npm - javonet-nodejs-sdk - Versions diffs - 2.1.1 → 2.1.3 - Mend

javonet-nodejs-sdk 2.1.1 → 2.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (843) hide show

package/Binaries/Perl/MacOs/X64/deps/lib/perl5/darwin-thread-multi-2level/HTML/Filter.pm DELETED Viewed

@@ -1,110 +0,0 @@
-package HTML::Filter;
-use strict;
-require HTML::Parser;
-our @ISA = qw(HTML::Parser);
-our $VERSION = '3.81';
-sub declaration { $_[0]->output("<!$_[1]>")     }
-sub process     { $_[0]->output($_[2])          }
-sub comment     { $_[0]->output("<!--$_[1]-->") }
-sub start       { $_[0]->output($_[4])          }
-sub end         { $_[0]->output($_[2])          }
-sub text        { $_[0]->output($_[1])          }
-sub output      { print $_[1] }
-1;
-__END__
-=head1 NAME
-HTML::Filter - Filter HTML text through the parser
-=head1 NOTE
-B<This module is deprecated.> The C<HTML::Parser> now provides the
-functionally of C<HTML::Filter> much more efficiently with the
-C<default> handler.
-=head1 SYNOPSIS
- require HTML::Filter;
- $p = HTML::Filter->new->parse_file("index.html");
-=head1 DESCRIPTION
-C<HTML::Filter> is an HTML parser that by default prints the
-original text of each HTML element (a slow version of cat(1) basically).
-The callback methods may be overridden to modify the filtering for some
-HTML elements and you can override output() method which is called to
-print the HTML text.
-C<HTML::Filter> is a subclass of C<HTML::Parser>. This means that
-the document should be given to the parser by calling the $p->parse()
-or $p->parse_file() methods.
-=head1 EXAMPLES
-The first example is a filter that will remove all comments from an
-HTML file.  This is achieved by simply overriding the comment method
-to do nothing.
-  package CommentStripper;
-  require HTML::Filter;
-  @ISA=qw(HTML::Filter);
-  sub comment { }  # ignore comments
-The second example shows a filter that will remove any E<lt>TABLE>s
-found in the HTML file.  We specialize the start() and end() methods
-to count table tags and then make output not happen when inside a
-table.
-  package TableStripper;
-  require HTML::Filter;
-  @ISA=qw(HTML::Filter);
-  sub start
-  {
-     my $self = shift;
-     $self->{table_seen}++ if $_[0] eq "table";
-     $self->SUPER::start(@_);
-  }
-  sub end
-  {
-     my $self = shift;
-     $self->SUPER::end(@_);
-     $self->{table_seen}-- if $_[0] eq "table";
-  }
-  sub output
-  {
-      my $self = shift;
-      unless ($self->{table_seen}) {
-	  $self->SUPER::output(@_);
-      }
-  }
-If you want to collect the parsed text internally you might want to do
-something like this:
-  package FilterIntoString;
-  require HTML::Filter;
-  @ISA=qw(HTML::Filter);
-  sub output { push(@{$_[0]->{fhtml}}, $_[1]) }
-  sub filtered_html { join("", @{$_[0]->{fhtml}}) }
-=head1 SEE ALSO
-L<HTML::Parser>
-=head1 COPYRIGHT
-Copyright 1997-1999 Gisle Aas.
-This library is free software; you can redistribute it and/or
-modify it under the same terms as Perl itself.
-=cut

package/Binaries/Perl/MacOs/X64/deps/lib/perl5/darwin-thread-multi-2level/HTML/HeadParser.pm DELETED Viewed

@@ -1,314 +0,0 @@
-package HTML::HeadParser;
-=head1 NAME
-HTML::HeadParser - Parse <HEAD> section of a HTML document
-=head1 SYNOPSIS
- require HTML::HeadParser;
- $p = HTML::HeadParser->new;
- $p->parse($text) and  print "not finished";
- $p->header('Title')          # to access <title>....</title>
- $p->header('Content-Base')   # to access <base href="http://...">
- $p->header('Foo')            # to access <meta http-equiv="Foo" content="...">
- $p->header('X-Meta-Author')  # to access <meta name="author" content="...">
- $p->header('X-Meta-Charset') # to access <meta charset="...">
-=head1 DESCRIPTION
-The C<HTML::HeadParser> is a specialized (and lightweight)
-C<HTML::Parser> that will only parse the E<lt>HEAD>...E<lt>/HEAD>
-section of an HTML document.  The parse() method
-will return a FALSE value as soon as some E<lt>BODY> element or body
-text are found, and should not be called again after this.
-Note that the C<HTML::HeadParser> might get confused if raw undecoded
-UTF-8 is passed to the parse() method.  Make sure the strings are
-properly decoded before passing them on.
-The C<HTML::HeadParser> keeps a reference to a header object, and the
-parser will update this header object as the various elements of the
-E<lt>HEAD> section of the HTML document are recognized.  The following
-header fields are affected:
-=over 4
-=item Content-Base:
-The I<Content-Base> header is initialized from the E<lt>base
-href="..."> element.
-=item Title:
-The I<Title> header is initialized from the E<lt>title>...E<lt>/title>
-element.
-=item Isindex:
-The I<Isindex> header will be added if there is a E<lt>isindex>
-element in the E<lt>head>.  The header value is initialized from the
-I<prompt> attribute if it is present.  If no I<prompt> attribute is
-given it will have '?' as the value.
-=item X-Meta-Foo:
-All E<lt>meta> elements containing a C<name> attribute will result in
-headers using the prefix C<X-Meta-> appended with the value of the
-C<name> attribute as the name of the header, and the value of the
-C<content> attribute as the pushed header value.
-E<lt>meta> elements containing a C<http-equiv> attribute will result
-in headers as in above, but without the C<X-Meta-> prefix in the
-header name.
-E<lt>meta> elements containing a C<charset> attribute will result in
-an C<X-Meta-Charset> header, using the value of the C<charset>
-attribute as the pushed header value.
-The ':' character can't be represented in header field names, so
-if the meta element contains this char it's substituted with '-'
-before forming the field name.
-=back
-=head1 METHODS
-The following methods (in addition to those provided by the
-superclass) are available:
-=over 4
-=cut
-require HTML::Parser;
-our @ISA = qw(HTML::Parser);
-use HTML::Entities ();
-use strict;
-our $DEBUG;
-#$DEBUG = 1;
-our $VERSION = '3.81';
-=item $hp = HTML::HeadParser->new
-=item $hp = HTML::HeadParser->new( $header )
-The object constructor.  The optional $header argument should be a
-reference to an object that implement the header() and push_header()
-methods as defined by the C<HTTP::Headers> class.  Normally it will be
-of some class that is a or delegates to the C<HTTP::Headers> class.
-If no $header is given C<HTML::HeadParser> will create an
-C<HTTP::Headers> object by itself (initially empty).
-=cut
-sub new
-{
-    my($class, $header) = @_;
-    unless ($header) {
-	require HTTP::Headers;
-	$header = HTTP::Headers->new;
-    }
-    my $self = $class->SUPER::new(api_version => 3,
-				  start_h => ["start", "self,tagname,attr"],
-				  end_h   => ["end",   "self,tagname"],
-				  text_h  => ["text",  "self,text"],
-				  ignore_elements => [qw(script style)],
-				 );
-    $self->{'header'} = $header;
-    $self->{'tag'} = '';   # name of active element that takes textual content
-    $self->{'text'} = '';  # the accumulated text associated with the element
-    $self;
-}
-=item $hp->header;
-Returns a reference to the header object.
-=item $hp->header( $key )
-Returns a header value.  It is just a shorter way to write
-C<$hp-E<gt>header-E<gt>header($key)>.
-=cut
-sub header
-{
-    my $self = shift;
-    return $self->{'header'} unless @_;
-    $self->{'header'}->header(@_);
-}
-sub as_string    # legacy
-{
-    my $self = shift;
-    $self->{'header'}->as_string;
-}
-sub flush_text   # internal
-{
-    my $self = shift;
-    my $tag  = $self->{'tag'};
-    my $text = $self->{'text'};
-    $text =~ s/^\s+//;
-    $text =~ s/\s+$//;
-    $text =~ s/\s+/ /g;
-    print "FLUSH $tag => '$text'\n"  if $DEBUG;
-    if ($tag eq 'title') {
-	my $decoded;
-	$decoded = utf8::decode($text) if $self->utf8_mode && defined &utf8::decode;
-	HTML::Entities::decode($text);
-	utf8::encode($text) if $decoded;
-	$self->{'header'}->push_header(Title => $text);
-    }
-    $self->{'tag'} = $self->{'text'} = '';
-}
-# This is an quote from the HTML3.2 DTD which shows which elements
-# that might be present in a <HEAD>...</HEAD>.  Also note that the
-# <HEAD> tags themselves might be missing:
-#
-# <!ENTITY % head.content "TITLE & ISINDEX? & BASE? & STYLE? &
-#                            SCRIPT* & META* & LINK*">
-#
-# <!ELEMENT HEAD O O  (%head.content)>
-#
-# From HTML 4.01:
-#
-# <!ENTITY % head.misc "SCRIPT|STYLE|META|LINK|OBJECT">
-# <!ENTITY % head.content "TITLE & BASE?">
-# <!ELEMENT HEAD O O (%head.content;) +(%head.misc;)>
-#
-# From HTML 5 as of WD-html5-20090825:
-#
-# One or more elements of metadata content, [...]
-# => base, command, link, meta, noscript, script, style, title
-sub start
-{
-    my($self, $tag, $attr) = @_;  # $attr is reference to a HASH
-    print "START[$tag]\n" if $DEBUG;
-    $self->flush_text if $self->{'tag'};
-    if ($tag eq 'meta') {
-	my $key = $attr->{'http-equiv'};
-	if (!defined($key) || !length($key)) {
-	    if ($attr->{name}) {
-		$key = "X-Meta-\u$attr->{name}";
-	    } elsif ($attr->{charset}) { # HTML 5 <meta charset="...">
-		$key = "X-Meta-Charset";
-		$self->{header}->push_header($key => $attr->{charset});
-		return;
-	    } else {
-		return;
-	    }
-	}
-	$key =~ s/:/-/g;
-	$self->{'header'}->push_header($key => $attr->{content});
-    } elsif ($tag eq 'base') {
-	return unless exists $attr->{href};
-	(my $base = $attr->{href}) =~ s/^\s+//; $base =~ s/\s+$//; # HTML5
-	$self->{'header'}->push_header('Content-Base' => $base);
-    } elsif ($tag eq 'isindex') {
-	# This is a non-standard header.  Perhaps we should just ignore
-	# this element
-	$self->{'header'}->push_header(Isindex => $attr->{prompt} || '?');
-    } elsif ($tag =~ /^(?:title|noscript|object|command)$/) {
-	# Just remember tag.  Initialize header when we see the end tag.
-	$self->{'tag'} = $tag;
-    } elsif ($tag eq 'link') {
-	return unless exists $attr->{href};
-	# <link href="http:..." rel="xxx" rev="xxx" title="xxx">
-	my $href = delete($attr->{href});
-	$href =~ s/^\s+//; $href =~ s/\s+$//; # HTML5
-	my $h_val = "<$href>";
-	for (sort keys %{$attr}) {
-	    next if $_ eq "/";  # XHTML junk
-	    $h_val .= qq(; $_="$attr->{$_}");
-	}
-	$self->{'header'}->push_header(Link => $h_val);
-    } elsif ($tag eq 'head' || $tag eq 'html') {
-	# ignore
-    } else {
-	 # stop parsing
-	$self->eof;
-    }
-}
-sub end
-{
-    my($self, $tag) = @_;
-    print "END[$tag]\n" if $DEBUG;
-    $self->flush_text if $self->{'tag'};
-    $self->eof if $tag eq 'head';
-}
-sub text
-{
-    my($self, $text) = @_;
-    print "TEXT[$text]\n" if $DEBUG;
-    unless ($self->{first_chunk}) {
-	# drop Unicode BOM if found
-	if ($self->utf8_mode) {
-	    $text =~ s/^\xEF\xBB\xBF//;
-	}
-	else {
-	    $text =~ s/^\x{FEFF}//;
-	}
-	$self->{first_chunk}++;
-    }
-    my $tag = $self->{tag};
-    if (!$tag && $text =~ /\S/) {
-	# Normal text means start of body
-        $self->eof;
-	return;
-    }
-    return if $tag ne 'title';
-    $self->{'text'} .= $text;
-}
-BEGIN {
-    *utf8_mode = sub { 1 } unless HTML::Entities::UNICODE_SUPPORT;
-}
-1;
-__END__
-=back
-=head1 EXAMPLE
- $h = HTTP::Headers->new;
- $p = HTML::HeadParser->new($h);
- $p->parse(<<EOT);
- <title>Stupid example</title>
- <base href="http://www.linpro.no/lwp/">
- Normal text starts here.
- EOT
- undef $p;
- print $h->title;   # should print "Stupid example"
-=head1 SEE ALSO
-L<HTML::Parser>, L<HTTP::Headers>
-The C<HTTP::Headers> class is distributed as part of the
-I<libwww-perl> package.  If you don't have that distribution installed
-you need to provide the $header argument to the C<HTML::HeadParser>
-constructor with your own object that implements the documented
-protocol.
-=head1 COPYRIGHT
-Copyright 1996-2001 Gisle Aas. All rights reserved.
-This library is free software; you can redistribute it and/or
-modify it under the same terms as Perl itself.
-=cut

package/Binaries/Perl/MacOs/X64/deps/lib/perl5/darwin-thread-multi-2level/HTML/LinkExtor.pm DELETED Viewed

@@ -1,185 +0,0 @@
-package HTML::LinkExtor;
-require HTML::Parser;
-our @ISA = qw(HTML::Parser);
-our $VERSION = '3.81';
-=head1 NAME
-HTML::LinkExtor - Extract links from an HTML document
-=head1 SYNOPSIS
- require HTML::LinkExtor;
- $p = HTML::LinkExtor->new(\&cb, "http://www.perl.org/");
- sub cb {
-     my($tag, %links) = @_;
-     print "$tag @{[%links]}\n";
- }
- $p->parse_file("index.html");
-=head1 DESCRIPTION
-I<HTML::LinkExtor> is an HTML parser that extracts links from an
-HTML document.  The I<HTML::LinkExtor> is a subclass of
-I<HTML::Parser>. This means that the document should be given to the
-parser by calling the $p->parse() or $p->parse_file() methods.
-=cut
-use strict;
-use HTML::Tagset ();
-# legacy (some applications grabs this hash directly)
-our %LINK_ELEMENT;
-*LINK_ELEMENT = \%HTML::Tagset::linkElements;
-=over 4
-=item $p = HTML::LinkExtor->new
-=item $p = HTML::LinkExtor->new( $callback )
-=item $p = HTML::LinkExtor->new( $callback, $base )
-The constructor takes two optional arguments. The first is a reference
-to a callback routine. It will be called as links are found. If a
-callback is not provided, then links are just accumulated internally
-and can be retrieved by calling the $p->links() method.
-The $base argument is an optional base URL used to absolutize all URLs found.
-You need to have the I<URI> module installed if you provide $base.
-The callback is called with the lowercase tag name as first argument,
-and then all link attributes as separate key/value pairs.  All
-non-link attributes are removed.
-=cut
-sub new
-{
-    my($class, $cb, $base) = @_;
-    my $self = $class->SUPER::new(
-                    start_h => ["_start_tag", "self,tagname,attr"],
-		    report_tags => [keys %HTML::Tagset::linkElements],
-	       );
-    $self->{extractlink_cb} = $cb;
-    if ($base) {
-	require URI;
-	$self->{extractlink_base} = URI->new($base);
-    }
-    $self;
-}
-sub _start_tag
-{
-    my($self, $tag, $attr) = @_;
-    my $base = $self->{extractlink_base};
-    my $links = $HTML::Tagset::linkElements{$tag};
-    $links = [$links] unless ref $links;
-    my @links;
-    my $a;
-    for $a (@$links) {
-	next unless exists $attr->{$a};
-	(my $link = $attr->{$a}) =~ s/^\s+//; $link =~ s/\s+$//; # HTML5
-	push(@links, $a, $base ? URI->new($link, $base)->abs($base) : $link);
-    }
-    return unless @links;
-    $self->_found_link($tag, @links);
-}
-sub _found_link
-{
-    my $self = shift;
-    my $cb = $self->{extractlink_cb};
-    if ($cb) {
-	&$cb(@_);
-    } else {
-	push(@{$self->{'links'}}, [@_]);
-    }
-}
-=item $p->links
-Returns a list of all links found in the document.  The returned
-values will be anonymous arrays with the following elements:
-  [$tag, $attr => $url1, $attr2 => $url2,...]
-The $p->links method will also truncate the internal link list.  This
-means that if the method is called twice without any parsing
-between them the second call will return an empty list.
-Also note that $p->links will always be empty if a callback routine
-was provided when the I<HTML::LinkExtor> was created.
-=cut
-sub links
-{
-    my $self = shift;
-    exists($self->{'links'}) ? @{delete $self->{'links'}} : ();
-}
-# We override the parse_file() method so that we can clear the links
-# before we start a new file.
-sub parse_file
-{
-    my $self = shift;
-    delete $self->{'links'};
-    $self->SUPER::parse_file(@_);
-}
-=back
-=head1 EXAMPLE
-This is an example showing how you can extract links from a document
-received using LWP:
-  use LWP::UserAgent;
-  use HTML::LinkExtor;
-  use URI::URL;
-  $url = "http://www.perl.org/";  # for instance
-  $ua = LWP::UserAgent->new;
-  # Set up a callback that collect image links
-  my @imgs = ();
-  sub callback {
-     my($tag, %attr) = @_;
-     return if $tag ne 'img';  # we only look closer at <img ...>
-     push(@imgs, values %attr);
-  }
-  # Make the parser.  Unfortunately, we don't know the base yet
-  # (it might be different from $url)
-  $p = HTML::LinkExtor->new(\&callback);
-  # Request document and parse it as it arrives
-  $res = $ua->request(HTTP::Request->new(GET => $url),
-                      sub {$p->parse($_[0])});
-  # Expand all image URLs to absolute ones
-  my $base = $res->base;
-  @imgs = map { $_ = url($_, $base)->abs; } @imgs;
-  # Print them out
-  print join("\n", @imgs), "\n";
-=head1 SEE ALSO
-L<HTML::Parser>, L<HTML::Tagset>, L<LWP>, L<URI::URL>
-=head1 COPYRIGHT
-Copyright 1996-2001 Gisle Aas.
-This library is free software; you can redistribute it and/or
-modify it under the same terms as Perl itself.
-=cut
-1;