tessl/npm-xmldom

A pure JavaScript W3C standard-based (XML DOM Level 2 Core) DOMParser and XMLSerializer module.

Overview

Eval results

Files

XML Parsing

Name: tessl/npm-xmldom
Author: tessl

Core XML parsing functionality providing robust conversion of XML and HTML strings into DOM documents with configurable error handling and namespace support.

Capabilities

DOMParser Constructor

Creates a new DOMParser instance with optional configuration for error handling, namespace processing, and parsing behavior.

/**
 * Creates a new DOMParser instance
 * @param options Configuration options for parsing behavior
 */
function DOMParser(options?: {
  locator?: object;
  errorHandler?: {
    warning?: (msg: string) => void;
    error?: (msg: string) => void;
    fatalError?: (msg: string) => void;
  } | ((level: string, msg: string) => void);
  xmlns?: object;
  domBuilder?: object;
}): DOMParser;

Usage Examples:

const { DOMParser } = require('xmldom');

// Basic parser with default settings
const parser = new DOMParser();

// Parser with custom error handling
const parserWithErrors = new DOMParser({
  errorHandler: {
    warning: function(w) { console.warn(w); },
    error: function(e) { console.error(e); },
    fatalError: function(e) { throw new Error(e); }
  }
});

// Parser with function-style error handler
const parserWithCallback = new DOMParser({
  errorHandler: function(level, msg) {
    console.log(`${level}: ${msg}`);
  }
});

// Parser with position tracking
const parserWithLocator = new DOMParser({
  locator: {},
  errorHandler: function(level, msg) {
    console.log(`${level}: ${msg}`);
  }
});

parseFromString Method

Parses XML or HTML string content into a DOM Document with support for different MIME types and parsing modes.

/**
 * Parses XML/HTML string into DOM Document
 * @param source The XML or HTML string to parse
 * @param mimeType MIME type determining parsing mode ('text/xml', 'application/xml', 'text/html', etc.)
 * @returns Parsed DOM Document object
 */
parseFromString(source: string, mimeType: string): Document;

Usage Examples:

const { DOMParser } = require('xmldom');
const parser = new DOMParser();

// Parse XML document
const xmlDoc = parser.parseFromString(`
  <?xml version="1.0" encoding="UTF-8"?>
  <catalog xmlns="http://example.com/catalog">
    <product id="123" name="Widget">
      <price currency="USD">29.99</price>
      <description>A useful widget</description>
    </product>
  </catalog>
`, 'text/xml');

// Parse HTML document
const htmlDoc = parser.parseFromString(`
  <html>
    <head><title>Test Page</title></head>
    <body>
      <h1>Hello World</h1>
      <p>This is a test.</p>
    </body>
  </html>
`, 'text/html');

// Parse XML fragment
const fragment = parser.parseFromString('<item>value</item>', 'text/xml');

// Access parsed content
console.log(xmlDoc.documentElement.tagName); // "catalog"
console.log(xmlDoc.documentElement.namespaceURI); // "http://example.com/catalog"
const product = xmlDoc.getElementsByTagName('product').item(0);
console.log(product.getAttribute('name')); // "Widget"

MIME Type Support

Different MIME types control parsing behavior and enable appropriate handling of XML versus HTML content.

// Supported MIME types for XML parsing
type XMLMimeType = 
  | 'text/xml'
  | 'application/xml'
  | 'application/xhtml+xml'
  | string; // Other +xml suffixes

// Supported MIME types for HTML parsing  
type HTMLMimeType =
  | 'text/html'
  | string; // Other html-based types

Usage Examples:

const parser = new DOMParser();

// XML parsing (strict mode)
const xmlDoc = parser.parseFromString('<root><item/></root>', 'text/xml');
const appXmlDoc = parser.parseFromString('<data><entry/></data>', 'application/xml');

// HTML parsing (lenient mode, uses HTML entity map)
const htmlDoc = parser.parseFromString('<div>Test &nbsp; content</div>', 'text/html');

// XHTML parsing (XML rules with HTML entities)
const xhtmlDoc = parser.parseFromString(`
  <html xmlns="http://www.w3.org/1999/xhtml">
    <body><p>Content</p></body>
  </html>
`, 'application/xhtml+xml');

Error Handling Configuration

Configure how parsing errors, warnings, and fatal errors are handled during document processing.

interface ErrorHandler {
  warning?: (msg: string) => void;
  error?: (msg: string) => void;
  fatalError?: (msg: string) => void;
}

type ErrorHandlerFunction = (level: 'warning' | 'error' | 'fatalError', msg: string) => void;

Usage Examples:

const { DOMParser } = require('xmldom');

// Object-style error handler
const parser1 = new DOMParser({
  errorHandler: {
    warning: function(msg) {
      console.warn(`XML Warning: ${msg}`);
    },
    error: function(msg) {
      console.error(`XML Error: ${msg}`);
    },
    fatalError: function(msg) {
      throw new Error(`XML Fatal Error: ${msg}`);
    }
  }
});

// Function-style error handler
const parser2 = new DOMParser({
  errorHandler: function(level, msg) {
    switch(level) {
      case 'warning':
        console.warn(msg);
        break;
      case 'error':
        console.error(msg);
        break;
      case 'fatalError':
        throw new Error(msg);
    }
  }
});

// Collect errors for later processing
const errors = [];
const parser3 = new DOMParser({
  errorHandler: function(level, msg) {
    errors.push({ level, msg });
  }
});

const doc = parser3.parseFromString('<invalid><unclosed>', 'text/xml');
console.log(errors); // Array of parsing issues

Namespace Processing

Configure default namespace mappings and namespace processing behavior during parsing.

interface ParserOptions {
  xmlns?: { [prefix: string]: string };
  locator?: object;
}

Usage Examples:

const parser = new DOMParser({
  xmlns: {
    '': 'http://example.com/default',
    'ns': 'http://example.com/namespace',
    'xml': 'http://www.w3.org/XML/1998/namespace'
  }
});

const doc = parser.parseFromString(`
  <root>
    <ns:item>Namespaced content</ns:item>
    <item>Default namespace content</item>
  </root>
`, 'text/xml');

console.log(doc.documentElement.namespaceURI); // "http://example.com/default"
const nsItem = doc.getElementsByTagNameNS('http://example.com/namespace', 'item').item(0);
console.log(nsItem.textContent); // "Namespaced content"

Position Tracking

Enable source position tracking to get line and column numbers for parsed nodes.

interface LocatorOptions {
  locator?: object;
}

interface NodeWithPosition extends Node {
  lineNumber?: number;
  columnNumber?: number;
}

Usage Examples:

const parser = new DOMParser({
  locator: {},
  errorHandler: function(level, msg) {
    console.log(`${level}: ${msg}`);
  }
});

const doc = parser.parseFromString(`
  <root>
    <item>First</item>
    <item>Second</item>
  </root>
`, 'text/xml');

// Access position information (xmldom extension)
const items = doc.getElementsByTagName('item');
for (let i = 0; i < items.length; i++) {
  const item = items.item(i);
  console.log(`Item ${i}: line ${item.lineNumber}, column ${item.columnNumber}`);
}

Install with Tessl CLI