javonet-nodejs-sdk 2.5.9 → 2.5.10

package/Binaries/Perl/Linux/X64/deps/bin/yamlpp-load-dump

@@ -0,0 +1,303 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+use YAML::PP;
+use YAML::PP::Dumper;
+use YAML::PP::Common qw/
+    :PRESERVE
+/;
+use Encode;
+use Getopt::Long;
+Getopt::Long::Configure('bundling');
+
+GetOptions(
+    'help|h' => \my $help,
+    'boolean=s' => \my $boolean,
+    'cyclic' => \my $cyclic,
+    'indent=i' => \my $indent,
+    'width=i' => \my $width,
+    'header!' => \my $header,
+    'footer!' => \my $footer,
+    'merge' => \my $merge,
+    'perl' => \my $perl,
+    'preserve|P=s' => \my $preserve,
+    'module|M=s' => \my $module,
+    'dump-module|D=s' => \my $dump_module,
+    'include' => \my $include,
+    'include-absolute' => \my $include_absolute,
+    'yaml-version=s' => \my $yaml_version,
+    'version-directive' => \my $version_directive,
+) or usage(1);
+
+usage(0) if $help;
+
+$module ||= 'YAML::PP';
+$boolean ||= 'JSON::PP';
+$footer ||= 0;
+$indent ||= 2;
+$yaml_version ||= 1.2;
+$dump_module ||= $module;
+if ($dump_module eq 'YAML::PP::Ref') {
+    $dump_module = 'YAML::PP';
+}
+my @yaml_versions = split m/,/, $yaml_version;
+my @schema = ('+');
+if ($merge) {
+    push @schema, 'Merge';
+}
+if ($perl) {
+    push @schema, 'Perl';
+}
+
+my $preserve_order = 1;
+if (defined $preserve) {
+    $preserve_order = 0;
+    my @split = split m/,/, $preserve;
+    $preserve = 0;
+    for my $split (@split) {
+        $preserve |= PRESERVE_ORDER if $split eq 'order';
+        $preserve_order = 1 if $split eq 'order';
+        $preserve |= PRESERVE_SCALAR_STYLE if $split eq 'scalar';
+        $preserve |= PRESERVE_FLOW_STYLE if $split eq 'flow';
+        $preserve |= PRESERVE_ALIAS if $split eq 'alias';
+    }
+}
+elsif ($dump_module =~ m/JSON/) {
+    $preserve = PRESERVE_ORDER;
+}
+else {
+    $preserve = 1;
+}
+$header = 1 unless defined $header;
+
+my ($file) = @ARGV;
+my $yaml;
+
+my $decode = 1;
+if ($module eq 'YAML::XS') {
+    $decode = 0;
+}
+if ($file) {
+    open my $fh, '<', $file or die "Can not open '$file'";
+    $yaml = do { local $/; <$fh> };
+    close $fh;
+}
+else {
+    $yaml = do { local $/; <STDIN> };
+}
+$yaml = decode_utf8($yaml) if $decode;
+
+my %load_modules = (
+    'YAML::PP' => \&yamlpp,
+    'YAML::PP::LibYAML' => \&yamlpplibyaml,
+    'YAML::PP::Ref' => \&yamlppref,
+    'YAML::XS' => \&yamlxs,
+    'YAML::Tiny' => \&yamltiny,
+    'YAML::Syck' => \&yamlsyck,
+    'YAML' => \&yaml,
+);
+my %dump_modules = (
+    'YAML::PP' => \&yamlpp_dump,
+    'YAML::PP::LibYAML' => \&yamlpplibyaml_dump,
+    'YAML::XS' => \&yamlxs_dump,
+    'YAML::Tiny' => \&yamltiny_dump,
+    'YAML::Syck' => \&yamlsyck_dump,
+    'YAML' => \&yaml_dump,
+    'Data::Dumper' => \&data_dumper,
+    'JSON::PP' => \&json_pp_dump,
+    'JSON::XS' => \&json_xs_dump,
+    'Cpanel::JSON::XS' => \&cpanel_json_xs_dump,
+);
+
+my $code = $load_modules{ $module } or die "Module '$module' not supported for loading";
+my $dump_code = $dump_modules{ $dump_module } or die "Module '$dump_module' not supported for dumping";
+
+my $docs = $code->($yaml, $file);
+my $out_yaml = $dump_code->($docs);
+
+sub _yamlpp {
+    my ($class, $yaml, $file) = @_;
+    my %args;
+    my $inc;
+    if ($include) {
+        require YAML::PP::Schema::Include;
+        $inc = YAML::PP::Schema::Include->new(
+            $include_absolute ? (allow_absolute => 1) : (),
+        );
+        push @schema, $inc;
+    }
+    my $ypp = $class->new(
+        schema => \@schema,
+        boolean => $boolean,
+        cyclic_refs => $cyclic ? 'allow' : 'fatal',
+        preserve => $preserve,
+        indent => $indent,
+        width => $width,
+        header => $header ? 1 : 0,
+        footer => $footer ? 1 : 0,
+        yaml_version => \@yaml_versions,
+        version_directive => $version_directive || 0,
+    );
+    if ($inc) {
+        $inc->yp($ypp);
+    }
+    my @docs = $file ? $ypp->load_file($file) : $ypp->load_string($yaml);
+    return \@docs;
+}
+sub yamlpp {
+    _yamlpp('YAML::PP' => @_);
+}
+sub yamlpp_dump {
+    _yamlpp_dump('YAML::PP' => @_);
+}
+sub yamlpplibyaml {
+    eval { require YAML::PP::LibYAML };
+    _yamlpp('YAML::PP::LibYAML' => @_);
+}
+sub yamlppref {
+    eval { require YAML::PP::Ref };
+    _yamlpp('YAML::PP::Ref' => @_);
+}
+sub yamlpplibyaml_dump {
+    eval { require YAML::PP::LibYAML };
+    _yamlpp_dump('YAML::PP::LibYAML' => @_);
+}
+sub _yamlpp_dump {
+    my ($class, $docs) = @_;
+    my $ypp = $class->new(
+        schema => \@schema,
+        boolean => $boolean,
+        preserve => $preserve,
+        indent => $indent,
+        width => $width,
+        header => $header ? 1 : 0,
+        footer => $footer ? 1 : 0,
+        yaml_version => \@yaml_versions,
+        version_directive => $version_directive || 0,
+    );
+    return $ypp->dump_string(@$docs);
+}
+
+sub yamlxs {
+    eval { require YAML::XS };
+    my ($yaml) = @_;
+    no warnings 'once';
+    local $YAML::XS::LoadBlessed = $perl;
+    my @docs = YAML::XS::Load($yaml);
+    return \@docs;
+}
+sub yamlxs_dump {
+    my ($docs) = @_;
+    eval { require YAML::XS };
+    no warnings 'once';
+    local $YAML::XS::Indent = $indent;
+    return YAML::XS::Dump(@$docs);
+}
+sub yamlsyck {
+    eval { require YAML::Syck };
+    my ($yaml) = @_;
+    no warnings 'once';
+    local $YAML::Syck::LoadBlessed = $perl;
+    local $YAML::Syck::ImplicitTyping = 1;
+    local $YAML::Syck::ImplicitUnicode = 1;
+    my @docs = YAML::Syck::Load($yaml);
+    return \@docs;
+}
+sub yamlsyck_dump {
+    eval { require YAML::Syck };
+    my ($docs) = @_;
+    no warnings 'once';
+    local $YAML::Syck::Headless = 1 unless $header;
+    local $YAML::Syck::ImplicitTyping = 1;
+    local $YAML::Syck::ImplicitUnicode = 1;
+    return YAML::Syck::Dump(@$docs);
+}
+sub yaml {
+    eval { require YAML };
+    no warnings 'once';
+    local $YAML::LoadBlessed = $perl;
+    my ($yaml) = @_;
+    my @docs = YAML::Load($yaml);
+    return \@docs;
+}
+sub yaml_dump {
+    my ($docs) = @_;
+    eval { require YAML };
+    no warnings 'once';
+    local $YAML::UseHeader = $header ? 1 : 0;
+    local $YAML::Indent = $indent;
+    return YAML::Dump(@$docs);
+}
+sub yamltiny {
+    eval { require YAML::Tiny };
+    my ($yaml) = @_;
+    my @docs = YAML::Tiny::Load($yaml);
+    return \@docs;
+}
+sub yamltiny_dump {
+    eval { require YAML::Tiny };
+    my ($docs) = @_;
+    return YAML::Tiny::Dump(@$docs);
+}
+sub data_dumper {
+    my ($docs) = @_;
+    local $Data::Dumper::Useqq = 1;
+    local $Data::Dumper::Sortkeys = 1 unless $preserve_order;
+    my $out = '';
+    $out .= Data::Dumper->Dump([$docs->[ $_ ]], ["doc$_"]) for 0 ..$#$docs;
+    return $out;
+}
+sub json_pp_dump { require JSON::PP; _json_dump('JSON::PP', @_) }
+sub json_xs_dump { require JSON::XS; _json_dump('JSON::XS', @_) }
+sub cpanel_json_xs_dump { require Cpanel::JSON::XS; _json_dump('Cpanel::JSON::XS', @_) }
+sub _json_dump {
+    my ($class, $docs) = @_;
+    my $coder = $class->new->ascii->pretty->allow_nonref->space_before(0);
+    $coder = $coder->indent_length($indent) if $coder->can('indent_length');
+    $coder = $coder->canonical unless $preserve_order;
+    my $out = '';
+    $out .= $coder->encode($docs->[ $_ ]) for 0 ..$#$docs;
+    return $out;
+}
+
+if ($decode) {
+    print encode_utf8 $out_yaml;
+}
+else {
+    print $out_yaml;
+}
+
+sub usage {
+    my ($rc) = @_;
+    print <<"EOM";
+Usage:
+
+    $0 [options] < file
+    $0 [options] file
+
+Options:
+    --boolean=            'perl', 'JSON::PP', 'boolean'
+    --cyclic              Allow cyclic references
+    --indent=             Number of spaces for indentation
+    --width=              Maximum column width (only used in flow style for now)
+    --[no-]header         Print '---' (default)
+    --[no-]footer         Print '...'
+    --merge               Enable loading merge keys '<<'
+    --perl                Enable loading perl types and objects (use only
+                          on trusted input!)
+    --preserve, -P        Comma separated: 'order', 'scalar', 'flow', 'alias'.
+                          Set to 0 to preserve nothing.
+                          By default all things are preserved
+    --module -M           YAML::PP (default), YAML, YAML::PP::LibYAML,
+                          YAML::Syck, YAML::Tiny, YAML::XS, YAML::PP::Ref
+    --dump-module -D      All of the above plus Data::Dumper, JSON::PP,
+                          JSON::XS, Cpanel::JSON::XS
+    --yaml-version=       '1.2' (default), '1.1', '1.2,1.1', '1.1,1.2'
+    --version-directive   Print '%YAML <version>'
+    --include             Enable Include Schema
+    --include-absolute    Allow absolute paths and ../../../ in includes (use
+                          only on trusted input!)
+EOM
+    exit $rc;
+}

package/Binaries/Perl/Linux/X64/deps/bin/yamlpp-parse-emit

@@ -0,0 +1,123 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+use YAML::PP;
+use YAML::PP::Common qw/ YAML_FLOW_SEQUENCE_STYLE YAML_FLOW_MAPPING_STYLE /;
+use YAML::PP::Parser;
+use YAML::PP::Emitter;
+use YAML::PP::Writer;
+use Data::Dumper;
+use Encode;
+use Getopt::Long;
+Getopt::Long::Configure('bundling');
+GetOptions(
+    'help|h' => \my $help,
+    'indent=i' => \my $indent,
+    'module|M=s' => \my $module,
+    'dump|D=s' => \my $emit,
+    'verbose' => \my $verbose,
+    'flow=s' => \my $flow,
+    'width=i' => \my $width,
+) or usage(1);
+
+usage(0) if $help;
+
+$module ||= 'YAML::PP';
+$emit ||= $module;
+
+$flow ||= 'no';
+
+my ($file) = @ARGV;
+my $yaml;
+
+if ($file) {
+    open my $fh, '<', $file or die $!;
+    $yaml = do { local $/; <$fh> };
+    close $fh;
+}
+else {
+    $yaml = do { local $/; <STDIN> };
+}
+$yaml = decode_utf8($yaml);
+
+if ($emit eq 'YAML::PP::Ref') {
+    $emit = 'YAML::PP';
+}
+my $parserclass = 'YAML::PP::Parser';
+my $emitterclass = 'YAML::PP::Emitter';
+if ($module eq 'YAML::PP::LibYAML') {
+    eval { require YAML::PP::LibYAML } or die "Module $module not supported: $@";
+    $parserclass = 'YAML::PP::LibYAML::Parser';
+    $emitterclass = 'YAML::PP::LibYAML::Emitter';
+}
+elsif ($module eq 'YAML::PP::Ref') {
+    eval { require YAML::PP::Ref } or die "Module $module not supported: $@";
+    $parserclass = 'YAML::PP::Ref::Parser';
+}
+if ($emit eq 'YAML::PP::LibYAML') {
+    eval { require YAML::PP::LibYAML } or die "Module $emit not supported: $@";
+    $emitterclass = 'YAML::PP::LibYAML::Emitter';
+}
+
+my @events;
+my $parser = $parserclass->new(
+    receiver => sub {
+        my ($self, undef, $event) = @_;
+        push @events, $event;
+    },
+);
+eval {
+    $parser->parse_string($yaml);
+};
+if ($@) {
+    for (@events) {
+        print YAML::PP::Common::event_to_test_suite($_) ."\n";
+    }
+    warn "Error parsing: $@";
+    exit 1;
+}
+my $writer = YAML::PP::Writer->new;
+my $emitter = $emitterclass->new( indent => $indent, width => $width );
+$emitter->set_writer($writer);
+for my $event (@events) {
+    my $type = $event->{name};
+    my $str = YAML::PP::Common::event_to_test_suite($event);
+    print "$str\n" if $verbose;
+    if ($type eq 'sequence_start_event' or $type eq 'mapping_start_event') {
+        if ($flow eq 'no') {
+            delete $event->{style};
+        }
+        elsif ($flow eq 'yes') {
+            if ($type eq 'sequence_start_event') {
+                $event->{style} = YAML_FLOW_SEQUENCE_STYLE;
+            }
+            else {
+                $event->{style} = YAML_FLOW_MAPPING_STYLE;
+            }
+        }
+    }
+    $emitter->$type($event);
+}
+my $out_yaml = $emitter->writer->output;
+print encode_utf8 $out_yaml;
+
+sub usage {
+    my ($rc) = @_;
+    print <<"EOM";
+Usage:
+
+    $0 [options] < file
+    $0 [options] file
+
+Options:
+    --indent=             Number of spaces for indentation
+    --width=              Maximum column width (only used in flow style for now)
+    --module, -M          YAML::PP, YAML::PP::LibYAML or YAML::PP::Ref
+    --dump, -D            YAML::PP, YAML::PP::LibYAML
+    --flow                'no' (default, always output block style), 'yes'
+                          (always output flow style), 'keep' (output flow
+                          style like in the original input)
+EOM
+    exit $rc;
+}

package/Binaries/Perl/Linux/X64/deps/lib/perl5/Capture/Tiny.pm

@@ -3,7 +3,7 @@ use strict;
 use warnings;
 package Capture::Tiny;
 # ABSTRACT: Capture STDOUT and STDERR from Perl, XS or external programs
-our $VERSION = '0.48';
+our $VERSION = '0.50';
 use Carp ();
 use Exporter ();
 use IO::Handle ();
@@ -436,7 +436,7 @@ Capture::Tiny - Capture STDOUT and STDERR from Perl, XS or external programs
 
 =head1 VERSION
 
-version 0.48
+version 0.50
 
 =head1 SYNOPSIS
 
@@ -529,7 +529,7 @@ capture via a named file (e.g. to externally monitor a long-running capture),
 provide custom filehandles as a trailing list of option pairs:
 
   my $out_fh = IO::File->new("out.txt", "w+");
-  my $err_fh = IO::File->new("out.txt", "w+");
+  my $err_fh = IO::File->new("err.txt", "w+");
   capture { ... } stdout => $out_fh, stderr => $err_fh;
 
 The filehandles must be read/write and seekable.  Modifying the files or
@@ -577,7 +577,7 @@ as well as passed on to the original STDOUT and STDERR.
 
 When called in void context, C<tee> saves memory and time by
 not reading back from the capture handles, except when the
-original STDOUT OR STDERR were tied or opened to a scalar
+original STDOUT or STDERR were tied or opened to a scalar
 handle.
 
 =head2 tee_stdout
@@ -743,7 +743,7 @@ waiting for its child processes to be ready to proceed.
 This module was inspired by L<IO::CaptureOutput>, which provides
 similar functionality without the ability to tee output and with more
 complicated code and API.  L<IO::CaptureOutput> does not handle layers
-or most of the unusual cases described in the L</Limitations> section and
+or most of the unusual cases described in the L</LIMITATIONS> section and
 I no longer recommend it.
 
 There are many other CPAN modules that provide some sort of output capture,
@@ -839,7 +839,7 @@ L<Test::Output>
 
 =back
 
-=for :stopwords cpan testmatrix url annocpan anno bugtracker rt cpants kwalitee diff irc mailto metadata placeholders metacpan
+=for :stopwords cpan testmatrix url bugtracker rt cpants kwalitee diff irc mailto metadata placeholders metacpan
 
 =head1 SUPPORT
 
@@ -864,7 +864,7 @@ David Golden <dagolden@cpan.org>
 
 =head1 CONTRIBUTORS
 
-=for stopwords Dagfinn Ilmari Mannsåker David E. Wheeler fecundf Graham Knop Peter Rabbitson
+=for stopwords Dagfinn Ilmari Mannsåker David E. Wheeler Ed Sabol fecundf Graham Knop Karen Etheridge Mohammad S Anwar Peter Rabbitson Sven Kirmess
 
 =over 4
 
@@ -878,6 +878,10 @@ David E. Wheeler <david@justatheory.com>
 
 =item *
 
+Ed Sabol <esabol@users.noreply.github.com>
+
+=item *
+
 fecundf <not.com+github@gmail.com>
 
 =item *
@@ -886,8 +890,20 @@ Graham Knop <haarg@haarg.org>
 
 =item *
 
+Karen Etheridge <ether@cpan.org>
+
+=item *
+
+Mohammad S Anwar <mohammad.anwar@yahoo.com>
+
+=item *
+
 Peter Rabbitson <ribasushi@cpan.org>
 
+=item *
+
+Sven Kirmess <sven.kirmess@kzone.ch>
+
 =back
 
 =head1 COPYRIGHT AND LICENSE

package/Binaries/Perl/Linux/X64/deps/lib/perl5/PPI/Cache.pm

@@ -54,7 +54,7 @@ use Digest::MD5 2.35 ();
 use Params::Util     qw{_INSTANCE _SCALAR};
 use PPI::Document    ();
 
-our $VERSION = '1.279';
+our $VERSION = '1.281';
 
 use constant VMS => !! ( $^O eq 'VMS' );
 

package/Binaries/Perl/Linux/X64/deps/lib/perl5/PPI/Document/File.pm

@@ -22,7 +22,7 @@ use Carp          ();
 use Params::Util  qw{_STRING _INSTANCE};
 use PPI::Document ();
 
-our $VERSION = '1.279';
+our $VERSION = '1.281';
 
 our @ISA = 'PPI::Document';
 

package/Binaries/Perl/Linux/X64/deps/lib/perl5/PPI/Document/Fragment.pm

@@ -21,7 +21,7 @@ within it, and it does not represent a scope.
 use strict;
 use PPI::Document ();
 
-our $VERSION = '1.279';
+our $VERSION = '1.281';
 
 our @ISA = 'PPI::Document';
 

package/Binaries/Perl/Linux/X64/deps/lib/perl5/PPI/Document/Normalized.pm

@@ -45,7 +45,7 @@ use Scalar::Util qw{refaddr reftype blessed};
 use Params::Util qw{_INSTANCE _ARRAY};
 use PPI::Util    ();
 
-our $VERSION = '1.279';
+our $VERSION = '1.281';
 
 use overload 'bool' => \&PPI::Util::TRUE;
 use overload '=='   => 'equal';