This package provides a general purpose Haskell XML library using Expat
to do its parsing (a fast stream-oriented XML parser written in C). It
is extensible to any string type, with String, ByteString and Text
provided out of the box.
Instead of reading input in lines as sed, bbe reads
arbitrary blocks from an input stream and performs
byte-related transformations on found blocks. Blocks
can be defined using start/stop strings, stream offset
and block length, or a combination. Basic editing commands
include delete, replace, search/replace, binary operations
(and, or, etc.), append, and bcd/ASCII conversion. For
examining the input stream, it contains some grep-like
features like printing the input file name, stream offset,
and block number of found blocks. Block contents can also
be printed in different formats like hex, octal, ASCII, and
binary.
The texmath library provides functions to read and write TeX math,
presentation MathML, and OMML (Office Math Markup Language, used in
Microsoft Office). Support is also included for converting math formats to
pandoc's native format (allowing conversion, via pandoc, to a variety of
different markup formats). The TeX reader supports basic LaTeX and AMS
extensions, and it can parse and apply LaTeX macros.
This package provides parsing and rendering functions for XML. It is
based on the datatypes found in the xml-types package. This package is
broken up into the following modules:
* Text.XML: DOM-based parsing and rendering. This is the most commonly
used module.
* Text.XML.Cursor: A wrapper around Text.XML which allows bidirectional
traversing of the DOM, similar to XPath.
* Text.XML.Unresolved: A slight modification to Text.XML which does not
require all entities to be resolved at parsing. The datatypes are
slightly more complicated here, and therefore this module is only
recommended when you need to deal directly with raw entities.
* Text.XML.Stream.Parse: Streaming parser, including some streaming
parser combinators.
* Text.XML.Stream.Render: Streaming renderer.
Provides support for parsing and emitting Yaml documents. This package
includes the full libyaml C library version 0.1.2 by Kirill Simonov in
the package so you don't need to worry about any non-Haskell
dependencies.
html2fo is a converter from html to xsl:fo. The html code could be written
with StarOffice or other WYSIWYM editors and must not be 100% valid html code.
html2fo is designed to produce a valid xsl:fo for using FOP from Apache.
libtranslate is a library for translating text and web pages between
natural languages. Its modular infrastructure allows to implement new
translation services separately from the core library.
libtranslate is shipped with a generic module supporting web-based
translation services such as Babel Fish, Google Language Tools and
SYSTRAN. Moreover, the generic module allows to add new services
simply by adding a few lines to a XML file (see the services.xml(5)
manual page).
The libtranslate distribution includes a powerful command line
interface (see the translate(1) manual page).
Liblinebreak is an implementation of the line and word breaking algorithm
as described in Unicode 5.1.0 Standard Annex 14, Revision 22. It breaks
lines that contain Unicode characters. It is designed to be used in a
generic text renderer. FBReader is one real-world example.
This is the Public software group utf8proc library repackaged as a
conveniance library for NetSurf.
This takes the unicode 5 capable version 1.1.6 of the library and
converts it to the NetSurf build system. additional API has been added
with a normalisation function but there are no data changes from
upstream.
LibYAML is a YAML 1.1 parser and emitter written in C.
LibYAML covers presenting and parsing processes. Thus LibYAML defines the
following two processors:
* Parser, which takes an input stream of bytes and produces a sequence
of parsing events.
* Emitter, which takes a sequence of events and produces a stream of
bytes.
The processes of parsing and presenting are inverse to each other. Any
sequence of events produced by parsing a well-formed YAML document should
be acceptable by the Emitter, which should produce an equivalent document.
Similarly, any document produced by emitting a sequence of events should
be acceptable for the Parser, which should produce an equivalent sequence
of events.
The job of resolving implicit tags, composing and serializing representation
trees, as well as constructing and representing native objects is left to
applications and bindings. Although some of these processes may be covered
in the latter releases, they are not in the scope of the initial release of
LibYAML.