

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: Filters.pm</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>#============================================================= -*-Perl-*-
#
# Template::Filters
#
# DESCRIPTION
#   Defines filter plugins as used by the FILTER directive.
#
# AUTHORS
#   Andy Wardley &lt;abw@wardley.org&gt;, with a number of filters contributed
#   by Leslie Michael Orchard &lt;deus_x@nijacode.com&gt;
#
# COPYRIGHT
#   Copyright (C) 1996-2022 Andy Wardley.  All Rights Reserved.
#
#   This module is free software; you can redistribute it and/or
#   modify it under the same terms as Perl itself.
#
#============================================================================

package Template::Filters;

use strict;
use warnings;
use locale;
use base &#039;Template::Base&#039;;
use Template::Constants;
use Scalar::Util &#039;blessed&#039;;

our $VERSION         = &#039;3.106&#039;;
our $AVAILABLE       = { };
our $TRUNCATE_LENGTH = 32;
our $TRUNCATE_ADDON  = &#039;...&#039;;


#------------------------------------------------------------------------
# standard filters, defined in one of the following forms:
#   name =&gt;   \&amp;static_filter
#   name =&gt; [ \&amp;subref, $is_dynamic ]
# If the $is_dynamic flag is set then the sub-routine reference
# is called to create a new filter each time it is requested;  if
# not set, then it is a single, static sub-routine which is returned
# for every filter request for that name.
#------------------------------------------------------------------------

our $FILTERS = {
    # static filters
    &#039;html&#039;            =&gt; \&amp;html_filter,
    &#039;html_para&#039;       =&gt; \&amp;html_paragraph,
    &#039;html_break&#039;      =&gt; \&amp;html_para_break,
    &#039;html_para_break&#039; =&gt; \&amp;html_para_break,
    &#039;html_line_break&#039; =&gt; \&amp;html_line_break,
    &#039;xml&#039;             =&gt; \&amp;xml_filter,
    &#039;uri&#039;             =&gt; \&amp;uri_filter,
    &#039;url&#039;             =&gt; \&amp;url_filter,
    &#039;upper&#039;           =&gt; sub { uc $_[0] },
    &#039;lower&#039;           =&gt; sub { lc $_[0] },
    &#039;ucfirst&#039;         =&gt; sub { ucfirst $_[0] },
    &#039;lcfirst&#039;         =&gt; sub { lcfirst $_[0] },
    &#039;stderr&#039;          =&gt; sub { print STDERR @_; return &#039;&#039; },
    &#039;trim&#039;            =&gt; sub { for ($_[0]) { s/^\s+//; s/\s+$// }; $_[0] },
    &#039;null&#039;            =&gt; sub { return &#039;&#039; },
    &#039;collapse&#039;        =&gt; sub { for ($_[0]) { s/^\s+//; s/\s+$//; s/\s+/ /g };
                               $_[0] },

    # dynamic filters
    &#039;html_entity&#039; =&gt; [ \&amp;html_entity_filter_factory, 1 ],
    &#039;indent&#039;      =&gt; [ \&amp;indent_filter_factory,      1 ],
    &#039;format&#039;      =&gt; [ \&amp;format_filter_factory,      1 ],
    &#039;truncate&#039;    =&gt; [ \&amp;truncate_filter_factory,    1 ],
    &#039;repeat&#039;      =&gt; [ \&amp;repeat_filter_factory,      1 ],
    &#039;replace&#039;     =&gt; [ \&amp;replace_filter_factory,     1 ],
    &#039;remove&#039;      =&gt; [ \&amp;remove_filter_factory,      1 ],
    &#039;eval&#039;        =&gt; [ \&amp;eval_filter_factory,        1 ],
    &#039;evaltt&#039;      =&gt; [ \&amp;eval_filter_factory,        1 ],  # alias
    &#039;perl&#039;        =&gt; [ \&amp;perl_filter_factory,        1 ],
    &#039;evalperl&#039;    =&gt; [ \&amp;perl_filter_factory,        1 ],  # alias
    &#039;redirect&#039;    =&gt; [ \&amp;redirect_filter_factory,    1 ],
    &#039;file&#039;        =&gt; [ \&amp;redirect_filter_factory,    1 ],  # alias
    &#039;stdout&#039;      =&gt; [ \&amp;stdout_filter_factory,      1 ],
};

# name of module implementing plugin filters
our $PLUGIN_FILTER = &#039;Template::Plugin::Filter&#039;;


#========================================================================
#                         -- PUBLIC METHODS --
#========================================================================

#------------------------------------------------------------------------
# fetch($name, \@args, $context)
#
# Attempts to instantiate or return a reference to a filter sub-routine
# named by the first parameter, $name, with additional constructor
# arguments passed by reference to a list as the second parameter,
# $args.  A reference to the calling Template::Context object is
# passed as the third parameter.
#
# Returns a reference to a filter sub-routine or a pair of values
# (undef, STATUS_DECLINED) or ($error, STATUS_ERROR) to decline to
# deliver the filter or to indicate an error.
#------------------------------------------------------------------------

sub fetch {
    my ($self, $name, $args, $context) = @_;
    my ($factory, $is_dynamic, $filter, $error);

    $self-&gt;debug(&quot;fetch($name, &quot;,
                 defined $args ? (&#039;[ &#039;, join(&#039;, &#039;, @$args), &#039; ]&#039;) : &#039;&lt;no args&gt;&#039;, &#039;, &#039;,
                 $context // &#039;&lt;no context&gt;&#039;,
                 &#039;)&#039;) if $self-&gt;{ DEBUG };

    # allow $name to be specified as a reference to
    # a plugin filter object;  any other ref is
    # assumed to be a coderef and hence already a filter;
    # non-refs are assumed to be regular name lookups

    if (ref $name) {
        if (blessed($name) &amp;&amp; $name-&gt;isa($PLUGIN_FILTER)) {
            $factory = $name-&gt;factory()
                || return $self-&gt;error($name-&gt;error());
        }
        else {
            return $name;
        }
    }
    else {
        return (undef, Template::Constants::STATUS_DECLINED)
            unless ($factory = $self-&gt;{ FILTERS }-&gt;{ $name }
                    || $FILTERS-&gt;{ $name });
    }

    # factory can be an [ $code, $dynamic ] or just $code
    if (ref $factory eq &#039;ARRAY&#039;) {
        ($factory, $is_dynamic) = @$factory;
    }
    else {
        $is_dynamic = 0;
    }

    if (ref $factory eq &#039;CODE&#039;) {
        if ($is_dynamic) {
            # if the dynamic flag is set then the sub-routine is a
            # factory which should be called to create the actual
            # filter...
            eval {
                ($filter, $error) = &amp;$factory($context, $args ? @$args : ());
            };
            $error ||= $@;
            $error = &quot;invalid FILTER for &#039;$name&#039; (not a CODE ref)&quot;
                unless $error || ref($filter) eq &#039;CODE&#039;;
        }
        else {
            # ...otherwise, it&#039;s a static filter sub-routine
            $filter = $factory;
        }
    }
    else {
        $error = &quot;invalid FILTER entry for &#039;$name&#039; (not a CODE ref)&quot;;
    }

    if ($error) {
        return $self-&gt;{ TOLERANT }
               ? (undef,  Template::Constants::STATUS_DECLINED)
               : ($error, Template::Constants::STATUS_ERROR) ;
    }
    else {
        return $filter;
    }
}


#------------------------------------------------------------------------
# store($name, \&amp;filter)
#
# Stores a new filter in the internal FILTERS hash.  The first parameter
# is the filter name, the second a reference to a subroutine or
# array, as per the standard $FILTERS entries.
#------------------------------------------------------------------------

sub store {
    my ($self, $name, $filter) = @_;

    $self-&gt;debug(&quot;store($name, $filter)&quot;) if $self-&gt;{ DEBUG };

    $self-&gt;{ FILTERS }-&gt;{ $name } = $filter;
    return 1;
}


#========================================================================
#                        -- PRIVATE METHODS --
#========================================================================

#------------------------------------------------------------------------
# _init(\%config)
#
# Private initialisation method.
#------------------------------------------------------------------------

sub _init {
    my ($self, $params) = @_;

    $self-&gt;{ FILTERS  } = $params-&gt;{ FILTERS } || { };
    $self-&gt;{ TOLERANT } = $params-&gt;{ TOLERANT }  || 0;
    $self-&gt;{ DEBUG    } = ( $params-&gt;{ DEBUG } || 0 )
                          &amp; Template::Constants::DEBUG_FILTERS;


    return $self;
}

#========================================================================
#                         -- STATIC FILTER SUBS --
#========================================================================

#------------------------------------------------------------------------
# uri_filter() and url_filter() below can match using either RFC3986 or
# RFC2732.  See https://github.com/abw/Template2/issues/13
#-----------------------------------------------------------------------

our $UNSAFE_SPEC = {
    RFC2732 =&gt; q{A-Za-z0-9\-_.~!*&#039;()},
    RFC3986 =&gt; q{A-Za-z0-9\-_.~},
};
our $UNSAFE_CHARS = $UNSAFE_SPEC-&gt;{ RFC3986 };
our $URI_REGEX;
our $URL_REGEX;
our $URI_ESCAPES;

sub use_rfc2732 {
    $UNSAFE_CHARS = $UNSAFE_SPEC-&gt;{ RFC2732 };
    $URI_REGEX = $URL_REGEX = undef;
}

sub use_rfc3986 {
    $UNSAFE_CHARS = $UNSAFE_SPEC-&gt;{ RFC3986 };
    $URI_REGEX = $URL_REGEX = undef;
}

sub uri_escapes {
    return {
        map { ( chr($_), sprintf(&quot;%%%02X&quot;, $_) ) } (0..255),
    };
}

#------------------------------------------------------------------------
# uri_filter()                                           [% FILTER uri %]
#
# URI escape a string.  This code is borrowed from Gisle Aas&#039; URI::Escape
# module, copyright 1995-2004.  See RFC2396, RFC2732 and RFC3986 for
# details.
#-----------------------------------------------------------------------

sub uri_filter {
    my $text = shift;

    $URI_REGEX   ||= qr/([^$UNSAFE_CHARS])/;
    $URI_ESCAPES ||= uri_escapes();

    if ($] &gt;= 5.008 &amp;&amp; utf8::is_utf8($text)) {
        utf8::encode($text);
    }

    $text =~ s/$URI_REGEX/$URI_ESCAPES-&gt;{$1}/eg;
    $text;
}


#------------------------------------------------------------------------
# url_filter()                                           [% FILTER uri %]
#
# NOTE: the difference: url vs uri.
# This implements the old-style, non-strict behaviour of the uri filter
# which allows any valid URL characters to pass through so that
# http://example.com/blah.html does not get the &#039;:&#039; and &#039;/&#039; characters
# munged.
#-----------------------------------------------------------------------

sub url_filter {
    my $text = shift;

    $URL_REGEX   ||= qr/([^;\/?:@&amp;=+\$,$UNSAFE_CHARS])/;
    $URI_ESCAPES ||= uri_escapes();

    if ($] &gt;= 5.008 &amp;&amp; utf8::is_utf8($text)) {
        utf8::encode($text);
    }

    $text =~ s/$URL_REGEX/$URI_ESCAPES-&gt;{$1}/eg;
    $text;
}


#------------------------------------------------------------------------
# html_filter()                                         [% FILTER html %]
#
# Convert any &#039;&lt;&#039;, &#039;&gt;&#039;, &#039;&amp;&#039;, &#039;&quot;&#039; or &quot;&#039;&quot; characters to the HTML
# equivalents, &#039;&amp;lt;&#039;, &#039;&amp;gt;&#039;, &#039;&amp;amp;&#039;, &#039;&amp;quot;&#039; and &#039;&amp;#39;&#039;,
# respectively.
#------------------------------------------------------------------------

sub html_filter {
    my $text = shift;
    for ($text) {
        s/&amp;/&amp;amp;/g;
        s/&lt;/&amp;lt;/g;
        s/&gt;/&amp;gt;/g;
        s/&quot;/&amp;quot;/g;
        s/&#039;/&amp;#39;/g;
    }
    return $text;
}


#------------------------------------------------------------------------
# xml_filter()                                           [% FILTER xml %]
#
# Same as the html filter, but uses &amp;apos; for single quotes (the XML
# named entity) instead of &amp;#39; (the numeric reference used for HTML).
#------------------------------------------------------------------------

sub xml_filter {
    my $text = shift;
    for ($text) {
        s/&amp;/&amp;amp;/g;
        s/&lt;/&amp;lt;/g;
        s/&gt;/&amp;gt;/g;
        s/&quot;/&amp;quot;/g;
        s/&#039;/&amp;apos;/g;
    }
    return $text;
}


#------------------------------------------------------------------------
# html_paragraph()                                 [% FILTER html_para %]
#
# Wrap each paragraph of text (delimited by two or more newlines) in the
# &lt;p&gt;...&lt;/p&gt; HTML tags.
#------------------------------------------------------------------------

sub html_paragraph  {
    my $text = shift;
    return &quot;&lt;p&gt;\n&quot;
           . join(&quot;\n&lt;/p&gt;\n\n&lt;p&gt;\n&quot;, split(/(?:\r?\n){2,}/, $text))
           . &quot;&lt;/p&gt;\n&quot;;
}


#------------------------------------------------------------------------
# html_para_break()                          [% FILTER html_para_break %]
#
# Join each paragraph of text (delimited by two or more newlines) with
# &lt;br&gt;&lt;br&gt; HTML tags.
#------------------------------------------------------------------------

sub html_para_break  {
    my $text = shift;
    $text =~ s|(\r?\n){2,}|$1&lt;br /&gt;$1&lt;br /&gt;$1|g;
    return $text;
}

#------------------------------------------------------------------------
# html_line_break()                          [% FILTER html_line_break %]
#
# replaces any newlines with &lt;br&gt; HTML tags.
#------------------------------------------------------------------------

sub html_line_break  {
    my $text = shift;
    $text =~ s|(\r?\n)|&lt;br /&gt;$1|g;
    return $text;
}

#========================================================================
#                    -- DYNAMIC FILTER FACTORIES --
#========================================================================

#------------------------------------------------------------------------
# html_entity_filter_factory(\%options)                 [% FILTER html %]
#
# Dynamic version of the static html filter which attempts to locate the
# Apache::Util or HTML::Entities modules to perform full entity encoding
# of the text passed.  Returns an exception if one or other of the
# modules can&#039;t be located.
#------------------------------------------------------------------------

sub use_html_entities {
    require HTML::Entities;
    return ($AVAILABLE-&gt;{ HTML_ENTITY } = \&amp;HTML::Entities::encode_entities);
}

sub use_apache_util {
    require Apache::Util;
    Apache::Util::escape_html(&#039;&#039;);      # TODO: explain this
    return ($AVAILABLE-&gt;{ HTML_ENTITY } = \&amp;Apache::Util::escape_html);
}

sub html_entity_filter_factory {
    my $context = shift;
    my $haz;

    # if Apache::Util is installed then we use escape_html
    $haz = $AVAILABLE-&gt;{ HTML_ENTITY }
       ||  eval { use_apache_util()   }
       ||  eval { use_html_entities() }
       ||  -1;      # we use -1 for &quot;not available&quot; because it&#039;s a true value

    return ref $haz eq &#039;CODE&#039;
        ? $haz
        : (undef, Template::Exception-&gt;new(
            html_entity =&gt; &#039;cannot locate Apache::Util or HTML::Entities&#039; )
          );
}


#------------------------------------------------------------------------
# indent_filter_factory($pad)                    [% FILTER indent(pad) %]
#
# Create a filter to indent text by a fixed pad string or when $pad is
# numerical, a number of space.
#------------------------------------------------------------------------

sub indent_filter_factory {
    my ($context, $pad) = @_;
    $pad //= 4;
    $pad = &#039; &#039; x $pad if $pad =~ /^\d+$/;

    return sub {
        my $text = shift // &#039;&#039;;
        $text =~ s/^/$pad/mg;
        return $text;
    }
}

#------------------------------------------------------------------------
# format_filter_factory()                     [% FILTER format(format) %]
#
# Create a filter to format text according to a printf()-like format
# string.
#------------------------------------------------------------------------

sub format_filter_factory {
    my ($context, $format) = @_;
    $format //= &#039;%s&#039;;

    return sub {
        my $text = shift // &#039;&#039;;
        return join(&quot;\n&quot;, map{ sprintf($format, $_) } split(/\n/, $text));
    }
}


#------------------------------------------------------------------------
# repeat_filter_factory($n)                        [% FILTER repeat(n) %]
#
# Create a filter to repeat text n times.
#------------------------------------------------------------------------

sub repeat_filter_factory {
    my ($context, $iter) = @_;
    $iter = 1 unless defined $iter and length $iter;

    return sub {
        my $text = shift // &#039;&#039;;
        return join(&#039;\n&#039;, $text) x $iter;
    }
}


#------------------------------------------------------------------------
# replace_filter_factory($s, $r)    [% FILTER replace(search, replace) %]
#
# Create a filter to replace &#039;search&#039; text with &#039;replace&#039;
#------------------------------------------------------------------------

sub replace_filter_factory {
    my ($context, $search, $replace) = @_;
    $search //= &#039;&#039;;
    $replace //= &#039;&#039;;

    return sub {
        my $text = shift // &#039;&#039;;
        my $prev_end = -1;
        $text =~ s{$search}{
            my $s = $-[0];
            my $e = $+[0];
            if ($s == $e &amp;&amp; $s == $prev_end) {
                &#039;&#039;;
            } else {
                $prev_end = $e;
                $replace;
            }
        }eg;
        return $text;
    }
}


#------------------------------------------------------------------------
# remove_filter_factory($text)                  [% FILTER remove(text) %]
#
# Create a filter to remove &#039;search&#039; string from the input text.
#------------------------------------------------------------------------

sub remove_filter_factory {
    my ($context, $search) = @_;

    return sub {
        my $text = shift // &#039;&#039;;
        $text =~ s/$search//g;
        return $text;
    }
}


#------------------------------------------------------------------------
# truncate_filter_factory($n)                    [% FILTER truncate(n) %]
#
# Create a filter to truncate text after n characters.
#------------------------------------------------------------------------

sub truncate_filter_factory {
    my ($context, $len, $char) = @_;
    $len  //= $TRUNCATE_LENGTH;
    $char //= $TRUNCATE_ADDON;

    # Calculate visual length of the addon, treating HTML character entity
    # references (e.g. &amp;hellip; &amp;#8230; &amp;#x2026;) as single characters
    my $lchar = _visual_length($char);
    if ($len &lt; $lchar) {
        $char  = substr($char, 0, $len);
        $lchar = $len;
    }

    return sub {
        my $text = shift;
        return $text if _visual_length($text) &lt;= $len;
        return _truncate_visual($text, $len - $lchar) . $char;
    }
}


#------------------------------------------------------------------------
# _visual_length($str)
#
# Returns the &quot;visual&quot; length of a string, counting each HTML character
# entity reference (&amp;name; &amp;#digits; &amp;#xhex;) as a single character.
#------------------------------------------------------------------------

sub _visual_length {
    my $str = shift;
    (my $copy = $str) =~ s/&amp;(?:[a-zA-Z][a-zA-Z0-9]*|#[0-9]+|#x[0-9a-fA-F]+);/_/g;
    return length $copy;
}


#------------------------------------------------------------------------
# _truncate_visual($str, $maxlen)
#
# Truncates $str to at most $maxlen visual characters, treating HTML
# character entity references as single characters and never splitting
# one in the middle.
#------------------------------------------------------------------------

sub _truncate_visual {
    my ($str, $maxlen) = @_;
    my $result = &#039;&#039;;
    my $vlen   = 0;

    while ($str =~ /\G(&amp;(?:[a-zA-Z][a-zA-Z0-9]*|#[0-9]+|#x[0-9a-fA-F]+);|.)/gs) {
        last if $vlen &gt;= $maxlen;
        $result .= $1;
        $vlen++;
    }
    return $result;
}


#------------------------------------------------------------------------
# eval_filter_factory                                   [% FILTER eval %]
#
# Create a filter to evaluate template text.
#------------------------------------------------------------------------

sub eval_filter_factory {
    my $context = shift;

    return sub {
        my $text = shift;
        $context-&gt;process(\$text);
    }
}


#------------------------------------------------------------------------
# perl_filter_factory                                   [% FILTER perl %]
#
# Create a filter to process Perl text iff the context EVAL_PERL flag
# is set.
#------------------------------------------------------------------------

sub perl_filter_factory {
    my $context = shift;
    my $stash = $context-&gt;stash;

    return (undef, Template::Exception-&gt;new(&#039;perl&#039;, &#039;EVAL_PERL is not set&#039;))
        unless $context-&gt;eval_perl();

    return sub {
        my $text = shift;
        local($Template::Perl::context) = $context;
        local($Template::Perl::stash)   = $stash;
        my $out = eval &lt;&lt;EOF;
package Template::Perl;
\$stash = \$context-&gt;stash();
$text
EOF
        $context-&gt;throw($@) if $@;
        return $out;
    }
}


#------------------------------------------------------------------------
# redirect_filter_factory($context, $file)    [% FILTER redirect(file) %]
#
# Create a filter to redirect the block text to a file.
#------------------------------------------------------------------------

sub redirect_filter_factory {
    my ($context, $file, $options) = @_;
    my $outpath = $context-&gt;config-&gt;{ OUTPUT_PATH };

    return (undef, Template::Exception-&gt;new(&#039;redirect&#039;,
                                            &#039;OUTPUT_PATH is not set&#039;))
        unless $outpath;

    $context-&gt;throw(&#039;redirect&#039;, &quot;relative filenames are not supported: $file&quot;)
        if $file =~ m{(^|/)\.\./};

    $options = { binmode =&gt; $options } unless ref $options;

    sub {
        my $text = shift;
        my $outpath = $context-&gt;config-&gt;{ OUTPUT_PATH }
            || return &#039;&#039;;
        $outpath .= &quot;/$file&quot;;
        my $error = Template::_output($outpath, \$text, $options);
        die Template::Exception-&gt;new(&#039;redirect&#039;, $error)
            if $error;
        return &#039;&#039;;
    }
}


#------------------------------------------------------------------------
# stdout_filter_factory($context, $binmode)    [% FILTER stdout(binmode) %]
#
# Create a filter to print a block to stdout, with an optional binmode.
#------------------------------------------------------------------------

sub stdout_filter_factory {
    my ($context, $options) = @_;

    $options = { binmode =&gt; $options } unless ref $options;

    sub {
        my $text = shift;
        binmode(STDOUT) if $options-&gt;{ binmode };
        print STDOUT $text;
        return &#039;&#039;;
    }
}


1;

__END__

=head1 NAME

Template::Filters - Post-processing filters for template blocks

=head1 SYNOPSIS

    use Template::Filters;

    $filters = Template::Filters-&gt;new(\%config);

    ($filter, $error) = $filters-&gt;fetch($name, \@args, $context);

    if ($filter) {
        print &amp;$filter(&quot;some text&quot;);
    }
    else {
        print &quot;Could not fetch $name filter: $error\n&quot;;
    }

=head1 DESCRIPTION

The C&lt;Template::Filters&gt; module implements a provider for creating subroutines
that implement the standard filters. Additional custom filters may be provided
via the L&lt;FILTERS&gt; configuration option.

=head1 METHODS

=head2 new(\%params)

Constructor method which instantiates and returns a reference to a
C&lt;Template::Filters&gt; object.  A reference to a hash array of configuration
items may be passed as a parameter.  These are described below.

    my $filters = Template::Filters-&gt;new({
        FILTERS =&gt; { ... },
    });

    my $template = Template-&gt;new({
        LOAD_FILTERS =&gt; [ $filters ],
    });

A default C&lt;Template::Filters&gt; module is created by the L&lt;Template&gt; module
if the L&lt;LOAD_FILTERS&gt; option isn&#039;t specified.  All configuration parameters
are forwarded to the constructor.

    $template = Template-&gt;new({
        FILTERS =&gt; { ... },
    });

=head2 fetch($name, \@args, $context)

Called to request that a filter of a given name be provided.  The name
of the filter should be specified as the first parameter.  This should
be one of the standard filters or one specified in the L&lt;FILTERS&gt;
configuration hash.  The second argument should be a reference to an
array containing configuration parameters for the filter.  This may be
specified as 0, or undef where no parameters are provided.  The third
argument should be a reference to the current L&lt;Template::Context&gt;
object.

The method returns a reference to a filter sub-routine on success.  It
may also return C&lt;(undef, STATUS_DECLINE)&gt; to decline the request, to allow
delegation onto other filter providers in the L&lt;LOAD_FILTERS&gt; chain of
responsibility.  On error, C&lt;($error, STATUS_ERROR)&gt; is returned where $error
is an error message or L&lt;Template::Exception&gt; object indicating the error
that occurred.

When the C&lt;TOLERANT&gt; option is set, errors are automatically downgraded to
a C&lt;STATUS_DECLINE&gt; response.

=head2 use_html_entities()

This class method can be called to configure the C&lt;html_entity&gt; filter to use
the L&lt;HTML::Entities&gt; module. An error will be raised if it is not installed
on your system.

    use Template::Filters;
    Template::Filters-&gt;use_html_entities();

=head2 use_apache_util()

This class method can be called to configure the C&lt;html_entity&gt; filter to use
the L&lt;Apache::Util&gt; module. An error will be raised if it is not installed on
your system.

    use Template::Filters;
    Template::Filters-&gt;use_apache_util();

=head2 use_rfc2732()

This class method can be called to configure the C&lt;uri&gt; and C&lt;url&gt; filters to
use the older RFC2732 standard for matching unsafe characters.

=head2 use_rfc3986()

This class method can be called to configure the C&lt;uri&gt; and C&lt;url&gt; filters to
use the newer RFC3986 standard for matching unsafe characters.

=head1 CONFIGURATION OPTIONS

The following list summarises the configuration options that can be provided
to the C&lt;Template::Filters&gt; L&lt;new()&gt; constructor. Please see
L&lt;Template::Manual::Config&gt; for further information about each option.

=head2 FILTERS

The L&lt;FILTERS|Template::Manual::Config#FILTERS&gt; option can be used to specify
custom filters which can then be used with the
L&lt;FILTER|Template::Manual::Directives#FILTER&gt; directive like any other. These
are added to the standard filters which are available by default.

    $filters = Template::Filters-&gt;new({
        FILTERS =&gt; {
            &#039;sfilt1&#039; =&gt;   \&amp;static_filter,
            &#039;dfilt1&#039; =&gt; [ \&amp;dynamic_filter_factory, 1 ],
        },
    });

=head2 TOLERANT

The L&lt;TOLERANT|Template::Manual::Config#TOLERANT&gt; flag can be set to indicate
that the C&lt;Template::Filters&gt; module should ignore any errors and instead
return C&lt;STATUS_DECLINED&gt;.

=head2 DEBUG

The L&lt;DEBUG|Template::Manual::Config#DEBUG&gt; option can be used to enable
debugging messages for the Template::Filters module by setting it to include
the C&lt;DEBUG_FILTERS&gt; value.

    use Template::Constants qw( :debug );

    my $template = Template-&gt;new({
        DEBUG =&gt; DEBUG_FILTERS | DEBUG_PLUGINS,
    });

=head1 STANDARD FILTERS

Please see L&lt;Template::Manual::Filters&gt; for a list of the filters provided
with the Template Toolkit, complete with examples of use.

=head1 AUTHOR

Andy Wardley E&lt;lt&gt;abw@wardley.orgE&lt;gt&gt; L&lt;http://wardley.org/&gt;

=head1 COPYRIGHT

Copyright (C) 1996-20202Andy Wardley.  All Rights Reserved.

This module is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

=head1 SEE ALSO

L&lt;Template::Manual::Filters&gt;, L&lt;Template&gt;, L&lt;Template::Context&gt;

=cut

# Local Variables:
# mode: perl
# perl-indent-level: 4
# indent-tabs-mode: nil
# End:
#
# vim: expandtab shiftwidth=4:</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/local/lib64/perl5/Template/Filters.pm'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Fusr%2Flocal%2Flib64%2Fperl5%2FTemplate' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>