Hash::MultiValue is an object (and a plain hash reference) that may contain
multiple values per key, inspired by MultiDict of WebOb.

The majority of the web pages of the internet today are much larger
than they need to be. The reason for this is that HTML tends to be
stored in a human readable format, with indenting, newlines and
comments.

However, all of these comments, whitespace etc. are ignored by the
browser, and needlessly lengthen download times.

Second, many people are using WYSIWYG HTML editors these days. This
makes creating content easy. However these editors can cause a number
of compatibility problems by tying themselves to a particular browser
or operating system.

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::Form' class represents a single HTML ' ...
' instance. A form consists of a sequence of inputs that usually
have names, and which can take on various values. The state of a form can
be tweaked and it can then be asked to provide 'HTTP::Request' objects that
can be passed to the request() method of 'LWP::UserAgent'.

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.

This module contains several data tables useful in various kinds of HTML
parsing operations.

Note that all tag names used are lowercase.

In the following documentation, a "hashset" is a hash being used as a set
-- the hash conveys that its keys are there, and the actual values
associated with the keys are not significant. (But what values are there,
are always true.)

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.

HTTP::Body parses chunks of HTTP POST data and supports application/octet-
stream, application/x-www-form-urlencoded, and multipart/form-data.

This class is for objects that represent a "cookie jar" -- that is, a
database of all the HTTP cookies that a given LWP::UserAgent object knows
about.

Cookies are a general mechanism which server side connections can use to
both store and retrieve information on the client side of the connection.
For more information about cookies refer to
and
. This module also implements the new
style cookies described in _RFC 2965_. The two variants of cookies are
supposed to be able to coexist happily.

Instances of the 'HTTP::Daemon' class are HTTP/1.1 servers that listen on a
socket for incoming requests. The 'HTTP::Daemon' is a subclass of
'IO::Socket::INET', so you can perform socket operations directly on it
too.

This module provides functions that deal the date formats used by the HTTP
protocol (and then some more). Only the first two functions, time2str() and
str2time(), are exported by default.

HTTP::DAV is a Perl API for interacting with and modifying content on
webservers using the WebDAV protocol. Now you can LOCK, DELETE and PUT
files and much more on a DAV-enabled webserver.

An 'HTTP::Message' object contains some headers and a content body. The
following methods are available:

* $mess = HTTP::Message->new

* $mess = HTTP::Message->new( $headers )

* $mess = HTTP::Message->new( $headers, $content )

This module provides a complete implementation of the HTTP content
negotiation algorithm specified in _draft-ietf-http-v11-spec-00.ps_ chapter
12. Content negotiation allows for the selection of a preferred content
representation based upon attributes of the negotiable variants and the
value of the various Accept* header fields in the request.

Provides a convenient way of setting up an CGI environment from an
HTTP::Request.

This module provide functions to extract various kind of meta information
from image files.

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::Interface adds methods to IO::Socket objects that allows them to be
used to retrieve and change information about the network interfaces on
your system. In addition to the object-oriented access methods, you can
use a function-oriented style.

"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.

This module is a true drop-in replacement for IO::Socket::INET that uses
SSL to encrypt data before it is transferred to a remote server or client.
IO::Socket::SSL supports all the extra features that one needs to write a
full-featured SSL client or server application: multiple SSL contexts,
cipher selection, certificate verification, and SSL version selection. As
an extra bonus, it works perfectly with mod_perl.

If you have never used SSL before, you should read the appendix labelled
'Using SSL' before attempting to use this module.

If you have used this module before, read on, as versions 0.93 and above
have several changes from the previous IO::Socket::SSL versions (especially
see the note about return values).

If you are using non-blocking sockets read on, as version 0.98 added better
support for non-blocking.

If you are trying to use it with threads see the BUGS section.