This module automatically inserts data from a previous HTML form into
the HTML input and select tags. It is a subclass of HTML::Parser and
uses it to parse the HTML and insert the values into the form tags.

Objects of the HTML::Parser class will recognize markup and separate it
from plain text (alias data content) in HTML documents. As different
kinds of markup and text are recognized, the corresponding event handlers
are invoked.

HTML::Parser is not a generic SGML parser. We have tried to make it able to
deal with the HTML that is actually "out there", and it normally parses as
closely as possible to the way the popular web browsers do it instead of
strictly following one of the many HTML specifications from W3C. Where
there is disagreement, there is often an option that you can enable to
get the official behaviour.

The document to be parsed may be supplied in arbitrary chunks. This makes
on-the-fly parsing as documents are received from the network possible.

If event driven parsing does not feel right for your application, you might
want to use HTML::PullParser. This is an HTML::Parser subclass that allows
a more conventional program structure.

This is the HTML::SimpleParse module. It is a bare-bones HTML parser,
similar to HTML::Parser, but with a couple important distinctions:

First, HTML::Parser knows which tags can contain other tags, which
start tags have corresponding end tags, which tags can exist only in
the portion of the document, and so forth. HTML::SimpleParse
does not know any of these things. It just finds tags and text in the
HTML you give it, it does not care about the specific content of these
tags (though it does distiguish between different _types_ of tags, such
as comments, starting tags like , ending tags like , and so on).

Second, HTML::SimpleParse does not create a hierarchical tree of HTML
content, but rather a simple linear list. It does not pay any
attention to balancing start tags with corresponding end tags, or which
pairs of tags are inside other pairs of tags.

Because of these characteristics, you can make a very effective HTML
filter by sub-classing HTML::SimpleParse.

Data tables useful for dealing with HTML.

This allows you to separate design - the HTML - from the data, which
you generate in the Perl script.

This module provides an extension to HTML::Template which allows
expressions in the template syntax.

Expression support includes comparisons, math operations, string
operations, and a mechanism to allow you to add your own functions at
runtime.

This is a just in time compiler for the HTML Template module. Makes the
use of templates very fast.

NOTE: Automatically created during Factory devel project migration by admin.

Inline lets you write Perl subroutines in other programming languages,
like C, C++, Java, Python, Tcl and even Assembly. You don't need to
compile anything. All the details are handled transparently, so you can
just run your Perl script like normal.

IO provides a simple mechanism to load several of the IO modules in one go. The IO modules belonging to the core are:
IO::Handle
IO::Seekable
IO::File
IO::Pipe
IO::Socket
IO::Dir
IO::Select
IO::Poll

"IO::Multiplex" reduces the effort of managing multiple file handles.
It is a fancy front end to the "select" system call.

IO::Socket::INET6 provides an object interface to creating and using sockets in either AF_INET or AF_INET6 domains. It is built upon the IO::Socket interface and inherits all the methods defined by IO::Socket.

IO::Socket::SSL is a class implementing an object oriented interface to
SSL sockets. The class is a descendant of IO::Socket::INET and provides
a subset of the base class' interface methods.

IO::String is an IO::File (and IO::Handle) compatible class that read
or write data from in-core strings.

I/O on in-core objects like strings and arrays

This module provides an IO:: style interface to the Compress::Zlib
package.

Included in perl

IPC::Run allows you run and interact with child processes using files,
pipes, and pseudo-ttys. Both system()-style and scripted usages are
supported and may be mixed. Like­wise, functional and OO API styles are
both supported and may be mixed.

Authors: Barrie Slaymaker

A Client interface for LDAP servers.

perl-libxml-perl is a collection of Perl modules for working with XML.

Mail::Mbox::MessageParser is a feature-poor but very fast mbox parser.
It uses the best of three strategies for parsing a mailbox: either
using cached folder information, GNU grep, or highly optimized Perl.

a set of perl modules related to mail applications

Math::Calc::Units is a simple calculator that keeps track of units. It
currently handles combinations of byte sizes and duration only, although adding
any other multiplicative types is easy. Any unknown type is treated as a unique
user type (with some effort to map English plurals to their singular forms).

The primary intended use is via the ucalc script that prints out all of the
"readable" variants of a value. For example, "3 bytes" will only produce "3
byte", but "3 byte / sec" produces the original along with "180 byte / minute",
"10.55 kilobyte / hour", etc.

MIME::Lite is intended as a simple, standalone module for generating
(not parsing!) MIME messages... specifically, it allows you to output a
simple, decent single- or multi-part message with text or binary
attachments. It does not require that you have the Mail:: or MIME::
modules installed.

modules for parsing (and creating!) MIME entities

MIME types are used in MIME entities, for instance as part of e-mail
and HTTP traffic. Sometimes real knowledge about a mime-type is need.
This module will supply it.