javonet-nodejs-sdk 2.1.0 → 2.1.2

package/Binaries/Perl/Linux/X64/deps/lib/perl5/YAML/Types.pm

@@ -1,240 +0,0 @@
-package YAML::Types;
-
-use YAML::Mo;
-use YAML::Node;
-
-# XXX These classes and their APIs could still use some refactoring,
-# but at least they work for now.
-#-------------------------------------------------------------------------------
-package YAML::Type::blessed;
-
-use YAML::Mo; # XXX
-
-sub yaml_dump {
-    my $self = shift;
-    my ($value) = @_;
-    my ($class, $type) = YAML::Mo::Object->node_info($value);
-    no strict 'refs';
-    my $kind = lc($type) . ':';
-    my $tag = ${$class . '::ClassTag'} ||
-              "!perl/$kind$class";
-    if ($type eq 'REF') {
-        YAML::Node->new(
-            {(&YAML::VALUE, ${$_[0]})}, $tag
-        );
-    }
-    elsif ($type eq 'SCALAR') {
-        $_[1] = $$value;
-        YAML::Node->new($_[1], $tag);
-    }
-    elsif ($type eq 'GLOB') {
-        # blessed glob support is minimal, and will not round-trip
-        # initial aim: to not cause an error
-        return YAML::Type::glob->yaml_dump($value, $tag);
-    } else {
-        YAML::Node->new($value, $tag);
-    }
-}
-
-#-------------------------------------------------------------------------------
-package YAML::Type::undef;
-
-sub yaml_dump {
-    my $self = shift;
-}
-
-sub yaml_load {
-    my $self = shift;
-}
-
-#-------------------------------------------------------------------------------
-package YAML::Type::glob;
-
-sub yaml_dump {
-    my $self = shift;
-    # $_[0] remains as the glob
-    my $tag = pop @_ if 2==@_;
-
-    $tag = '!perl/glob:' unless defined $tag;
-    my $ynode = YAML::Node->new({}, $tag);
-    for my $type (qw(PACKAGE NAME SCALAR ARRAY HASH CODE IO)) {
-        my $value = *{$_[0]}{$type};
-        $value = $$value if $type eq 'SCALAR';
-        if (defined $value) {
-            if ($type eq 'IO') {
-                my @stats = qw(device inode mode links uid gid rdev size
-                               atime mtime ctime blksize blocks);
-                undef $value;
-                $value->{stat} = YAML::Node->new({});
-                if ($value->{fileno} = fileno(*{$_[0]})) {
-                    local $^W;
-                    map {$value->{stat}{shift @stats} = $_} stat(*{$_[0]});
-                    $value->{tell} = tell(*{$_[0]});
-                }
-            }
-            $ynode->{$type} = $value;
-        }
-    }
-    return $ynode;
-}
-
-sub yaml_load {
-    my $self = shift;
-    my ($node, $class, $loader) = @_;
-    my ($name, $package);
-    if (defined $node->{NAME}) {
-        $name = $node->{NAME};
-        delete $node->{NAME};
-    }
-    else {
-        $loader->warn('YAML_LOAD_WARN_GLOB_NAME');
-        return undef;
-    }
-    if (defined $node->{PACKAGE}) {
-        $package = $node->{PACKAGE};
-        delete $node->{PACKAGE};
-    }
-    else {
-        $package = 'main';
-    }
-    no strict 'refs';
-    if (exists $node->{SCALAR}) {
-        if ($YAML::LoadBlessed and $loader->load_code) {
-            *{"${package}::$name"} = \$node->{SCALAR};
-        }
-        delete $node->{SCALAR};
-    }
-    for my $elem (qw(ARRAY HASH CODE IO)) {
-        if (exists $node->{$elem}) {
-            if ($elem eq 'IO') {
-                $loader->warn('YAML_LOAD_WARN_GLOB_IO');
-                delete $node->{IO};
-                next;
-            }
-            if ($YAML::LoadBlessed and $loader->load_code) {
-                *{"${package}::$name"} = $node->{$elem};
-            }
-            delete $node->{$elem};
-        }
-    }
-    for my $elem (sort keys %$node) {
-        $loader->warn('YAML_LOAD_WARN_BAD_GLOB_ELEM', $elem);
-    }
-    return *{"${package}::$name"};
-}
-
-#-------------------------------------------------------------------------------
-package YAML::Type::code;
-
-my $dummy_warned = 0;
-my $default = '{ "DUMMY" }';
-
-sub yaml_dump {
-    my $self = shift;
-    my $code;
-    my ($dumpflag, $value) = @_;
-    my ($class, $type) = YAML::Mo::Object->node_info($value);
-    my $tag = "!perl/code";
-    $tag .= ":$class" if defined $class;
-    if (not $dumpflag) {
-        $code = $default;
-    }
-    else {
-        bless $value, "CODE" if $class;
-        eval { require B::Deparse };
-        return if $@;
-        my $deparse = B::Deparse->new();
-        eval {
-            local $^W = 0;
-            $code = $deparse->coderef2text($value);
-        };
-        if ($@) {
-            warn YAML::YAML_DUMP_WARN_DEPARSE_FAILED() if $^W;
-            $code = $default;
-        }
-        bless $value, $class if $class;
-        chomp $code;
-        $code .= "\n";
-    }
-    $_[2] = $code;
-    YAML::Node->new($_[2], $tag);
-}
-
-sub yaml_load {
-    my $self = shift;
-    my ($node, $class, $loader) = @_;
-    if ($loader->load_code) {
-        my $code = eval "package main; sub $node";
-        if ($@) {
-            $loader->warn('YAML_LOAD_WARN_PARSE_CODE', $@);
-            return sub {};
-        }
-        else {
-            CORE::bless $code, $class if ($class and $YAML::LoadBlessed);
-            return $code;
-        }
-    }
-    else {
-        return CORE::bless sub {}, $class if ($class and $YAML::LoadBlessed);
-        return sub {};
-    }
-}
-
-#-------------------------------------------------------------------------------
-package YAML::Type::ref;
-
-sub yaml_dump {
-    my $self = shift;
-    YAML::Node->new({(&YAML::VALUE, ${$_[0]})}, '!perl/ref')
-}
-
-sub yaml_load {
-    my $self = shift;
-    my ($node, $class, $loader) = @_;
-    $loader->die('YAML_LOAD_ERR_NO_DEFAULT_VALUE', 'ptr')
-      unless exists $node->{&YAML::VALUE};
-    return \$node->{&YAML::VALUE};
-}
-
-#-------------------------------------------------------------------------------
-package YAML::Type::regexp;
-
-# XXX Be sure to handle blessed regexps (if possible)
-sub yaml_dump {
-    die "YAML::Type::regexp::yaml_dump not currently implemented";
-}
-
-use constant _QR_TYPES => {
-    '' => sub { qr{$_[0]} },
-    x => sub { qr{$_[0]}x },
-    i => sub { qr{$_[0]}i },
-    s => sub { qr{$_[0]}s },
-    m => sub { qr{$_[0]}m },
-    ix => sub { qr{$_[0]}ix },
-    sx => sub { qr{$_[0]}sx },
-    mx => sub { qr{$_[0]}mx },
-    si => sub { qr{$_[0]}si },
-    mi => sub { qr{$_[0]}mi },
-    ms => sub { qr{$_[0]}sm },
-    six => sub { qr{$_[0]}six },
-    mix => sub { qr{$_[0]}mix },
-    msx => sub { qr{$_[0]}msx },
-    msi => sub { qr{$_[0]}msi },
-    msix => sub { qr{$_[0]}msix },
-};
-
-sub yaml_load {
-    my $self = shift;
-    my ($node, $class) = @_;
-    return qr{$node} unless $node =~ /^\(\?([\^\-uxism]*):(.*)\)\z/s;
-    my ($flags, $re) = ($1, $2);
-    $flags =~ s/-.*//;
-    $flags =~ s/^\^//;
-    $flags =~ tr/u//d;
-    my $sub = _QR_TYPES->{$flags} || sub { qr{$_[0]} };
-    my $qr = &$sub($re);
-    bless $qr, $class if (length $class and $YAML::LoadBlessed);
-    return $qr;
-}
-
-1;

package/Binaries/Perl/Linux/X64/deps/lib/perl5/YAML/Types.pod

@@ -1,38 +0,0 @@
-=pod
-
-=for comment
-DO NOT EDIT. This Pod was generated by Swim v0.1.46.
-See http://github.com/ingydotnet/swim-pm#readme
-
-=encoding utf8
-
-=head1 NAME
-
-YAML::Types - Marshall Perl internal data types to/from YAML
-
-=head1 SYNOPSIS
-
-    $::foo = 42;
-    print YAML::Dump(*::foo);
-
-    print YAML::Dump(qr{match me});
-
-=head1 DESCRIPTION
-
-This module has the helper classes for transferring objects, subroutines,
-references, globs, regexps and file handles to and from YAML.
-
-=head1 AUTHOR
-
-ingy döt Net <ingy@cpan.org>
-
-=head1 COPYRIGHT
-
-Copyright 2001-2014. Ingy döt Net
-
-This program is free software; you can redistribute it and/or modify it under
-the same terms as Perl itself.
-
-See L<http://www.perl.com/perl/misc/Artistic.html>
-
-=cut

package/Binaries/Perl/Linux/X64/deps/lib/perl5/YAML.pm

@@ -1,117 +0,0 @@
-package YAML;
-our $VERSION = '1.30';
-
-use YAML::Mo;
-
-use Exporter;
-push @YAML::ISA, 'Exporter';
-our @EXPORT = qw{ Dump Load };
-our @EXPORT_OK = qw{ freeze thaw DumpFile LoadFile Bless Blessed };
-our (
-    $UseCode, $DumpCode, $LoadCode,
-    $SpecVersion,
-    $UseHeader, $UseVersion, $UseBlock, $UseFold, $UseAliases,
-    $Indent, $SortKeys, $Preserve,
-    $AnchorPrefix, $CompressSeries, $InlineSeries, $Purity,
-    $Stringify, $Numify, $LoadBlessed, $QuoteNumericStrings,
-    $DumperClass, $LoaderClass
-);
-
-use YAML::Node; # XXX This is a temp fix for Module::Build
-use Scalar::Util qw/ openhandle /;
-
-# XXX This VALUE nonsense needs to go.
-use constant VALUE => "\x07YAML\x07VALUE\x07";
-
-# YAML Object Properties
-has dumper_class => default => sub {'YAML::Dumper'};
-has loader_class => default => sub {'YAML::Loader'};
-has dumper_object => default => sub {$_[0]->init_action_object("dumper")};
-has loader_object => default => sub {$_[0]->init_action_object("loader")};
-
-sub Dump {
-    my $yaml = YAML->new;
-    $yaml->dumper_class($YAML::DumperClass)
-        if $YAML::DumperClass;
-    return $yaml->dumper_object->dump(@_);
-}
-
-sub Load {
-    my $yaml = YAML->new;
-    $yaml->loader_class($YAML::LoaderClass)
-        if $YAML::LoaderClass;
-    return $yaml->loader_object->load(@_);
-}
-
-{
-    no warnings 'once';
-    # freeze/thaw is the API for Storable string serialization. Some
-    # modules make use of serializing packages on if they use freeze/thaw.
-    *freeze = \ &Dump;
-    *thaw   = \ &Load;
-}
-
-sub DumpFile {
-    my $OUT;
-    my $filename = shift;
-    if (openhandle $filename) {
-        $OUT = $filename;
-    }
-    else {
-        my $mode = '>';
-        if ($filename =~ /^\s*(>{1,2})\s*(.*)$/) {
-            ($mode, $filename) = ($1, $2);
-        }
-        open $OUT, $mode, $filename
-          or YAML::Mo::Object->die('YAML_DUMP_ERR_FILE_OUTPUT', $filename, "$!");
-    }
-    binmode $OUT, ':utf8';  # if $Config{useperlio} eq 'define';
-    local $/ = "\n"; # reset special to "sane"
-    print $OUT Dump(@_);
-    unless (ref $filename eq 'GLOB') {
-        close $OUT
-          or do {
-              my $errsav = $!;
-              YAML::Mo::Object->die('YAML_DUMP_ERR_FILE_OUTPUT_CLOSE', $filename, $errsav);
-          }
-    }
-}
-
-sub LoadFile {
-    my $IN;
-    my $filename = shift;
-    if (openhandle $filename) {
-        $IN = $filename;
-    }
-    else {
-        open $IN, '<', $filename
-          or YAML::Mo::Object->die('YAML_LOAD_ERR_FILE_INPUT', $filename, "$!");
-    }
-    binmode $IN, ':utf8';  # if $Config{useperlio} eq 'define';
-    return Load(do { local $/; <$IN> });
-}
-
-sub init_action_object {
-    my $self = shift;
-    my $object_class = (shift) . '_class';
-    my $module_name = $self->$object_class;
-    eval "require $module_name";
-    $self->die("Error in require $module_name - $@")
-        if $@ and "$@" !~ /Can't locate/;
-    my $object = $self->$object_class->new;
-    $object->set_global_options;
-    return $object;
-}
-
-my $global = {};
-sub Bless {
-    require YAML::Dumper::Base;
-    YAML::Dumper::Base::bless($global, @_)
-}
-sub Blessed {
-    require YAML::Dumper::Base;
-    YAML::Dumper::Base::blessed($global, @_)
-}
-sub global_object { $global }
-
-1;