javonet-nodejs-sdk 2.1.1 → 2.1.2

package/Binaries/Perl/MacOs/X64/deps/lib/perl5/Time/Zone.pm

@@ -1,291 +0,0 @@
-
-package Time::Zone;
-
-=head1 NAME
-
-Time::Zone -- miscellaneous timezone manipulations routines
-
-=head1 SYNOPSIS
-
-	use Time::Zone;
-	print tz2zone();
-	print tz2zone($ENV{'TZ'});
-	print tz2zone($ENV{'TZ'}, time());
-	print tz2zone($ENV{'TZ'}, undef, $isdst);
-	$offset = tz_local_offset();
-	$offset = tz_offset($TZ);
-
-=head1 DESCRIPTION
-
-This is a collection of miscellaneous timezone manipulation routines.
-
-C<tz2zone()> parses the TZ environment variable and returns a timezone
-string suitable for inclusion in L<date(1)>-like output.  It opionally takes
-a timezone string, a time, and a is-dst flag.
-
-C<tz_local_offset()> determins the offset from GMT time in seconds.  It
-only does the calculation once.
-
-C<tz_offset()> determines the offset from GMT in seconds of a specified
-timezone.  
-
-C<tz_name()> determines the name of the timezone based on its offset
-
-=head1 AUTHORS
-
-Graham Barr <gbarr@pobox.com>
-David Muir Sharnoff <muir@idiom.com>
-Paul Foley <paul@ascent.com>
-
-=cut
-
-require 5.002;
-
-require Exporter;
-use Carp;
-use strict;
-use vars qw(@ISA @EXPORT $VERSION @tz_local);
-
-@ISA = qw(Exporter);
-@EXPORT = qw(tz2zone tz_local_offset tz_offset tz_name);
-$VERSION = "2.24";
-
-# Parts stolen from code by Paul Foley <paul@ascent.com>
-
-sub tz2zone (;$$$)
-{
-	my($TZ, $time, $isdst) = @_;
-
-	use vars qw(%tzn_cache);
-
-	$TZ = defined($ENV{'TZ'}) ? ( $ENV{'TZ'} ? $ENV{'TZ'} : 'GMT' ) : ''
-	    unless $TZ;
-
-	# Hack to deal with 'PST8PDT' format of TZ
-	# Note that this can't deal with all the esoteric forms, but it
-	# does recognize the most common: [:]STDoff[DST[off][,rule]]
-
-	if (! defined $isdst) {
-		my $j;
-		$time = time() unless $time;
-		($j, $j, $j, $j, $j, $j, $j, $j, $isdst) = localtime($time);
-	}
-
-	if (defined $tzn_cache{$TZ}->[$isdst]) {
-		return $tzn_cache{$TZ}->[$isdst];
-	}
-      
-	if ($TZ =~ /^
-		    ( [^:\d+\-,] {3,} )
-		    ( [+-] ?
-		      \d {1,2}
-		      ( : \d {1,2} ) {0,2} 
-		    )
-		    ( [^\d+\-,] {3,} )?
-		    /x
-	    ) {
-		my $dsttz = defined($4) ? $4 : $1;
-		$TZ = $isdst ? $dsttz : $1;
-		$tzn_cache{$TZ} = [ $1, $dsttz ];
-	} else {
-		$tzn_cache{$TZ} = [ $TZ, $TZ ];
-	}
-	return $TZ;
-}
-
-sub tz_local_offset (;$)
-{
-	my ($time) = @_;
-
-	$time = time() unless $time;
-	my (@l) = localtime($time);
-	my $isdst = $l[8];
-
-	if (defined($tz_local[$isdst])) {
-		return $tz_local[$isdst];
-	}
-
-	$tz_local[$isdst] = &calc_off($time);
-
-	return $tz_local[$isdst];
-}
-
-sub calc_off
-{
-	my ($time) = @_;
-
-	my (@l) = localtime($time);
-	my (@g) = gmtime($time);
-
-	my $off;
-
-	$off =     $l[0] - $g[0]
-		+ ($l[1] - $g[1]) * 60
-		+ ($l[2] - $g[2]) * 3600;
-
-	# subscript 7 is yday.
-
-	if ($l[7] == $g[7]) {
-		# done
-	} elsif ($l[7] == $g[7] + 1) {
-		$off += 86400;
-	} elsif ($l[7] == $g[7] - 1) {
-		$off -= 86400;
-	} elsif ($l[7] < $g[7]) {
-		# crossed over a year boundry!
-		# localtime is beginning of year, gmt is end
-		# therefore local is ahead
-		$off += 86400;
-	} else {
-		$off -= 86400;
-	}
-
-	return $off;
-}
-
-# constants
-
-CONFIG: {
-	use vars qw(%dstZone %zoneOff %dstZoneOff %Zone);
-
-	my @dstZone = (
-	#   "ndt"  =>   -2*3600-1800,	 # Newfoundland Daylight   
-	    "brst" =>   -2*3600,         # Brazil Summer Time (East Daylight)
-	    "adt"  =>   -3*3600,  	 # Atlantic Daylight   
-	    "edt"  =>   -4*3600,  	 # Eastern Daylight
-	    "cdt"  =>   -5*3600,  	 # Central Daylight
-	    "mdt"  =>   -6*3600,  	 # Mountain Daylight
-	    "pdt"  =>   -7*3600,  	 # Pacific Daylight
-	    "akdt" =>   -8*3600,         # Alaska Daylight
-	    "ydt"  =>   -8*3600,  	 # Yukon Daylight
-	    "hdt"  =>   -9*3600,  	 # Hawaii Daylight
-	    "bst"  =>   +1*3600,  	 # British Summer   
-	    "mest" =>   +2*3600,  	 # Middle European Summer   
-	    "metdst" => +2*3600, 	 # Middle European DST
-	    "sst"  =>   +2*3600,  	 # Swedish Summer
-	    "fst"  =>   +2*3600,  	 # French Summer
-            "cest" =>   +2*3600,         # Central European Daylight
-            "eest" =>   +3*3600,         # Eastern European Summer
-            "msd"  =>   +4*3600,         # Moscow Daylight
-	    "wadt" =>   +8*3600,  	 # West Australian Daylight
-	    "kdt"  =>  +10*3600,	 # Korean Daylight
-	#   "cadt" =>  +10*3600+1800,	 # Central Australian Daylight
-	    "aedt" =>  +11*3600,  	 # Eastern Australian Daylight
-	    "eadt" =>  +11*3600,  	 # Eastern Australian Daylight
-	    "nzd"  =>  +13*3600,  	 # New Zealand Daylight   
-	    "nzdt" =>  +13*3600,  	 # New Zealand Daylight   
-	);
-
-	my @Zone = (
-	    "gmt"	=>   0,  	 # Greenwich Mean
-	    "ut"        =>   0,  	 # Universal (Coordinated)
-	    "utc"       =>   0,
-	    "wet"       =>   0,  	 # Western European
-	    "wat"       =>  -1*3600,	 # West Africa
-	    "at"        =>  -2*3600,	 # Azores
-	    "fnt"	=>  -2*3600,	 # Brazil Time (Extreme East - Fernando Noronha)
-	    "brt"	=>  -3*3600,	 # Brazil Time (East Standard - Brasilia)
-	# For completeness.  BST is also British Summer, and GST is also Guam Standard.
-	#   "bst"       =>  -3*3600,	 # Brazil Standard
-	#   "gst"       =>  -3*3600,	 # Greenland Standard
-	#   "nft"       =>  -3*3600-1800,# Newfoundland
-	#   "nst"       =>  -3*3600-1800,# Newfoundland Standard
-	    "mnt"	=>  -4*3600,	 # Brazil Time (West Standard - Manaus)
-	    "ewt"       =>  -4*3600,	 # U.S. Eastern War Time
-	    "ast"       =>  -4*3600,	 # Atlantic Standard
-	    "est"       =>  -5*3600,	 # Eastern Standard
-	    "act"	=>  -5*3600,	 # Brazil Time (Extreme West - Acre)
-	    "cst"       =>  -6*3600,	 # Central Standard
-	    "mst"       =>  -7*3600,	 # Mountain Standard
-	    "pst"       =>  -8*3600,	 # Pacific Standard
-	    "akst"      =>  -9*3600,     # Alaska Standard
-	    "yst"	=>  -9*3600,	 # Yukon Standard
-	    "hst"	=> -10*3600,	 # Hawaii Standard
-	    "cat"	=> -10*3600,	 # Central Alaska
-	    "ahst"	=> -10*3600,	 # Alaska-Hawaii Standard
-	    "nt"	=> -11*3600,	 # Nome
-	    "idlw"	=> -12*3600,	 # International Date Line West
-	    "cet"	=>  +1*3600, 	 # Central European
-	    "mez"	=>  +1*3600, 	 # Central European (German)
-	    "ect"	=>  +1*3600, 	 # Central European (French)
-	    "met"	=>  +1*3600, 	 # Middle European
-	    "mewt"	=>  +1*3600, 	 # Middle European Winter
-	    "swt"	=>  +1*3600, 	 # Swedish Winter
-	    "set"	=>  +1*3600, 	 # Seychelles
-	    "fwt"	=>  +1*3600, 	 # French Winter
-	    "eet"	=>  +2*3600, 	 # Eastern Europe, USSR Zone 1
-	    "ukr"	=>  +2*3600, 	 # Ukraine
-	    "bt"	=>  +3*3600, 	 # Baghdad, USSR Zone 2
-            "msk"       =>  +3*3600,     # Moscow
-	#   "it"	=>  +3*3600+1800,# Iran
-	    "zp4"	=>  +4*3600, 	 # USSR Zone 3
-	    "zp5"	=>  +5*3600, 	 # USSR Zone 4
-	#   "ist"	=>  +5*3600+1800,# Indian Standard
-	    "zp6"	=>  +6*3600, 	 # USSR Zone 5
-	# For completeness.  NST is also Newfoundland Stanard, and SST is also Swedish Summer.
-	#   "nst"	=>  +6*3600+1800,# North Sumatra
-	#   "sst"	=>  +7*3600, 	 # South Sumatra, USSR Zone 6
-	#   "jt"	=>  +7*3600+1800,# Java (3pm in Cronusland!)
-	    "wst"	=>  +8*3600, 	 # West Australian Standard
-	    "hkt"	=>  +8*3600, 	 # Hong Kong
-	    "cct"	=>  +8*3600, 	 # China Coast, USSR Zone 7
-	    "jst"	=>  +9*3600,	 # Japan Standard, USSR Zone 8
-	    "kst"	=>  +9*3600,	 # Korean Standard
-	#   "cast"	=>  +9*3600+1800,# Central Australian Standard
-	    "aest"	=> +10*3600,	 # Eastern Australian Standard
-	    "east"	=> +10*3600,	 # Eastern Australian Standard
-	    "gst"	=> +10*3600,	 # Guam Standard, USSR Zone 9
-	    "nzt"	=> +12*3600,	 # New Zealand
-	    "nzst"	=> +12*3600,	 # New Zealand Standard
-	    "idle"	=> +12*3600,	 # International Date Line East
-	);
-
-	%Zone = @Zone;
-	%dstZone = @dstZone;
-	%zoneOff = reverse(@Zone);
-	%dstZoneOff = reverse(@dstZone);
-
-}
-
-sub tz_offset (;$$)
-{
-	my ($zone, $time) = @_;
-
-	return &tz_local_offset($time) unless($zone);
-
-	$time = time() unless $time;
-	my(@l) = localtime($time);
-	my $dst = $l[8];
-
-	$zone = lc $zone;
-
-	if($zone =~ /^(([\-\+])\d\d?)(\d\d)$/) {
-		my $v = $2 . $3;
-		return $1 * 3600 + $v * 60;
-	} elsif (exists $dstZone{$zone} && ($dst || !exists $Zone{$zone})) {
-		return $dstZone{$zone};
-	} elsif(exists $Zone{$zone}) {
-		return $Zone{$zone};
-	}
-	undef;
-}
-
-sub tz_name (;$$)
-{
-	my ($off, $dst) = @_;
-
-	$off = tz_offset()
-		unless(defined $off);
-
-	$dst = (localtime(time))[8]
-		unless(defined $dst);
-
-	if (exists $dstZoneOff{$off} && ($dst || !exists $zoneOff{$off})) {
-		return $dstZoneOff{$off};
-	} elsif (exists $zoneOff{$off}) {
-		return $zoneOff{$off};
-	}
-	sprintf("%+05d", int($off / 60) * 100 + $off % 60);
-}
-
-1;

package/Binaries/Perl/MacOs/X64/deps/lib/perl5/TimeDate.pm

@@ -1,16 +0,0 @@
-package TimeDate;
-
-use vars qw($VERSION);
-
-$VERSION = "1.21";
-
-=pod
-
-This is an empty module which is just there to get ownership on TimeDate
-using first-come permissions from PAUSE.
-
-This was required during the release of 1.21 for transferring ownership.
-
-=cut
-
-1;

package/Binaries/Perl/MacOs/X64/deps/lib/perl5/URI/Escape.pm

@@ -1,248 +0,0 @@
-package URI::Escape;
-
-use strict;
-use warnings;
-
-=head1 NAME
-
-URI::Escape - Percent-encode and percent-decode unsafe characters
-
-=head1 SYNOPSIS
-
- use URI::Escape;
- $safe = uri_escape("10% is enough\n");
- $verysafe = uri_escape("foo", "\0-\377");
- $str  = uri_unescape($safe);
-
-=head1 DESCRIPTION
-
-This module provides functions to percent-encode and percent-decode URI strings as
-defined by RFC 3986. Percent-encoding URI's is informally called "URI escaping".
-This is the terminology used by this module, which predates the formalization of the
-terms by the RFC by several years.
-
-A URI consists of a restricted set of characters.  The restricted set
-of characters consists of digits, letters, and a few graphic symbols
-chosen from those common to most of the character encodings and input
-facilities available to Internet users.  They are made up of the
-"unreserved" and "reserved" character sets as defined in RFC 3986.
-
-   unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
-   reserved      = ":" / "/" / "?" / "#" / "[" / "]" / "@"
-                   "!" / "$" / "&" / "'" / "(" / ")"
-                 / "*" / "+" / "," / ";" / "="
-
-In addition, any byte (octet) can be represented in a URI by an escape
-sequence: a triplet consisting of the character "%" followed by two
-hexadecimal digits.  A byte can also be represented directly by a
-character, using the US-ASCII character for that octet.
-
-Some of the characters are I<reserved> for use as delimiters or as
-part of certain URI components.  These must be escaped if they are to
-be treated as ordinary data.  Read RFC 3986 for further details.
-
-The functions provided (and exported by default) from this module are:
-
-=over 4
-
-=item uri_escape( $string )
-
-=item uri_escape( $string, $unsafe )
-
-Replaces each unsafe character in the $string with the corresponding
-escape sequence and returns the result.  The $string argument should
-be a string of bytes.  The uri_escape() function will croak if given a
-characters with code above 255.  Use uri_escape_utf8() if you know you
-have such chars or/and want chars in the 128 .. 255 range treated as
-UTF-8.
-
-The uri_escape() function takes an optional second argument that
-overrides the set of characters that are to be escaped.  The set is
-specified as a string that can be used in a regular expression
-character class (between [ ]).  E.g.:
-
-  "\x00-\x1f\x7f-\xff"          # all control and hi-bit characters
-  "a-z"                         # all lower case characters
-  "^A-Za-z"                     # everything not a letter
-
-The default set of characters to be escaped is all those which are
-I<not> part of the C<unreserved> character class shown above as well
-as the reserved characters.  I.e. the default is:
-
-    "^A-Za-z0-9\-\._~"
-
-The second argument can also be specified as a regular expression object:
-
-  qr/[^A-Za-z]/
-
-Any strings matched by this regular expression will have all of their
-characters escaped.
-
-=item uri_escape_utf8( $string )
-
-=item uri_escape_utf8( $string, $unsafe )
-
-Works like uri_escape(), but will encode chars as UTF-8 before
-escaping them.  This makes this function able to deal with characters
-with code above 255 in $string.  Note that chars in the 128 .. 255
-range will be escaped differently by this function compared to what
-uri_escape() would.  For chars in the 0 .. 127 range there is no
-difference.
-
-Equivalent to:
-
-    utf8::encode($string);
-    my $uri = uri_escape($string);
-
-Note: JavaScript has a function called escape() that produces the
-sequence "%uXXXX" for chars in the 256 .. 65535 range.  This function
-has really nothing to do with URI escaping but some folks got confused
-since it "does the right thing" in the 0 .. 255 range.  Because of
-this you sometimes see "URIs" with these kind of escapes.  The
-JavaScript encodeURIComponent() function is similar to uri_escape_utf8().
-
-=item uri_unescape($string,...)
-
-Returns a string with each %XX sequence replaced with the actual byte
-(octet).
-
-This does the same as:
-
-   $string =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg;
-
-but does not modify the string in-place as this RE would.  Using the
-uri_unescape() function instead of the RE might make the code look
-cleaner and is a few characters less to type.
-
-In a simple benchmark test I did,
-calling the function (instead of the inline RE above) if a few chars
-were unescaped was something like 40% slower, and something like 700% slower if none were.  If
-you are going to unescape a lot of times it might be a good idea to
-inline the RE.
-
-If the uri_unescape() function is passed multiple strings, then each
-one is returned unescaped.
-
-=back
-
-The module can also export the C<%escapes> hash, which contains the
-mapping from all 256 bytes to the corresponding escape codes.  Lookup
-in this hash is faster than evaluating C<sprintf("%%%02X", ord($byte))>
-each time.
-
-=head1 SEE ALSO
-
-L<URI>
-
-
-=head1 COPYRIGHT
-
-Copyright 1995-2004 Gisle Aas.
-
-This program is free software; you can redistribute it and/or modify
-it under the same terms as Perl itself.
-
-=cut
-
-use Exporter 5.57 'import';
-our %escapes;
-our @EXPORT = qw(uri_escape uri_unescape uri_escape_utf8);
-our @EXPORT_OK = qw(%escapes);
-our $VERSION = '5.17';
-
-use Carp ();
-
-# Build a char->hex map
-for (0..255) {
-    $escapes{chr($_)} = sprintf("%%%02X", $_);
-}
-
-my %subst;  # compiled patterns
-
-my %Unsafe = (
-    RFC2732 => qr/[^A-Za-z0-9\-_.!~*'()]/,
-    RFC3986 => qr/[^A-Za-z0-9\-\._~]/,
-);
-
-sub uri_escape {
-    my($text, $patn) = @_;
-    return undef unless defined $text;
-    my $re;
-    if (defined $patn){
-        if (ref $patn eq 'Regexp') {
-            $text =~ s{($patn)}{
-                join('', map +($escapes{$_} || _fail_hi($_)), split //, "$1")
-            }ge;
-            return $text;
-        }
-        $re = $subst{$patn};
-        if (!defined $re) {
-            $re = $patn;
-            # we need to escape the [] characters, except for those used in
-            # posix classes. if they are prefixed by a backslash, allow them
-            # through unmodified.
-            $re =~ s{(\[:\w+:\])|(\\)?([\[\]]|\\\z)}{
-                defined $1 ? $1 : defined $2 ? "$2$3" : "\\$3"
-            }ge;
-            eval {
-                # disable the warnings here, since they will trigger later
-                # when used, and we only want them to appear once per call,
-                # but every time the same pattern is used.
-                no warnings 'regexp';
-                $re = $subst{$patn} = qr{[$re]};
-                1;
-            } or Carp::croak("uri_escape: $@");
-        }
-    }
-    else {
-        $re = $Unsafe{RFC3986};
-    }
-    $text =~ s/($re)/$escapes{$1} || _fail_hi($1)/ge;
-    $text;
-}
-
-sub _fail_hi {
-    my $chr = shift;
-    Carp::croak(sprintf "Can't escape \\x{%04X}, try uri_escape_utf8() instead", ord($chr));
-}
-
-sub uri_escape_utf8 {
-    my $text = shift;
-    return undef unless defined $text;
-    utf8::encode($text);
-    return uri_escape($text, @_);
-}
-
-sub uri_unescape {
-    # Note from RFC1630:  "Sequences which start with a percent sign
-    # but are not followed by two hexadecimal characters are reserved
-    # for future extension"
-    my $str = shift;
-    if (@_ && wantarray) {
-        # not executed for the common case of a single argument
-        my @str = ($str, @_);  # need to copy
-        for (@str) {
-            s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg;
-        }
-        return @str;
-    }
-    $str =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg if defined $str;
-    $str;
-}
-
-# XXX FIXME escape_char is buggy as it assigns meaning to the string's storage format.
-sub escape_char {
-    # Old versions of utf8::is_utf8() didn't properly handle magical vars (e.g. $1).
-    # The following forces a fetch to occur beforehand.
-    my $dummy = substr($_[0], 0, 0);
-
-    if (utf8::is_utf8($_[0])) {
-        my $s = shift;
-        utf8::encode($s);
-        unshift(@_, $s);
-    }
-
-    return join '', @URI::Escape::escapes{split //, $_[0]};
-}
-
-1;