ltx: JavaScript XML Library

3.1.2 · active · verified Sun Apr 19

ltx is a JavaScript library designed for efficient XML building, parsing, serialization, and manipulation. Currently stable at version 3.1.2, it sees regular maintenance releases primarily focused on dependency updates and minor improvements, with a major version (v3.0.0) introducing significant breaking changes. A key differentiator of ltx is its performance-oriented design, offering its own fast default parser while also supporting integration with multiple third-party parsers like sax-js and saxes for more advanced XML features or specific use cases. It provides a succinct API for in-memory XML object manipulation, supports JSX compatibility via `ltx.createElement`, and offers tagged template literal support for convenient XML string creation. The library targets modern JavaScript environments and Node.js versions 12.4.0 and above. Its modular design allows users to swap out parser backends depending on performance requirements or specific XML feature needs, making it versatile for various XML processing tasks.

Common errors

```
TypeError: element.clone is not a function
```
cause Attempting to use the `clone` method on an `Element` instance after `ltx` v3.0.0, where this method was removed.

fix Manually create a new `Element` instance and copy properties/children, or refactor the logic to avoid direct cloning.
```
Error: require() of ES Module C:\path\to\node_modules\ltx\lib\index.js from C:\your\app.js not supported.
```
cause Attempting to `require('ltx')` in a CommonJS module when `ltx` is primarily designed for ESM or has specific dual-package configurations that lead to this conflict in some environments.

fix If working in an ESM context, use `import * as ltx from 'ltx';`. If strictly in CommonJS and encountering this, ensure your `node_modules` are correctly resolved, or consider if an older version of `ltx` is more compatible with your CJS-only setup, although v3.1.0 claims 'Fix dual ESM/CJS export'.
```
TypeError: element.toJSON is not a function
```
cause Calling the `toJSON` method on an `Element` instance after `ltx` v3.0.0, where it was renamed.

fix Replace `element.toJSON()` with `element.JSONify()`.

Warnings

breaking Version 3.0.0 raised the minimum supported Node.js version to 12.4.0. Using older Node.js versions will result in runtime errors due to modern JavaScript syntax.
Fix: Upgrade your Node.js environment to version 12.4.0 or newer.
breaking As of v3.0.0, `ltx` no longer exports a pre-bundled browser version. If you are targeting browser environments, you must use a module bundler like Webpack, Rollup, or Browserify to package `ltx` for client-side use.
Fix: Integrate `ltx` into your browser build pipeline using a compatible JavaScript bundler.
breaking Several methods on the `Element` class were removed in v3.0.0, including `clone`, `nameEquals`, `attrsEquals`, `childrenEquals`, and `equals`. Attempting to call these methods will result in a `TypeError`.
Fix: Refactor your code to implement the desired logic manually or use alternative methods available on `Element` for comparison and manipulation.
breaking The `toJSON` method on `Element` was removed in v3.0.0 and replaced with `JSONify`. Calls to `toJSON` will fail.
Fix: Update calls from `element.toJSON()` to `element.JSONify()`.
gotcha While `ltx` provides its own fast parser, it is a simpler parser. For advanced XML features (e.g., DTDs, namespaces, validation) or different performance characteristics, you may need to explicitly register and use a third-party parser backend (e.g., `saxes`, `node-expat`).
Fix: If advanced XML features are required, install a compatible third-party parser (e.g., `npm install saxes`) and register it with `ltx`'s parser system. Refer to the documentation for details on setting the active parser.

Install

npm install ltx npm
yarn add ltx yarn
pnpm add ltx pnpm

Imports

ltx
wrong:
```
import ltx from 'ltx';
// or
const ltx = require('ltx');
```
correct:
```
import * as ltx from 'ltx';
```
Since v3.0.0, the package primarily uses named exports and a module namespace object, making `import * as ltx` the recommended ESM approach. While CJS `require('ltx')` may work for some properties due to dual export, `import * as ltx` is explicit and robust.
Element
wrong:
```
const Element = require('ltx').Element;
```
correct:
```
import { Element } from 'ltx';
```
The `Element` class is a core component for XML node representation. Since v3.0.0, `Element` is exported as a named class.
Parser
wrong:
```
const Parser = require('ltx').Parser;
```
correct:
```
import { Parser } from 'ltx';
```
The base `Parser` class, or specific parser implementations, are named exports. Since v3.0.0, parser backends are exposed as classes.

Quickstart

This quickstart demonstrates how to programmatically build an XML element, serialize it to a string, and then parse an XML string to access its properties and children using the `ltx` library's `Element` and `Parser` classes.

import { Element, Parser } from 'ltx';

// 1. Build an XML element
const book = new Element('book', { id: 'bk101' })
  .c('author').t('Gambardella, Matthew').up()
  .c('title').t('XML Developer\'s Guide').up()
  .c('genre').t('Computer').up();

console.log('Built XML:\n', book.toString());

// 2. Parse an XML string
const xmlString = `<catalog>
  <book id="bk102">
    <author>Ralls, Kim</author>
    <title>Midnight Rain</title>
    <price>4.95</price>
  </book>
</catalog>`;

const parser = new Parser();
let parsedCatalog;

parser.on('tree', (tree) => {
  parsedCatalog = tree;
});

parser.parse(xmlString);

console.log('\nParsed XML Author:', parsedCatalog.getChild('book').getChild('author').getText());
console.log('Parsed XML Book ID:', parsedCatalog.getChild('book').attrs.id);

view raw JSON →