XML Serialization

/**
 * W3C XMLSerializer interface for converting DOM nodes to XML strings
 */
class XMLSerializer {
  constructor();
  
  /**
   * Serializes a DOM node and its descendants to an XML string
   * @param node The DOM node to serialize (Document, Element, or any Node)
   * @param isHtml Optional boolean for HTML serialization mode
   * @param nodeFilter Optional filter function to control serialization
   * @returns XML string representation of the node
   */
  serializeToString(node: Node, isHtml?: boolean, nodeFilter?: (node: Node) => boolean): string;
}

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

// Parse a document
const parser = new DOMParser();
const doc = parser.parseFromString(`
  <catalog xmlns="http://example.com/catalog">
    <product id="123">
      <name>Widget &amp; Tools</name>
      <price currency="USD">29.99</price>
      <description><![CDATA[Special characters: < > & " ']]></description>
    </product>
  </catalog>
`, 'text/xml');

// Create serializer and convert back to string
const serializer = new XMLSerializer();
const xmlString = serializer.serializeToString(doc);
console.log(xmlString);

// Serialize individual elements
const product = doc.getElementsByTagName('product').item(0);
const productXml = serializer.serializeToString(product);
console.log(productXml);

// Serialize text nodes
const nameElement = doc.getElementsByTagName('name').item(0);
const textNode = nameElement.firstChild;
const textContent = serializer.serializeToString(textNode);
console.log(textContent); // "Widget &amp; Tools"

/**
 * toString method available on all Node instances
 * @returns XML string representation of the node
 */
toString(): string;

const { DOMParser } = require('xmldom');
const parser = new DOMParser();
const doc = parser.parseFromString('<items><item>test</item></items>', 'text/xml');

// Direct toString() on document
console.log(doc.toString());

// toString() on elements
const item = doc.getElementsByTagName('item').item(0);
console.log(item.toString()); // "<item>test</item>"

// toString() on text nodes
const textNode = item.firstChild;
console.log(textNode.toString()); // "test"

// toString() on attributes
const attr = doc.createAttribute('id');
attr.value = '123';
item.setAttributeNode(attr);
console.log(attr.toString()); // 'id="123"'

// Namespace-aware serialization handles:
// - Namespace URI preservation
// - Prefix declarations
// - Default namespace handling
// - Namespace inheritance

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

// Document with multiple namespaces
const doc = parser.parseFromString(`
  <root xmlns="http://example.com/default" 
        xmlns:ns1="http://example.com/ns1"
        xmlns:ns2="http://example.com/ns2">
    <item>Default namespace item</item>
    <ns1:item>Namespace 1 item</ns1:item>
    <ns2:item xmlns:ns2="http://example.com/ns2-updated">Updated namespace</ns2:item>
  </root>
`, 'text/xml');

// Serialization preserves namespace information
const serialized = serializer.serializeToString(doc);
console.log(serialized);

// Create elements with namespaces programmatically
const newDoc = parser.parseFromString('<root></root>', 'text/xml');
const nsElement = newDoc.createElementNS('http://example.com/custom', 'custom:element');
nsElement.setAttributeNS('http://example.com/custom', 'custom:attr', 'value');
newDoc.documentElement.appendChild(nsElement);

console.log(newDoc.toString());
// Includes necessary namespace declarations

// Automatic entity encoding for:
// - < becomes &lt;
// - > becomes &gt; (in text content containing "]]>")
// - & becomes &amp;
// - " becomes &quot; (in attribute values)
// - ' becomes &apos; (in attribute values when needed)

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

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

// Create element with special characters
const element = doc.createElement('message');
element.setAttribute('type', 'text with "quotes" and <brackets>');
element.appendChild(doc.createTextNode('Content with < and > and & symbols'));

// Add CDATA section
const cdata = doc.createCDATASection('Raw content: <script>alert("test");</script>');
element.appendChild(cdata);

// Add text that needs entity encoding
const specialText = doc.createTextNode('Text ending with ]]> needs encoding');
element.appendChild(specialText);

doc.documentElement.appendChild(element);

// Serialization properly encodes entities
const result = serializer.serializeToString(doc);
console.log(result);
// Output will have proper entity encoding:
// - Attribute values with &quot; for quotes
// - Text content with &lt; and &gt; where needed
// - CDATA sections preserved as-is
// - "]]>" sequences properly encoded in text

// HTML serialization differences:
// - Uses HTML entity references where appropriate
// - Handles void elements correctly
// - Preserves HTML-specific formatting

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

// Parse HTML content
const htmlDoc = parser.parseFromString(`
  <html xmlns="http://www.w3.org/1999/xhtml">
    <head>
      <title>Test &nbsp; Page</title>
    </head>
    <body>
      <p>Paragraph with &copy; copyright symbol</p>
      <br/>
      <img src="test.jpg" alt="Test image"/>
    </body>
  </html>
`, 'text/html');

// Serialize HTML document
const htmlString = serializer.serializeToString(htmlDoc);
console.log(htmlString);
// Preserves HTML entities and structure

// Work with individual HTML elements
const title = htmlDoc.getElementsByTagName('title').item(0);
console.log(title.toString()); // Includes HTML entities

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

// Create document with processing instructions and comments
const doc = parser.parseFromString('<root></root>', 'text/xml');

// Add XML declaration equivalent (processing instruction)
const pi = doc.createProcessingInstruction('xml', 'version="1.0" encoding="UTF-8"');
doc.insertBefore(pi, doc.documentElement);

// Add comment
const comment = doc.createComment('Generated by xmldom');
doc.insertBefore(comment, doc.documentElement);

// Add content
const element = doc.createElement('data');
element.setAttribute('timestamp', new Date().toISOString());
element.appendChild(doc.createTextNode('Sample content'));
doc.documentElement.appendChild(element);

// Serialize complete document
const fullXml = serializer.serializeToString(doc);
console.log(fullXml);
// Includes processing instruction, comment, and content

// Serialize just the content (exclude processing instructions/comments)
const contentOnly = serializer.serializeToString(doc.documentElement);
console.log(contentOnly);

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

// For large documents, consider serializing sections
const largeDoc = parser.parseFromString('<data></data>', 'text/xml');

// Build large structure
for (let i = 0; i < 1000; i++) {
  const item = largeDoc.createElement('item');
  item.setAttribute('id', i.toString());
  item.appendChild(largeDoc.createTextNode(`Item ${i}`));
  largeDoc.documentElement.appendChild(item);
}

// Serialize entire document
const fullSerialization = serializer.serializeToString(largeDoc);

// Or serialize sections for streaming/chunked processing
const items = largeDoc.getElementsByTagName('item');
const serializedItems = [];
for (let i = 0; i < items.length; i++) {
  serializedItems.push(serializer.serializeToString(items.item(i)));
}

// Process sections as needed
serializedItems.forEach((itemXml, index) => {
  // Process individual item XML strings
  if (index % 100 === 0) {
    console.log(`Processed ${index} items`);
  }
});