exiftool-vendored.exe 12.80.0 → 12.82.1

package/bin/exiftool_files/lib/Time/Local.pm

@@ -5,13 +5,19 @@ use strict;
 use Carp ();
 use Exporter;
 
-our $VERSION = '1.28';
+our $VERSION = '1.30';
 
 use parent 'Exporter';
 
-our @EXPORT = qw( timegm timelocal );
-our @EXPORT_OK
-    = qw( timegm_modern timelocal_modern timegm_nocheck timelocal_nocheck );
+our @EXPORT    = qw( timegm timelocal );
+our @EXPORT_OK = qw(
+    timegm_modern
+    timelocal_modern
+    timegm_nocheck
+    timelocal_nocheck
+    timegm_posix
+    timelocal_posix
+);
 
 my @MonthDays = ( 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );
 
@@ -90,7 +96,7 @@ sub _daygm {
                     - int( $year / 100 )
                     + int( $year / 400 )
                     + int( ( ( $month * 306 ) + 5 ) / 10 ) ) - $Epoc;
-            }
+        }
     );
 }
 
@@ -109,7 +115,7 @@ sub timegm {
     if ( $Options{no_year_munging} ) {
         $year -= 1900;
     }
-    else {
+    elsif ( !$Options{posix_year} ) {
         if ( $year >= 1000 ) {
             $year -= 1900;
         }
@@ -175,6 +181,11 @@ sub timegm_modern {
     return &timegm;
 }
 
+sub timegm_posix {
+    local $Options{posix_year} = 1;
+    return &timegm;
+}
+
 sub timelocal {
     my $ref_t         = &timegm;
     my $loc_for_ref_t = _timegm( localtime($ref_t) );
@@ -204,8 +215,8 @@ sub timelocal {
 
     return $loc_t if $dst_off > 0;
 
-    # If the original date was a non-extent gap in a forward DST jump,
-    # we should now have the wrong answer - undo the DST adjustment
+    # If the original date was a non-existent gap in a forward DST jump, we
+    # should now have the wrong answer - undo the DST adjustment
     my ( $s, $m, $h ) = localtime($loc_t);
     $loc_t -= $dst_off if $s != $_[0] || $m != $_[1] || $h != $_[2];
 
@@ -222,6 +233,11 @@ sub timelocal_modern {
     return &timelocal;
 }
 
+sub timelocal_posix {
+    local $Options{posix_year} = 1;
+    return &timelocal;
+}
+
 1;
 
 # ABSTRACT: Efficiently compute time from local and GMT time
@@ -238,14 +254,14 @@ Time::Local - Efficiently compute time from local and GMT time
 
 =head1 VERSION
 
-version 1.28
+version 1.30
 
 =head1 SYNOPSIS
 
-    use Time::Local;
+    use Time::Local qw( timelocal_posix timegm_posix );
 
-    my $time = timelocal( $sec, $min, $hour, $mday, $mon, $year );
-    my $time = timegm( $sec, $min, $hour, $mday, $mon, $year );
+    my $time = timelocal_posix( $sec, $min, $hour, $mday, $mon, $year );
+    my $time = timegm_posix( $sec, $min, $hour, $mday, $mon, $year );
 
 =head1 DESCRIPTION
 
@@ -263,6 +279,32 @@ consistent with the values returned from C<localtime()> and C<gmtime()>.
 
 =head1 FUNCTIONS
 
+=head2 C<timelocal_posix()> and C<timegm_posix()>
+
+These functions are the exact inverse of Perl's built-in C<localtime> and
+C<gmtime> functions. That means that calling C<< timelocal_posix(
+localtime($value) ) >> will always give you the same C<$value> you started
+with. The same applies to C<< timegm_posix( gmtime($value) ) >>.
+
+The one exception is when the value returned from C<localtime()> represents an
+ambiguous local time because of a DST change. See the documentation below for
+more details.
+
+These functions expect the year value to be the number of years since 1900,
+which is what the C<localtime()> and C<gmtime()> built-ins returns.
+
+They perform range checking by default on the input C<$sec>, C<$min>,
+C<$hour>, C<$mday>, and C<$mon> values and will croak (using C<Carp::croak()>)
+if given a value outside the allowed ranges.
+
+While it would be nice to make this the default behavior, that would almost
+certainly break a lot of code, so you must explicitly import these functions
+and use them instead of the default C<timelocal()> and C<timegm()>.
+
+You are B<strongly> encouraged to use these functions in any new code which
+uses this module. It will almost certainly make your code's behavior less
+surprising.
+
 =head2 C<timelocal_modern()> and C<timegm_modern()>
 
 When C<Time::Local> was first written, it was a common practice to represent
@@ -274,41 +316,44 @@ The default exports of C<timelocal()> and C<timegm()> do a complicated
 calculation when given a year value less than 1000. This leads to surprising
 results in many cases. See L</Year Value Interpretation> for details.
 
-The C<time*_modern()> subs do not do this year munging and simply take the
-year value as provided.
-
-While it would be nice to make this the default behavior, that would almost
-certainly break a lot of code, so you must explicitly import these subs and
-use them instead of the default C<timelocal()> and C<timegm()>.
+The C<time*_modern()> functions do not do this year munging and simply take
+the year value as provided.
 
-You are B<strongly> encouraged to use these subs in any new code which uses
-this module. It will almost certainly make your code's behavior less
-surprising.
+They perform range checking by default on the input C<$sec>, C<$min>,
+C<$hour>, C<$mday>, and C<$mon> values and will croak (using C<Carp::croak()>)
+if given a value outside the allowed ranges.
 
 =head2 C<timelocal()> and C<timegm()>
 
 This module exports two functions by default, C<timelocal()> and C<timegm()>.
 
-The C<timelocal()> and C<timegm()> functions perform range checking on the
-input $sec, $min, $hour, $mday, and $mon values by default.
-
-=head2 C<timelocal_nocheck()> and C<timegm_nocheck()>
+They perform range checking by default on the input C<$sec>, C<$min>,
+C<$hour>, C<$mday>, and C<$mon> values and will croak (using C<Carp::croak()>)
+if given a value outside the allowed ranges.
 
-If you are working with data you know to be valid, you can speed your code up
-by using the "nocheck" variants, C<timelocal_nocheck()> and
-C<timegm_nocheck()>. These variants must be explicitly imported.
+B<Warning: The year value interpretation that these functions and their
+nocheck variants use will almost certainly lead to bugs in your code, if not
+now, then in the future. You are strongly discouraged from using these in new
+code, and you should convert old code to using either the C<*_posix> or
+C<*_modern> functions if possible.>
 
-    use Time::Local 'timelocal_nocheck';
+=head2 C<timelocal_nocheck()> and C<timegm_nocheck()>
 
-    # The 365th day of 1999
-    print scalar localtime timelocal_nocheck( 0, 0, 0, 365, 0, 99 );
+If you are working with data you know to be valid, you can use the "nocheck"
+variants, C<timelocal_nocheck()> and C<timegm_nocheck()>. These variants must
+be explicitly imported.
 
 If you supply data which is not valid (month 27, second 1,000) the results
 will be unpredictable (so don't do that).
 
+Note that my benchmarks show that this is just a 3% speed increase over the
+checked versions, so unless calling C<Time::Local> is the hottest spot in your
+application, using these nocheck variants is unlikely to have much impact on
+your application.
+
 =head2 Year Value Interpretation
 
-B<This does not apply to C<timelocal_modern> or C<timegm_modern>. Use those
+B<This does not apply to the C<*_posix> or C<*_modern> functions. Use those
 exports if you want to ensure consistent behavior as your code ages.>
 
 Strictly speaking, the year should be specified in a form consistent with
@@ -343,7 +388,9 @@ digit dates. Whenever possible, use an absolute four digit year instead.
 =back
 
 The scheme above allows interpretation of a wide range of dates, particularly
-if 4-digit years are used.
+if 4-digit years are used. But it also means that the behavior of your code
+changes as time passes, because the rolling "current century" changes each
+year.
 
 =head2 Limits of time_t
 
@@ -367,7 +414,7 @@ occurs for two different GMT times on the same day. For example, in the
 "Europe/Paris" time zone, the local time of 2001-10-28 02:30:00 can represent
 either 2001-10-28 00:30:00 GMT, B<or> 2001-10-28 01:30:00 GMT.
 
-When given an ambiguous local time, the timelocal() function should always
+When given an ambiguous local time, the timelocal() function will always
 return the epoch for the I<earlier> of the two possible GMT times.
 
 =head2 Non-Existent Local Times (DST)
@@ -457,7 +504,7 @@ Unknown <unknown@example.com>
 
 =head1 COPYRIGHT AND LICENSE
 
-This software is copyright (c) 1997 - 2018 by Graham Barr & Dave Rolsky.
+This software is copyright (c) 1997 - 2020 by Graham Barr & Dave Rolsky.
 
 This is free software; you can redistribute it and/or modify it under
 the same terms as the Perl 5 programming language system itself.

package/bin/exiftool_files/lib/Time/Piece.pm

@@ -19,7 +19,7 @@ our %EXPORT_TAGS = (
     ':override' => 'internal',
     );
 
-our $VERSION = '1.33';
+our $VERSION = '1.3401';
 
 XSLoader::load( 'Time::Piece', $VERSION );
 
@@ -126,6 +126,7 @@ sub _mktime {
     if ($class->_is_time_struct($time)) {
         my @new_time = @$time;
         my @tm_parts = (@new_time[c_sec .. c_mon], $new_time[c_year]+1900);
+
         $new_time[c_epoch] = $islocal ? timelocal(@tm_parts) : timegm(@tm_parts);
 
         return wantarray ? @new_time : bless [@new_time[0..9], $islocal], $class;
@@ -805,8 +806,14 @@ sub use_locale {
     #get locale month/day names from posix strftime (from Piece.xs)
     my $locales = _get_localization();
 
-    $locales->{PM} ||= '';
-    $locales->{AM} ||= '';
+    #If AM and PM are the same, set both to ''
+    if (   !$locales->{PM}
+        || !$locales->{AM}
+        || ( $locales->{PM} eq $locales->{AM} ) )
+    {
+        $locales->{PM} = '';
+        $locales->{AM} = '';
+    }
 
     $locales->{pm} = lc $locales->{PM};
     $locales->{am} = lc $locales->{AM};
@@ -896,7 +903,7 @@ in perlfunc will still return what you expect.
 
 The module actually implements most of an interface described by
 Larry Wall on the perl5-porters mailing list here:
-L<http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2000-01/msg00241.html>
+L<https://www.nntp.perl.org/group/perl.perl5.porters/2000/01/msg5283.html>
 
 =head1 USAGE
 
@@ -1152,6 +1159,14 @@ moves afoot to fix that in perl. Alternatively use 64 bit perl. Or if none
 of those are options, use the L<DateTime> module which has support for years
 well into the future and past.
 
+Also, the internal representation of Time::Piece->strftime deviates from the
+standard POSIX implementation in that is uses the epoch (instead of separate
+year, month, day parts). This change was added in version 1.30. If you must
+have a more traditional strftime (which will normally never calculate day
+light saving times correctly), you can pass the date parts from Time::Piece
+into the strftime function provided by the POSIX module
+(see strftime in L<POSIX> ).
+
 =head1 AUTHOR
 
 Matt Sergeant, matt@sergeant.org

package/bin/exiftool_files/lib/Time/Seconds.pm

@@ -1,7 +1,7 @@
 package Time::Seconds;
 use strict;
 
-our $VERSION = '1.33';
+our $VERSION = '1.3401';
 
 use Exporter 5.57 'import';
 

package/bin/exiftool_files/lib/UNIVERSAL.pm

@@ -0,0 +1,203 @@
+package UNIVERSAL;
+
+our $VERSION = '1.13';
+
+# UNIVERSAL should not contain any extra subs/methods beyond those
+# that it exists to define. The existence of import() below is a historical
+# accident that can't be fixed without breaking code.
+
+# Make sure that even though the import method is called, it doesn't do
+# anything unless called on UNIVERSAL.
+sub import {
+    return unless $_[0] eq __PACKAGE__;
+    return unless @_ > 1;
+    require Carp;
+    Carp::croak("UNIVERSAL does not export anything");
+}
+
+1;
+__END__
+
+=head1 NAME
+
+UNIVERSAL - base class for ALL classes (blessed references)
+
+=head1 SYNOPSIS
+
+    $is_io    = $fd->isa("IO::Handle");
+    $is_io    = Class->isa("IO::Handle");
+
+    $does_log = $obj->DOES("Logger");
+    $does_log = Class->DOES("Logger");
+
+    $sub      = $obj->can("print");
+    $sub      = Class->can("print");
+
+    $sub      = eval { $ref->can("fandango") };
+    $ver      = $obj->VERSION;
+
+    # but never do this!
+    $is_io    = UNIVERSAL::isa($fd, "IO::Handle");
+    $sub      = UNIVERSAL::can($obj, "print");
+
+=head1 DESCRIPTION
+
+C<UNIVERSAL> is the base class from which all blessed references inherit.
+See L<perlobj>.
+
+C<UNIVERSAL> provides the following methods:
+
+=over 4
+
+=item C<< $obj->isa( TYPE ) >>
+
+=item C<< CLASS->isa( TYPE ) >>
+
+=item C<< eval { VAL->isa( TYPE ) } >>
+
+Where
+
+=over 4
+
+=item C<TYPE>
+
+is a package name
+
+=item C<$obj>
+
+is a blessed reference or a package name
+
+=item C<CLASS>
+
+is a package name
+
+=item C<VAL>
+
+is any of the above or an unblessed reference
+
+=back
+
+When used as an instance or class method (C<< $obj->isa( TYPE ) >>),
+C<isa> returns I<true> if $obj is blessed into package C<TYPE> or
+inherits from package C<TYPE>.
+
+When used as a class method (C<< CLASS->isa( TYPE ) >>, sometimes
+referred to as a static method), C<isa> returns I<true> if C<CLASS>
+inherits from (or is itself) the name of the package C<TYPE> or
+inherits from package C<TYPE>.
+
+If you're not sure what you have (the C<VAL> case), wrap the method call in an
+C<eval> block to catch the exception if C<VAL> is undefined.
+
+If you want to be sure that you're calling C<isa> as a method, not a class,
+check the invocand with C<blessed> from L<Scalar::Util> first:
+
+  use Scalar::Util 'blessed';
+
+  if ( blessed( $obj ) && $obj->isa("Some::Class") ) {
+      ...
+  }
+
+=item C<< $obj->DOES( ROLE ) >>
+
+=item C<< CLASS->DOES( ROLE ) >>
+
+C<DOES> checks if the object or class performs the role C<ROLE>.  A role is a
+named group of specific behavior (often methods of particular names and
+signatures), similar to a class, but not necessarily a complete class by
+itself.  For example, logging or serialization may be roles.
+
+C<DOES> and C<isa> are similar, in that if either is true, you know that the
+object or class on which you call the method can perform specific behavior.
+However, C<DOES> is different from C<isa> in that it does not care I<how> the
+invocand performs the operations, merely that it does.  (C<isa> of course
+mandates an inheritance relationship.  Other relationships include aggregation,
+delegation, and mocking.)
+
+By default, classes in Perl only perform the C<UNIVERSAL> role, as well as the
+role of all classes in their inheritance.  In other words, by default C<DOES>
+responds identically to C<isa>.
+
+There is a relationship between roles and classes, as each class implies the
+existence of a role of the same name.  There is also a relationship between
+inheritance and roles, in that a subclass that inherits from an ancestor class
+implicitly performs any roles its parent performs.  Thus you can use C<DOES> in
+place of C<isa> safely, as it will return true in all places where C<isa> will
+return true (provided that any overridden C<DOES> I<and> C<isa> methods behave
+appropriately).
+
+=item C<< $obj->can( METHOD ) >>
+
+=item C<< CLASS->can( METHOD ) >>
+
+=item C<< eval { VAL->can( METHOD ) } >>
+
+C<can> checks if the object or class has a method called C<METHOD>. If it does,
+then it returns a reference to the sub.  If it does not, then it returns
+I<undef>.  This includes methods inherited or imported by C<$obj>, C<CLASS>, or
+C<VAL>.
+
+C<can> cannot know whether an object will be able to provide a method through
+AUTOLOAD (unless the object's class has overridden C<can> appropriately), so a
+return value of I<undef> does not necessarily mean the object will not be able
+to handle the method call. To get around this some module authors use a forward
+declaration (see L<perlsub>) for methods they will handle via AUTOLOAD. For
+such 'dummy' subs, C<can> will still return a code reference, which, when
+called, will fall through to the AUTOLOAD. If no suitable AUTOLOAD is provided,
+calling the coderef will cause an error.
+
+You may call C<can> as a class (static) method or an object method.
+
+Again, the same rule about having a valid invocand applies -- use an C<eval>
+block or C<blessed> if you need to be extra paranoid.
+
+=item C<VERSION ( [ REQUIRE ] )>
+
+C<VERSION> will return the value of the variable C<$VERSION> in the
+package the object is blessed into. If C<REQUIRE> is given then
+it will do a comparison and die if the package version is not
+greater than or equal to C<REQUIRE>, or if either C<$VERSION> or C<REQUIRE>
+is not a "lax" version number (as defined by the L<version> module).
+
+The return from C<VERSION> will actually be the stringified version object
+using the package C<$VERSION> scalar, which is guaranteed to be equivalent
+but may not be precisely the contents of the C<$VERSION> scalar.  If you want
+the actual contents of C<$VERSION>, use C<$CLASS::VERSION> instead.
+
+C<VERSION> can be called as either a class (static) method or an object
+method.
+
+=back
+
+=head1 WARNINGS
+
+B<NOTE:> C<can> directly uses Perl's internal code for method lookup, and
+C<isa> uses a very similar method and cache-ing strategy. This may cause
+strange effects if the Perl code dynamically changes @ISA in any package.
+
+You may add other methods to the UNIVERSAL class via Perl or XS code.
+You do not need to C<use UNIVERSAL> to make these methods
+available to your program (and you should not do so).
+
+=head1 EXPORTS
+
+None.
+
+Previous versions of this documentation suggested using C<isa> as
+a function to determine the type of a reference:
+
+  $yes = UNIVERSAL::isa($h, "HASH");
+  $yes = UNIVERSAL::isa("Foo", "Bar");
+
+The problem is that this code would I<never> call an overridden C<isa> method in
+any class.  Instead, use C<reftype> from L<Scalar::Util> for the first case:
+
+  use Scalar::Util 'reftype';
+
+  $yes = reftype( $h ) eq "HASH";
+
+and the method form of C<isa> for the second:
+
+  $yes = Foo->isa("Bar");
+
+=cut

package/bin/exiftool_files/lib/Unicode/GCString.pm

@@ -0,0 +1,60 @@
+#-*-perl-*-
+
+package Unicode::GCString;
+require 5.008;
+
+=encoding utf-8
+
+=cut
+
+### Pragmas:
+use strict;
+use warnings;
+use vars qw($VERSION @EXPORT_OK @ISA);
+
+### Exporting:
+use Exporter;
+our @EXPORT_OK = qw();
+our %EXPORT_TAGS = ('all' => [@EXPORT_OK]);
+
+### Inheritance:
+our @ISA = qw(Exporter);
+
+### Other modules:
+use Unicode::LineBreak;
+
+### Globals
+
+# The package version
+our $VERSION = '2013.10';
+
+use overload 
+    '@{}' => \&as_arrayref,
+    '${}' => \&as_scalarref,
+    '""' => \&as_string,
+    '.' => \&concat,
+    #XXX'.=' => \&concat, #FIXME:segfault
+    'cmp' => \&cmp,
+    '<>' => \&next,
+    ;
+
+sub new {
+    my $class = shift;
+
+    my $self;
+    if (scalar @_ <= 2) {
+        $self = __PACKAGE__->_new(@_);
+    } else {
+        my $str = shift;
+        my $lb = Unicode::LineBreak->new(@_);
+        $self = __PACKAGE__->_new($str, $lb);
+    }
+    bless $self, $class;
+}
+
+sub as_arrayref {
+    my @a = shift->as_array;
+    return \@a;
+}
+
+1;

package/bin/exiftool_files/lib/Unicode/LineBreak/Constants.pm

@@ -0,0 +1,68 @@
+#-*- perl -*-
+
+package Unicode::LineBreak;
+
+use constant { M => 4, D => 3, I => 2, P => 1,};
+use constant { MANDATORY => M, DIRECT => D, INDIRECT => I, PROHIBITED => P,
+               URGENT => 200,};
+
+use constant { ALLOW_BEFORE => 2, PROHIBIT_BEFORE => 1,
+               BREAK_BEFORE => 2, # deprecated.
+               FLAGS => (2 | 1) };
+
+use constant {
+    AMBIGUOUS_CYRILLIC => [0x0401, 0x0410..0x044F, 0x0451, ],
+    AMBIGUOUS_GREEK => [0x0391..0x03A9, 0x03B1..0x03C1, 0x03C3..0x03C9, ],
+    AMBIGUOUS_LATIN => [0x00C6, 0x00D0, 0x00D8, 0x00DE, 0x00DF, 0x00E0, 
+        0x00E1, 0x00E6, 0x00E8, 0x00E9, 0x00EA, 0x00EC, 0x00ED, 0x00F0, 
+        0x00F2, 0x00F3, 0x00F8, 0x00F9, 0x00FA, 0x00FC, 0x00FE, 0x0101, 
+        0x0111, 0x0113, 0x011B, 0x0126, 0x0127, 0x012B, 0x0131, 0x0132, 
+        0x0133, 0x0138, 0x013F, 0x0140, 0x0141, 0x0142, 0x0144, 0x0148, 
+        0x0149, 0x014A, 0x014B, 0x014D, 0x0152, 0x0153, 0x0166, 0x0167, 
+        0x016B, 0x01CE, 0x01D0, 0x01D2, 0x01D4, 0x01D6, 0x01D8, 0x01DA, 
+        0x01DC, 0x0251, 0x0261, ],
+    IDEOGRAPHIC_ITERATION_MARKS => [0x3005, 0x303B, 0x309D, 0x309E, 0x30FD, 
+        0x30FE, ],
+    KANA_PROLONGED_SOUND_MARKS => [0x30FC, 0xFF70, ],
+    KANA_SMALL_LETTERS => [0x3041, 0x3043, 0x3045, 0x3047, 0x3049, 0x3063, 
+        0x3083, 0x3085, 0x3087, 0x308E, 
+        0x3095, 0x3096, 
+        0x30A1, 0x30A3, 0x30A5, 0x30A7, 0x30A9, 0x30C3, 
+        0x30E3, 0x30E5, 0x30E7, 0x30EE, 
+        0x30F5, 0x30F6, 
+        0x31F0..0x31FF, 0xFF67..0xFF6F, ],
+    MASU_MARK => [0x303C, ],
+    QUESTIONABLE_NARROW_SIGNS => [0x00A2, 0x00A3, 0x00A5, 0x00A6, 0x00AC, 
+        0x00AF, ],
+};
+use constant {
+    AMBIGUOUS_ALPHABETICS => [
+        @{AMBIGUOUS_CYRILLIC()}, @{AMBIGUOUS_GREEK()},
+        @{AMBIGUOUS_LATIN()}, ],
+    KANA_NONSTARTERS => [
+        @{IDEOGRAPHIC_ITERATION_MARKS()}, @{KANA_PROLONGED_SOUND_MARKS()},
+        @{KANA_SMALL_LETTERS()}, @{MASU_MARK()}, ]
+};
+use constant {
+    BACKWORD_GUILLEMETS => [
+        0x00AB, 0x2039, ],
+    FORWARD_GUILLEMETS => [
+        0x00BB, 0x203A, ],
+    BACKWORD_QUOTES => [
+        0x2018, 0x201C, ],
+    FORWARD_QUOTES => [
+        0x2019, 0x201D, ],
+};
+# obsoleted names.
+use constant {
+    LEFT_GUILLEMETS => BACKWORD_GUILLEMETS(),
+    RIGHT_GUILLEMETS => FORWARD_GUILLEMETS(),
+    LEFT_QUOTES => BACKWORD_QUOTES(),
+    RIGHT_QUOTES => FORWARD_QUOTES(),
+};
+
+use constant {
+    IDEOGRAPHIC_SPACE => [ 0x3000, ],
+};
+
+1;