npm - javonet-nodejs-sdk - Versions diffs - 2.4.9 → 2.4.11 - Mend

javonet-nodejs-sdk 2.4.9 → 2.4.11

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 (1624) hide show

package/Binaries/Perl/MacOs/X64/deps/lib/perl5/PPI/Token/Regexp.pm DELETED Viewed

@@ -1,136 +0,0 @@
-package PPI::Token::Regexp;
-=pod
-=head1 NAME
-PPI::Token::Regexp - Regular expression abstract base class
-=head1 INHERITANCE
-  PPI::Token::Regexp
-  isa PPI::Token
-      isa PPI::Element
-=head1 DESCRIPTION
-The C<PPI::Token::Regexp> class is never instantiated, and simply
-provides a common abstract base class for the three regular expression
-classes. These being:
-=over 2
-=item m// - L<PPI::Token::Regexp::Match>
-=item s/// - L<PPI::Token::Regexp::Substitute>
-=item tr/// - L<PPI::Token::Regexp::Transliterate>
-=back
-The names are hopefully obvious enough not to have to explain what
-each class is. See their pages for more details.
-To save some confusion, it's worth pointing out here that C<qr//> is
-B<not> a regular expression (which PPI takes to mean something that
-will actually examine or modify a string), but rather a quote-like
-operator that acts as a constructor for compiled L<Regexp> objects.
-=head1 METHODS
-The following methods are inherited by this class' offspring:
-=cut
-use strict;
-use PPI::Token ();
-our $VERSION = '1.279';
-our @ISA = "PPI::Token";
-#####################################################################
-# PPI::Token::Regexp Methods
-=pod
-=head2 get_match_string
-The C<get_match_string> method returns the portion of the regexp that
-performs the match.
-=cut
-sub get_match_string {
-	return $_[0]->_section_content( 0 );
-}
-=pod
-=head2 get_substitute_string
-The C<get_substitute_string> method returns the portion of the regexp
-that is substituted for the match, if any.  If the regexp does not
-substitute, C<undef> is returned.
-=cut
-sub get_substitute_string {
-	return $_[0]->_section_content( 1 );
-}
-=pod
-=head2 get_modifiers
-The C<get_modifiers> method returns the modifiers of the regexp.
-=cut
-sub get_modifiers {
-	return $_[0]->_modifiers();
-}
-=pod
-=head2 get_delimiters
-The C<get_delimiters> method returns the delimiters of the regexp as
-an array. The first element is the delimiters of the match string, and
-the second element (if any) is the delimiters of the substitute string
-(if any).
-=cut
-sub get_delimiters {
-	return $_[0]->_delimiters();
-}
-1;
-=pod
-=head1 SUPPORT
-See the L<support section|PPI/SUPPORT> in the main module.
-=head1 AUTHOR
-Adam Kennedy E<lt>adamk@cpan.orgE<gt>
-=head1 COPYRIGHT
-Copyright 2001 - 2011 Adam Kennedy.
-This program is free software; you can redistribute
-it and/or modify it under the same terms as Perl itself.
-The full text of the license can be found in the
-LICENSE file included with this module.
-=cut

package/Binaries/Perl/MacOs/X64/deps/lib/perl5/PPI/Token/Separator.pm DELETED Viewed

@@ -1,64 +0,0 @@
-package PPI::Token::Separator;
-=pod
-=head1 NAME
-PPI::Token::Separator - The __DATA__ and __END__ tags
-=head1 INHERITANCE
-  PPI::Token::Separator
-  isa PPI::Token::Word
-      isa PPI::Token
-          isa PPI::Element
-=head1 DESCRIPTION
-Although superficially looking like a normal L<PPI::Token::Word> object,
-when the C<__DATA__> and C<__END__> compiler tags appear at the beginning of
-a line (on supposedly) their own line, these tags become file section
-separators.
-The indicate that the time for Perl code is over, and the rest of the
-file is dedicated to something else (data in the case of C<__DATA__>) or
-to nothing at all (in the case of C<__END__>).
-=head1 METHODS
-This class has no methods beyond what is provided by its
-L<PPI::Token::Word>, L<PPI::Token> and L<PPI::Element>
-parent classes.
-=cut
-use strict;
-use PPI::Token::Word ();
-our $VERSION = '1.279';
-our @ISA = "PPI::Token::Word";
-1;
-=pod
-=head1 SUPPORT
-See the L<support section|PPI/SUPPORT> in the main module.
-=head1 AUTHOR
-Adam Kennedy E<lt>adamk@cpan.orgE<gt>
-=head1 COPYRIGHT
-Copyright 2001 - 2011 Adam Kennedy.
-This program is free software; you can redistribute
-it and/or modify it under the same terms as Perl itself.
-The full text of the license can be found in the
-LICENSE file included with this module.
-=cut

package/Binaries/Perl/MacOs/X64/deps/lib/perl5/PPI/Token/Structure.pm DELETED Viewed

@@ -1,209 +0,0 @@
-package PPI::Token::Structure;
-=pod
-=head1 NAME
-PPI::Token::Structure - Token class for characters that define code structure
-=head1 INHERITANCE
-  PPI::Token::Structure
-  isa PPI::Token
-      isa PPI::Element
-=head1 DESCRIPTION
-The C<PPI::Token::Structure> class is used for tokens that control the
-general tree structure or code.
-This consists of seven characters. These are the six brace characters from
-the "round", "curly" and "square" pairs, plus the semi-colon statement
-separator C<;>.
-=head1 METHODS
-This class has no methods beyond what is provided by its
-L<PPI::Token> and L<PPI::Element> parent classes.
-=cut
-use strict;
-use PPI::Token ();
-our $VERSION = '1.279';
-our @ISA = "PPI::Token";
-# Set the matching braces, done as an array
-# for slightly faster lookups.
-my %MATCH = (
-	ord '{' => '}',
-	ord '}' => '{',
-	ord '[' => ']',
-	ord ']' => '[',
-	ord '(' => ')',
-	ord ')' => '(',
-);
-my %OPENS = (
-	ord '{' => 1,
-	ord '[' => 1,
-	ord '(' => 1,
-);
-my %CLOSES = (
-	ord '}' => 1,
-	ord ']' => 1,
-	ord ')' => 1,
-);
-#####################################################################
-# Tokenizer Methods
-sub __TOKENIZER__on_char {
-	# Structures are one character long, always.
-	# Finalize and process again.
-	$_[1]->_finalize_token->__TOKENIZER__on_char( $_[1] );
-}
-sub __TOKENIZER__commit {
-	my $t = $_[1];
-	$t->_new_token( 'Structure', substr( $t->{line}, $t->{line_cursor}, 1 ) );
-	$t->_finalize_token;
-	0;
-}
-#####################################################################
-# Lexer Methods
-# For a given brace, find its opposing pair
-sub __LEXER__opposite {
-	$MATCH{ord $_[0]->{content}};
-}
-#####################################################################
-# PPI::Element Methods
-# There is a unusual situation in regards to "siblings".
-#
-# As an Element, braces sit outside the normal tree structure, and in
-# this context they NEVER have siblings.
-#
-# However, as tokens they DO have siblings.
-#
-# As such, we need special versions of _all_ of the sibling methods to
-# handle this.
-#
-# Statement terminators do not have these problems, and for them sibling
-# calls work as normal, and so they can just be passed upwards.
-sub next_sibling {
-	return $_[0]->SUPER::next_sibling if $_[0]->{content} eq ';';
-	return '';
-}
-sub snext_sibling {
-	return $_[0]->SUPER::snext_sibling if $_[0]->{content} eq ';';
-	return '';
-}
-sub previous_sibling {
-	return $_[0]->SUPER::previous_sibling if $_[0]->{content} eq ';';
-	return '';
-}
-sub sprevious_sibling {
-	return $_[0]->SUPER::sprevious_sibling if $_[0]->{content} eq ';';
-	return '';
-}
-sub next_token {
-	my $self = shift;
-	return $self->SUPER::next_token if $self->{content} eq ';';
-	my $structure = $self->parent or return '';
-	# If this is an opening brace, descend down into our parent
-	# structure, if it has children.
-	if ( $OPENS{ ord $self->{content} } ) {
-		my $child = $structure->child(0);
-		if ( $child ) {
-			# Decend deeper, or return if it is a token
-			return $child->isa('PPI::Token') ? $child : $child->first_token;
-		} elsif ( $structure->finish ) {
-			# Empty structure, so next is closing brace
-			return $structure->finish;
-		}
-		# Anything that slips through to here is a structure
-		# with an opening brace, but no closing brace, so we
-		# just have to go with it, and continue as we would
-		# if we started with a closing brace.
-	}
-	# We can use the default implement, if we call it from the
-	# parent structure of the closing brace.
-	$structure->next_token;
-}
-sub previous_token {
-	my $self = shift;
-	return $self->SUPER::previous_token if $self->{content} eq ';';
-	my $structure = $self->parent or return '';
-	# If this is a closing brace, descend down into our parent
-	# structure, if it has children.
-	if ( $CLOSES{ ord $self->{content} } ) {
-		my $child = $structure->child(-1);
-		if ( $child ) {
-			# Decend deeper, or return if it is a token
-			return $child->isa('PPI::Token') ? $child : $child->last_token;
-		} elsif ( $structure->start ) {
-			# Empty structure, so next is closing brace
-			return $structure->start;
-		}
-		# Anything that slips through to here is a structure
-		# with a closing brace, but no opening brace, so we
-		# just have to go with it, and continue as we would
-		# if we started with an opening brace.
-	}
-	# We can use the default implement, if we call it from the
-	# parent structure of the closing brace.
-	$structure->previous_token;
-}
-1;
-=pod
-=head1 SUPPORT
-See the L<support section|PPI/SUPPORT> in the main module.
-=head1 AUTHOR
-Adam Kennedy E<lt>adamk@cpan.orgE<gt>
-=head1 COPYRIGHT
-Copyright 2001 - 2011 Adam Kennedy.
-This program is free software; you can redistribute
-it and/or modify it under the same terms as Perl itself.
-The full text of the license can be found in the
-LICENSE file included with this module.
-=cut

package/Binaries/Perl/MacOs/X64/deps/lib/perl5/PPI/Token/Symbol.pm DELETED Viewed

@@ -1,241 +0,0 @@
-package PPI::Token::Symbol;
-=pod
-=head1 NAME
-PPI::Token::Symbol - A token class for variables and other symbols
-=head1 INHERITANCE
-  PPI::Token::Symbol
-  isa PPI::Token
-      isa PPI::Element
-=head1 DESCRIPTION
-The C<PPI::Token::Symbol> class is used to cover all tokens that represent
-variables and other things that start with a sigil.
-=head1 METHODS
-This class has several methods beyond what is provided by its
-L<PPI::Token> and L<PPI::Element> parent classes.
-Most methods are provided to help work out what the object is actually
-pointing at, rather than what it might appear to be pointing at.
-=cut
-use strict;
-use Params::Util qw{_INSTANCE};
-use PPI::Token   ();
-our $VERSION = '1.279';
-our @ISA = "PPI::Token";
-#####################################################################
-# PPI::Token::Symbol Methods
-=pod
-=head2 canonical
-The C<canonical> method returns a normalized, canonical version of the
-symbol.
-For example, it converts C<$ ::foo'bar::baz> to C<$main::foo::bar::baz>.
-This does not fully resolve the symbol, but merely removes syntax
-variations.
-=cut
-sub canonical {
-	my $symbol = shift->content;
-	$symbol =~ s/\s+//;
-	$symbol =~ s/\'/::/g;
-	$symbol =~ s/(?<=[\$\@\%\&\*])::/main::/;
-	$symbol;
-}
-=pod
-=head2 symbol
-The C<symbol> method returns the ACTUAL symbol this token refers to.
-A token of C<$foo> might actually be referring to C<@foo>, if it is found
-in the form C<$foo[1]>.
-This method attempts to resolve these issues to determine the actual
-symbol.
-Returns the symbol as a string.
-=cut
-my %cast_which_trumps_braces = map { $_ => 1 } qw{ $ @ % };
-sub symbol {
-	my $self   = shift;
-	my $symbol = $self->canonical;
-	# Immediately return the cases where it can't be anything else
-	my $type = substr( $symbol, 0, 1 );
-	return $symbol if $type eq '&';
-	# Unless the next significant Element is a structure, it's correct.
-	my $after  = $self->snext_sibling;
-	return $symbol unless _INSTANCE($after, 'PPI::Structure');
-	# Process the rest for cases where it might actually be something else
-	my $braces = $after->braces;
-	return $symbol unless defined $braces;
-	if ( $type eq '$' ) {
-		# If it is cast to '$' or '@', that trumps any braces
-		my $before = $self->sprevious_sibling;
-		return $symbol if $before &&
-			$before->isa( 'PPI::Token::Cast' ) &&
-			$cast_which_trumps_braces{ $before->content };
-		# Otherwise the braces rule
-		substr( $symbol, 0, 1, '@' ) if $braces eq '[]';
-		substr( $symbol, 0, 1, '%' ) if $braces eq '{}';
-	} elsif ( $type eq '@' ) {
-		substr( $symbol, 0, 1, '%' ) if $braces eq '{}';
-	} elsif ( $type eq '%' ) {
-		substr( $symbol, 0, 1, '@' ) if $braces eq '[]';
-	}
-	$symbol;
-}
-=pod
-=head2 raw_type
-The C<raw_type> method returns the B<apparent> type of the symbol in the
-form of its sigil.
-Returns the sigil as a string.
-=cut
-sub raw_type {
-	substr( $_[0]->content, 0, 1 );
-}
-=pod
-=head2 symbol_type
-The C<symbol_type> method returns the B<actual> type of the symbol in the
-form of its sigil.
-Returns the sigil as a string.
-=cut
-sub symbol_type {
-	substr( $_[0]->symbol, 0, 1 );
-}
-#####################################################################
-# Tokenizer Methods
-sub __TOKENIZER__on_char {
-	my $t = $_[1];
-	# Suck in till the end of the symbol
-	pos $t->{line} = $t->{line_cursor};
-	if ( $t->{line} =~ m/\G([\w:\']+)/gc ) {
-		$t->{token}->{content} .= $1;
-		$t->{line_cursor}      += length $1;
-	}
-	# Handle magic things
-	my $content = $t->{token}->{content};
-	if ( $content eq '@_' or $content eq '$_' ) {
-		$t->{class} = $t->{token}->set_class( 'Magic' );
-		return $t->_finalize_token->__TOKENIZER__on_char( $t );
-	}
-	# Shortcut for most of the X:: symbols
-	if ( $content eq '$::' ) {
-		# May well be an alternate form of a Magic
-		my $nextchar = substr( $t->{line}, $t->{line_cursor}, 1 );
-		if ( $nextchar eq '|' ) {
-			$t->{token}->{content} .= $nextchar;
-			$t->{line_cursor}++;
-			$t->{class} = $t->{token}->set_class( 'Magic' );
-		}
-		return $t->_finalize_token->__TOKENIZER__on_char( $t );
-	}
-	if ( $content =~ /^[\$%*@&]::(?:[^\w]|$)/ ) {
-		my $current = substr( $content, 0, 3, '' );
-		$t->{token}->{content} = $current;
-		$t->{line_cursor} -= length( $content );
-		return $t->_finalize_token->__TOKENIZER__on_char( $t );
-	}
-	if ( $content =~ /^(?:\$|\@)\d+/ ) {
-		$t->{class} = $t->{token}->set_class( 'Magic' );
-		return $t->_finalize_token->__TOKENIZER__on_char( $t );
-	}
-	# Trim off anything we oversucked...
-	$content =~ /^(
-		[\$@%&*]
-		(?: : (?!:) | # Allow single-colon non-magic variables
-			(?: \w+ | \' (?!\d) \w+ | \:: \w+ )
-			(?:
-				# Allow both :: and ' in namespace separators
-				(?: \' (?!\d) \w+ | \:: \w+ )
-			)*
-			(?: :: )? # Technically a compiler-magic hash, but keep it here
-		)
-	)/x or return undef;
-	unless ( length $1 eq length $content ) {
-		$t->{line_cursor} += length($1) - length($content);
-		$t->{token}->{content} = $1;
-	}
-	$t->_finalize_token->__TOKENIZER__on_char( $t );
-}
-1;
-=pod
-=head1 SUPPORT
-See the L<support section|PPI/SUPPORT> in the main module.
-=head1 AUTHOR
-Adam Kennedy E<lt>adamk@cpan.orgE<gt>
-=head1 COPYRIGHT
-Copyright 2001 - 2011 Adam Kennedy.
-This program is free software; you can redistribute
-it and/or modify it under the same terms as Perl itself.
-The full text of the license can be found in the
-LICENSE file included with this module.
-=cut