Devendor weatherspect

3 files changed, 673 insertions, 8 deletions

diff --git a/.SRCINFO b/.SRCINFO
index ebdfc65cb032..666c473c0a7e 100644
--- a/.SRCINFO
+++ b/.SRCINFO
@@ -1,18 +1,22 @@
 pkgbase = weatherspect-git
 	pkgdesc = A virtual weather environment in ASCII - git version
 	pkgver = 2.0.r3.g0f85875
-	pkgrel = 1
+	pkgrel = 2
 	url = https://github.com/AnotherFoxGuy/weatherspect
 	arch = any
 	license = GPL2
 	makedepends = git
 	depends = perl
+	depends = perl-compass-points
+	depends = perl-json
 	depends = perl-term-animation
 	provides = weatherspect
 	conflicts = weatherspect
 	source = weatherspect-git::git+https://github.com/AnotherFoxGuy/weatherspect
+	source = devendor.diff
 	source = weatherspect.1
-	sha256sums = SKIP
-	sha256sums = 8b0d7bb995e44190cc005ec3b604f147dcb233744a262cbbf9a9ad8f9214ab0c
+	sha512sums = SKIP
+	sha512sums = adaadc88a212143a1d232756dda48580d612ce93024dd467608571344963dc6f9aa4fe0d2730f55f451946a47d31ac83fb9def18e10e33192b1b656db698b673
+	sha512sums = 494dcc31151912ae6965a6c7f6323f1c3fbfa01f1eadc72838e605917ab6a4df4aba95aab2a891070eb928817b35240eecfa3d6a4fc285ff8a4e729044968caa
 
 pkgname = weatherspect-git
diff --git a/PKGBUILD b/PKGBUILD
index c60c686ba32a..f555a49695a7 100644
--- a/PKGBUILD
+++ b/PKGBUILD
@@ -1,28 +1,38 @@
-# Maintainer: Daniel Peukert <dan.peukert@gmail.com>
+# Maintainer: Daniel Peukert <daniel@peukert.cc>
 # Contributor: Kevin MacMartin <prurigro at gmail dot com>
 # Contributor: Lara Maia <lara@craft.net.br>
 # Contributor: archlinux.info:tdy
 _pkgname='weatherspect'
 pkgname="$_pkgname-git"
 pkgver='2.0.r3.g0f85875'
-pkgrel='1'
+pkgrel='2'
 pkgdesc='A virtual weather environment in ASCII - git version'
 arch=('any')
 url="https://github.com/AnotherFoxGuy/$_pkgname"
 license=('GPL2')
-depends=('perl' 'perl-term-animation')
+depends=('perl' 'perl-compass-points' 'perl-json' 'perl-term-animation')
 makedepends=('git')
 provides=("$_pkgname")
 conflicts=("$_pkgname")
 source=(
 	"$pkgname::git+$url"
+	'devendor.diff'
 	"$_pkgname.1"
 )
-sha256sums=('SKIP'
-            '8b0d7bb995e44190cc005ec3b604f147dcb233744a262cbbf9a9ad8f9214ab0c')
+sha512sums=('SKIP'
+            'adaadc88a212143a1d232756dda48580d612ce93024dd467608571344963dc6f9aa4fe0d2730f55f451946a47d31ac83fb9def18e10e33192b1b656db698b673'
+            '494dcc31151912ae6965a6c7f6323f1c3fbfa01f1eadc72838e605917ab6a4df4aba95aab2a891070eb928817b35240eecfa3d6a4fc285ff8a4e729044968caa')
 
 _sourcedirectory="$pkgname"
 
+
+prepare() {
+	cd "$srcdir/$_sourcedirectory/"
+
+	# Devendor perl-compass-points and perl-json
+	patch --forward -p1 < '../devendor.diff'
+}
+
 pkgver() {
 	cd "$srcdir/$_sourcedirectory/"
 	git describe --long --tags | sed -e 's/-\([^-]*-g[^-]*\)$/-r\1/' -e 's/-/./g'
diff --git a/devendor.diff b/devendor.diff
new file mode 100644
index 000000000000..876b77534902
--- /dev/null
+++ b/devendor.diff
@@ -0,0 +1,651 @@
+diff --git a/weatherspect b/weatherspect
+index 5a8716c..774c9e8 100755
+--- a/weatherspect
++++ b/weatherspect
+@@ -44,6 +44,8 @@
+ #############################################################################
+ 
+ use Term::Animation 2.5;
++use Compass::Points;
++use JSON;
+ 
+ use Curses;
+ use Data::Dumper;
+@@ -5289,636 +5291,3 @@ Copyright (C) 2018 Edgar (Edgar@AnotherFoxGuy).  All rights reserved.  Use is su
+     1;
+ 
+ }
+-
+-
+-# From http://search.cpan.org/~janus/Compass-Points-0.02/lib/Compass/Points.pm
+-BEGIN{
+-    package Compass::Points;
+-
+-    use strict;
+-    use warnings;
+-
+-    our $VERSION = "0.02";
+-
+-    our @FIELDS = qw(abbr name);
+-    our @NAMES = (
+-        [ N => "North" ],
+-        [ NbE => "North by east" ],
+-        [ NNE => "North-northeast" ],
+-        [ NEbN => "Northeast by north" ],
+-        [ NE => "Northeast" ],
+-        [ NEbE => "Northeast by east" ],
+-        [ ENE => "East-northeast" ],
+-        [ EbN => "East by north" ],
+-        [ E => "East" ],
+-        [ EbS => "East by south" ],
+-        [ ESE => "East-southeast" ],
+-        [ SEbE => "Southeast by east" ],
+-        [ SE => "Southeast" ],
+-        [ SEbS => "Southeast by south" ],
+-        [ SSE => "South-southeast" ],
+-        [ SbE => "South by east" ],
+-        [ S => "South" ],
+-        [ SbW => "South by west" ],
+-        [ SSW => "South-southwest" ],
+-        [ SWbS => "Southwest by south" ],
+-        [ SW => "Southwest" ],
+-        [ SWbW => "Southwest by west" ],
+-        [ WSW => "West-southwest" ],
+-        [ WbS => "West by south" ],
+-        [ W => "West" ],
+-        [ WbN => "West by north" ],
+-        [ WNW => "West-northwest" ],
+-        [ NWbW => "Northwest by west" ],
+-        [ NW => "Northwest" ],
+-        [ NWbN => "Northwest by north" ],
+-        [ NNW => "North-northwest" ],
+-        [ NbW => "North by west" ],
+-    );
+-    our @GROUP; # separate groups to assign different degree values
+-    our @INDEX; # index per group
+-    our @MAP;   # mapping for easy access
+-
+-    for my $n (0 .. 3) {
+-        my $slice = 360 / (2 ** (2 + $n));            # 90, 45, 22.5, 11.25
+-        my $mod = 2 ** (3 - $n);                      # 8, 4, 2, 1
+-        my @offs = grep $_ % $mod == 0, 0 .. $#NAMES; # 0,8,16,24 0,4,8,12,...
+-
+-        $GROUP[ $n ] = bless([], __PACKAGE__);
+-
+-        for my $m (0 .. $#offs) {
+-            my @entry = @{$NAMES[ $offs[ $m ] ]};
+-
+-            for my $key (map lc, @entry) {
+-                $key =~ s![^a-z]!!g;
+-
+-                $INDEX[ $n ]{ $key } = \@entry;
+-            }
+-
+-            $entry[ 2 ] = $m * $slice;
+-
+-            $GROUP[ $n ][ $m ] = \@entry;
+-        }
+-
+-        $MAP[ $_ ] = $n for @MAP .. $#offs;
+-    }
+-
+-    sub new {
+-        my $class = shift;
+-        my $number = shift || 16;
+-
+-        $number = @{$GROUP[ $#GROUP ]}
+-            if $number > @{$GROUP[ $#GROUP ]};
+-
+-        return $GROUP[ $MAP[ $number - 1 ] ];
+-    }
+-
+-    for my $offset (0 .. $#FIELDS) {
+-        my $deg2sub = "deg2$FIELDS[ $offset ]";
+-        my $sub2deg = "$FIELDS[ $offset ]2deg";
+-
+-        no strict qw(refs);
+-
+-        *$deg2sub = sub {
+-            my $self = shift;
+-            my $deg = abs(shift || 0);
+-
+-            $deg -= 360 while $deg > 360;
+-
+-            my $slice = 360 / @$self;
+-            my $index = ($deg + $slice / 2) / $slice;
+-
+-            return $self->[ $index ][ $offset ];
+-        };
+-
+-        *$sub2deg = sub {
+-            my $self = shift;
+-            my $key = lc(shift || "");
+-            my $index = $INDEX[ $MAP[ @$self - 1 ] ];
+-
+-            $key =~ s![^a-z]!!g;
+-
+-            return exists($index->{ $key })
+-                ? $index->{ $key }[ 2 ]
+-                : undef
+-            ;
+-        };
+-    }
+-
+-    1;
+-
+-=head1 NAME
+-
+-Compass::Points - Convert between compass point names, abbreviations and values
+-
+-=head1 SYNOPSIS
+-
+-  use Compass::Points;
+-  my $points = Compass::Points->new();
+-  my $deg = $points->abbr2deg( "NNE" );
+-
+-=head1 DESCRIPTION
+-
+-This module converts compass point names and abbreviations to degrees
+-and vice versa.
+-It supports four different compass point systems: 4, 8, 16 and 32.
+-The default is 16 and can be used for wind compass usage.
+-
+-=head1 METHODS
+-
+-=head2 new( [ $points ] )
+-
+-Returns a Compass::Points object for the number of points (defaults to 16).
+-
+-=head2 deg2abbr( $degree )
+-
+-Takes a degree value and returns the corresponding abbreviation for the
+-matching wind name.
+-
+-=head2 deg2name( $degree )
+-
+-Same as deg2abbr() but returns the full wind name.
+-
+-=head2 abbr2deg( $abbreviation )
+-
+-Given a wind name abbreviation returns the degree of the points object.
+-
+-=head2 name2deg( $name )
+-
+-Same as abbr2deg() but takes full wind names.
+-
+-=head1 SEE ALSO
+-
+-L<http://en.wikipedia.org/wiki/Points_of_the_compass>
+-
+-=head1 AUTHOR
+-
+-Simon Bertrang, E<lt>janus@cpan.orgE<gt>
+-
+-=head1 COPYRIGHT AND LICENSE
+-
+-Copyright (C) 2014 by Simon Bertrang
+-
+-This library is free software; you can redistribute it and/or modify
+-it under the same terms as Perl itself.
+-
+-=cut
+-}
+-
+-
+-BEGIN{
+-    package JSON;
+-
+-
+-    use strict;
+-    use Carp ();
+-    use Exporter;
+-    BEGIN {@JSON::ISA = 'Exporter'}
+-
+-    @JSON::EXPORT = qw(from_json to_json jsonToObj objToJson encode_json decode_json);
+-
+-    BEGIN {
+-        $JSON::VERSION = '4.02';
+-        $JSON::DEBUG = 0 unless (defined $JSON::DEBUG);
+-        $JSON::DEBUG = $ENV{ PERL_JSON_DEBUG } if exists $ENV{ PERL_JSON_DEBUG };
+-    }
+-
+-    my %RequiredVersion = (
+-        'JSON::PP' => '2.27203',
+-        'JSON::XS' => '2.34',
+-    );
+-
+-    # XS and PP common methods
+-
+-    my @PublicMethods = qw/
+-        ascii latin1 utf8 pretty indent space_before space_after relaxed canonical allow_nonref
+-        allow_blessed convert_blessed filter_json_object filter_json_single_key_object
+-        shrink max_depth max_size encode decode decode_prefix allow_unknown
+-    /;
+-
+-    my @Properties = qw/
+-        ascii latin1 utf8 indent space_before space_after relaxed canonical allow_nonref
+-        allow_blessed convert_blessed shrink max_depth max_size allow_unknown
+-    /;
+-
+-    my @XSOnlyMethods = qw//; # Currently nothing
+-
+-    my @PublicMethodsSince4_0 = qw/allow_tags/;
+-    my @PropertiesSince4_0 = qw/allow_tags/;
+-
+-    my @PPOnlyMethods = qw/
+-        indent_length sort_by
+-        allow_singlequote allow_bignum loose allow_barekey escape_slash as_nonblessed
+-    /; # JSON::PP specific
+-
+-
+-    # used in _load_xs and _load_pp ($INSTALL_ONLY is not used currently)
+-    my $_INSTALL_DONT_DIE = 1; # When _load_xs fails to load XS, don't die.
+-    my $_ALLOW_UNSUPPORTED = 0;
+-    my $_UNIV_CONV_BLESSED = 0;
+-
+-
+-    # Check the environment variable to decide worker module.
+-
+-    unless ($JSON::Backend) {
+-        $JSON::DEBUG and Carp::carp("Check used worker module...");
+-
+-        my $backend = exists $ENV{PERL_JSON_BACKEND} ? $ENV{PERL_JSON_BACKEND} : 1;
+-
+-        if ($backend eq '1') {
+-            $backend = 'JSON::XS,JSON::PP';
+-        }
+-        elsif ($backend eq '0') {
+-            $backend = 'JSON::PP';
+-        }
+-        elsif ($backend eq '2') {
+-            $backend = 'JSON::XS';
+-        }
+-        $backend =~ s/\s+//g;
+-
+-        my @backend_modules = split /,/, $backend;
+-        while (my $module = shift @backend_modules) {
+-            if ($module =~ /JSON::XS/) {
+-                _load_xs($module, @backend_modules ? $_INSTALL_DONT_DIE : 0);
+-            }
+-            elsif ($module =~ /JSON::PP/) {
+-                _load_pp($module);
+-            }
+-            elsif ($module =~ /JSON::backportPP/) {
+-                _load_pp($module);
+-            }
+-            else {
+-                Carp::croak "The value of environmental variable 'PERL_JSON_BACKEND' is invalid.";
+-            }
+-            last if $JSON::Backend;
+-        }
+-    }
+-
+-
+-    sub import {
+-        my $pkg = shift;
+-        my @what_to_export;
+-        my $no_export;
+-
+-        for my $tag (@_) {
+-            if ($tag eq '-support_by_pp') {
+-                if (!$_ALLOW_UNSUPPORTED++) {
+-                    JSON::Backend::XS
+-                        ->support_by_pp(@PPOnlyMethods) if ($JSON::Backend->is_xs);
+-                }
+-                next;
+-            }
+-            elsif ($tag eq '-no_export') {
+-                $no_export++, next;
+-            }
+-            elsif ($tag eq '-convert_blessed_universally') {
+-                my $org_encode = $JSON::Backend->can('encode');
+-                eval q|
+-                require B;
+-                local $^W;
+-                no strict 'refs';
+-                *{"${JSON::Backend}\::encode"} = sub {
+-                    # only works with Perl 5.18+
+-                    local *UNIVERSAL::TO_JSON = sub {
+-                        my $b_obj = B::svref_2object( $_[0] );
+-                        return    $b_obj->isa('B::HV') ? { %{ $_[0] } }
+-                                : $b_obj->isa('B::AV') ? [ @{ $_[0] } ]
+-                                : undef
+-                                ;
+-                    };
+-                    $org_encode->(@_);
+-                };
+-            | if (!$_UNIV_CONV_BLESSED++);
+-                next;
+-            }
+-            push @what_to_export, $tag;
+-        }
+-
+-        return if ($no_export);
+-
+-        __PACKAGE__->export_to_level(1, $pkg, @what_to_export);
+-    }
+-
+-
+-    # OBSOLETED
+-
+-    sub jsonToObj {
+-        my $alternative = 'from_json';
+-        if (defined $_[0] and UNIVERSAL::isa($_[0], 'JSON')) {
+-            shift @_;
+-            $alternative = 'decode';
+-        }
+-        Carp::carp "'jsonToObj' will be obsoleted. Please use '$alternative' instead.";
+-        return JSON::from_json(@_);
+-    };
+-
+-    sub objToJson {
+-        my $alternative = 'to_json';
+-        if (defined $_[0] and UNIVERSAL::isa($_[0], 'JSON')) {
+-            shift @_;
+-            $alternative = 'encode';
+-        }
+-        Carp::carp "'objToJson' will be obsoleted. Please use '$alternative' instead.";
+-        JSON::to_json(@_);
+-    };
+-
+-
+-    # INTERFACES
+-
+-    sub to_json($@) {
+-        if (
+-            ref($_[0]) eq 'JSON'
+-                or (@_ > 2 and $_[0] eq 'JSON')
+-        ) {
+-            Carp::croak "to_json should not be called as a method.";
+-        }
+-        my $json = JSON->new;
+-
+-        if (@_ == 2 and ref $_[1] eq 'HASH') {
+-            my $opt = $_[1];
+-            for my $method (keys %$opt) {
+-                $json->$method($opt->{$method});
+-            }
+-        }
+-
+-        $json->encode($_[0]);
+-    }
+-
+-
+-    sub from_json($@) {
+-        if (ref($_[0]) eq 'JSON' or $_[0] eq 'JSON') {
+-            Carp::croak "from_json should not be called as a method.";
+-        }
+-        my $json = JSON->new;
+-
+-        if (@_ == 2 and ref $_[1] eq 'HASH') {
+-            my $opt = $_[1];
+-            for my $method (keys %$opt) {
+-                $json->$method($opt->{$method});
+-            }
+-        }
+-
+-        return $json->decode($_[0]);
+-    }
+-
+-
+-
+-    sub true {$JSON::true}
+-
+-    sub false {$JSON::false}
+-
+-    sub boolean {
+-        # might be called as method or as function, so pop() to get the last arg instead of shift() to get the first
+-        pop() ? $JSON::true : $JSON::false
+-    }
+-
+-    sub null {undef;}
+-
+-
+-    sub require_xs_version {$RequiredVersion{'JSON::XS'};}
+-
+-    sub backend {
+-        my $proto = shift;
+-        $JSON::Backend;
+-    }
+-
+-    #*module = *backend;
+-
+-
+-    sub is_xs {
+-        return $_[0]->backend->is_xs;
+-    }
+-
+-
+-    sub is_pp {
+-        return $_[0]->backend->is_pp;
+-    }
+-
+-
+-    sub pureperl_only_methods {@PPOnlyMethods;}
+-
+-
+-    sub property {
+-        my ($self, $name, $value) = @_;
+-
+-        if (@_ == 1) {
+-            my %props;
+-            for $name (@Properties) {
+-                my $method = 'get_' . $name;
+-                if ($name eq 'max_size') {
+-                    my $value = $self->$method();
+-                    $props{$name} = $value == 1 ? 0 : $value;
+-                    next;
+-                }
+-                $props{$name} = $self->$method();
+-            }
+-            return \%props;
+-        }
+-        elsif (@_ > 3) {
+-            Carp::croak('property() can take only the option within 2 arguments.');
+-        }
+-        elsif (@_ == 2) {
+-            if (my $method = $self->can('get_' . $name)) {
+-                if ($name eq 'max_size') {
+-                    my $value = $self->$method();
+-                    return $value == 1 ? 0 : $value;
+-                }
+-                $self->$method();
+-            }
+-        }
+-        else {
+-            $self->$name($value);
+-        }
+-
+-    }
+-
+-
+-    # INTERNAL
+-
+-    sub __load_xs {
+-        my ($module, $opt) = @_;
+-
+-        $JSON::DEBUG and Carp::carp "Load $module.";
+-        my $required_version = $RequiredVersion{$module} || '';
+-
+-        eval qq|
+-        use $module $required_version ();
+-    |;
+-
+-        if ($@) {
+-            if (defined $opt and $opt & $_INSTALL_DONT_DIE) {
+-                $JSON::DEBUG and Carp::carp "Can't load $module...($@)";
+-                return 0;
+-            }
+-            Carp::croak $@;
+-        }
+-        $JSON::BackendModuleXS = $module;
+-        return 1;
+-    }
+-
+-    sub _load_xs {
+-        my ($module, $opt) = @_;
+-        __load_xs($module, $opt) or return;
+-
+-        my $data = join("", <DATA>); # this code is from Jcode 2.xx.
+-        close(DATA);
+-        eval $data;
+-        JSON::Backend::XS->init($module);
+-
+-        return 1;
+-    };
+-
+-
+-    sub __load_pp {
+-        my ($module, $opt) = @_;
+-
+-        $JSON::DEBUG and Carp::carp "Load $module.";
+-        my $required_version = $RequiredVersion{$module} || '';
+-
+-        eval qq| use $module $required_version () |;
+-
+-        if ($@) {
+-            if ($module eq 'JSON::PP') {
+-                $JSON::DEBUG and Carp::carp "Can't load $module ($@), so try to load JSON::backportPP";
+-                $module = 'JSON::backportPP';
+-                local $^W; # if PP installed but invalid version, backportPP redefines methods.
+-                eval qq| require $module |;
+-            }
+-            Carp::croak $@ if $@;
+-        }
+-        $JSON::BackendModulePP = $module;
+-        return 1;
+-    }
+-
+-    sub _load_pp {
+-        my ($module, $opt) = @_;
+-        __load_pp($module, $opt);
+-
+-        JSON::Backend::PP->init($module);
+-    };
+-
+-    #
+-    # Helper classes for Backend Module (PP)
+-    #
+-
+-    package JSON::Backend::PP;
+-
+-    sub init {
+-        my ($class, $module) = @_;
+-
+-        # name may vary, but the module should (always) be a JSON::PP
+-
+-        local $^W;
+-        no strict qw(refs); # this routine may be called after JSON::Backend::XS init was called.
+-        *{"JSON::decode_json"} = \&{"JSON::PP::decode_json"};
+-        *{"JSON::encode_json"} = \&{"JSON::PP::encode_json"};
+-        *{"JSON::is_bool"} = \&{"JSON::PP::is_bool"};
+-
+-        $JSON::true = ${"JSON::PP::true"};
+-        $JSON::false = ${"JSON::PP::false"};
+-
+-        push @JSON::Backend::PP::ISA, 'JSON::PP';
+-        push @JSON::ISA, $class;
+-        $JSON::Backend = $class;
+-        $JSON::BackendModule = $module;
+-        my $version = ${"$class\::VERSION"} = $module->VERSION;
+-        $version =~ s/_//;
+-        if ($version < 3.99) {
+-            push @XSOnlyMethods, qw/allow_tags get_allow_tags/;
+-        }
+-        else {
+-            push @Properties, 'allow_tags';
+-        }
+-
+-        for my $method (@XSOnlyMethods) {
+-            *{"JSON::$method"} = sub {
+-                Carp::carp("$method is not supported by $module $version.");
+-                $_[0];
+-            };
+-        }
+-
+-        return 1;
+-    }
+-
+-    sub is_xs {0};
+-    sub is_pp {1};
+-
+-    #
+-    # To save memory, the below lines are read only when XS backend is used.
+-    #
+-
+-    package JSON;
+-
+-    1;
+-
+-    #
+-    # Helper classes for Backend Module (XS)
+-    #
+-
+-    package JSON::Backend::XS;
+-
+-    sub init {
+-        my ($class, $module) = @_;
+-
+-        local $^W;
+-        no strict qw(refs);
+-        *{"JSON::decode_json"} = \&{"$module\::decode_json"};
+-        *{"JSON::encode_json"} = \&{"$module\::encode_json"};
+-        *{"JSON::is_bool"} = \&{"$module\::is_bool"};
+-
+-        $JSON::true = ${"$module\::true"};
+-        $JSON::false = ${"$module\::false"};
+-
+-        push @JSON::Backend::XS::ISA, $module;
+-        push @JSON::ISA, $class;
+-        $JSON::Backend = $class;
+-        $JSON::BackendModule = $module;
+-        ${"$class\::VERSION"} = $module->VERSION;
+-
+-        if ($module->VERSION < 3) {
+-            eval 'package JSON::PP::Boolean';
+-            push @{"$module\::Boolean::ISA"}, qw(JSON::PP::Boolean);
+-        }
+-
+-        for my $method (@PPOnlyMethods) {
+-            *{"JSON::$method"} = sub {
+-                Carp::carp("$method is not supported by $module.");
+-                $_[0];
+-            };
+-        }
+-
+-        return 1;
+-    }
+-
+-    sub is_xs {1};
+-    sub is_pp {0};
+-
+-    sub support_by_pp {
+-        my ($class, @methods) = @_;
+-
+-        JSON::__load_pp('JSON::PP');
+-
+-        local $^W;
+-        no strict qw(refs);
+-
+-        for my $method (@methods) {
+-            my $pp_method = JSON::PP->can($method) or next;
+-            *{"JSON::$method"} = sub {
+-                if (!$_[0]->isa('JSON::PP')) {
+-                    my $xs_self = $_[0];
+-                    my $pp_self = JSON::PP->new;
+-                    for (@Properties) {
+-                        my $getter = "get_$_";
+-                        $pp_self->$_($xs_self->$getter);
+-                    }
+-                    $_[0] = $pp_self;
+-                }
+-                $pp_method->(@_);
+-            };
+-        }
+-
+-        $JSON::DEBUG and Carp::carp("set -support_by_pp mode.");
+-    }
+-
+-    1;
+-}
+\ No newline at end of file