Implementing JSON output option.

README.md

@@ -89,12 +89,57 @@ const xslt = new Xslt(options);
 - `cData` (`boolean`, default `true`): resolves CDATA elements in the output. Content under CDATA is resolved as text. This overrides `escape` for CDATA content.
 - `escape` (`boolean`, default `true`): replaces symbols like `<`, `>`, `&` and `"` by the corresponding [HTML/XML entities](https://www.tutorialspoint.com/xml/xml_character_entities.htm). Can be overridden by `disable-output-escaping`, that also does the opposite, unescaping `&gt;` and `&lt;` by `<` and `>`, respectively.
 - `selfClosingTags` (`boolean`, default `true`): Self-closes tags that don't have inner elements, if `true`. For instance, `<test></test>` becomes `<test />`.
-- `outputMethod` (`string`, default `xml`): Specifies the default output method. if `<xsl:output>` is declared in your XSLT file, this will be overridden. Valid values: `xml`, `html`, `text`, `name`, `xhtml`.
+- `outputMethod` (`string`, default `xml`): Specifies the default output method. if `<xsl:output>` is declared in your XSLT file, this will be overridden. Valid values: `xml`, `html`, `text`, `name`, `xhtml`, `json`.
 - `parameters` (`array`, default `[]`): external parameters that you want to use.
     - `name`: the parameter name;
     - `namespaceUri` (optional): the namespace;
     - `value`: the value.
 
+#### JSON Output Format
+
+When using `outputMethod: 'json'`, the XSLT processor will convert the resulting XML document to JSON format. This is useful for APIs and modern JavaScript applications.
+
+**Example:**
+
+```js
+const xslt = new Xslt({ outputMethod: 'json' });
+const xmlParser = new XmlParser();
+
+const xmlString = `<root>
+  <users>
+    <user>Alice</user>
+    <user>Bob</user>
+  </users>
+</root>`;
+
+const xsltString = `<?xml version="1.0"?>
+  <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+    <xsl:template match="/">
+      <xsl:copy-of select="root"/>
+    </xsl:template>
+  </xsl:stylesheet>`;
+
+const result = await xslt.xsltProcess(
+  xmlParser.xmlParse(xmlString),
+  xmlParser.xmlParse(xsltString)
+);
+
+// result will be a JSON string:
+// {"root":{"users":{"user":["Alice","Bob"]}}}
+
+const parsed = JSON.parse(result);
+console.log(parsed.root.users.user); // ["Alice", "Bob"]
+```
+
+**JSON Structure Rules:**
+
+- Each element becomes a property in a JSON object
+- Text-only elements become string values
+- Elements with multiple children of the same name become arrays
+- Empty elements are omitted from the output
+- Attributes are prefixed with `@` (when present in the output)
+- Mixed text and element content uses the `#text` property for text nodes
+
 ### Direct use in browsers
 
 You can simply add a tag like this:

src/dom/xml-functions.ts

@@ -449,3 +449,178 @@
 
     return xmlOwnerDocument(node.ownerDocument);
 }
+
+/**
+ * Converts an XNode to a JSON-serializable object.
+ * Uses JSON.parse(JSON.stringify()) approach to filter out unwanted properties.
+ * @param node The node to convert.
+ * @returns A JSON-serializable object representation of the node.
+ */
+function nodeToJsonObject(node: XNode): any {
+    if (!node) {
+        return null;
+    }
+
+    const nodeType = node.nodeType;
+
+    // Handle text nodes
+    if (nodeType === DOM_TEXT_NODE || nodeType === DOM_CDATA_SECTION_NODE) {
+        const text = node.nodeValue ? node.nodeValue.trim() : '';
+        return text.length > 0 ? text : null;
+    }
+
+    // Handle comment nodes
+    if (nodeType === DOM_COMMENT_NODE) {
+        return null; // Skip comments in JSON output
+    }
+
+    // Handle document and document fragments
+    if (nodeType === DOM_DOCUMENT_NODE || nodeType === DOM_DOCUMENT_FRAGMENT_NODE) {
+        const children = node.childNodes || [];
+        const childObjects = [];
+
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            const childObj = nodeToJsonObject(child);
+            if (childObj !== null) {
+                childObjects.push(childObj);
+            }
+        }
+
+        if (childObjects.length === 0) {
+            return null;
+        } else if (childObjects.length === 1) {
+            return childObjects[0];
+        } else {
+            return childObjects;
+        }
+    }
+
+    // Handle element nodes
+    if (nodeType === DOM_ELEMENT_NODE) {
+        const obj: any = {};
+        const element = node as any;
+        const hasAttributes = element.attributes && element.attributes.length > 0;
+
+        // Add attributes with @ prefix
+        if (hasAttributes) {
+            for (let i = 0; i < element.attributes.length; i++) {
+                const attr = element.attributes[i];
+                obj['@' + attr.nodeName] = attr.nodeValue;
+            }
+        }
+
+        // Process child nodes
+        const children = element.childNodes || [];
+        let textContent = '';
+        let hasElementChildren = false;
+        const childElements: { [key: string]: any } = {};
+
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            const childType = child.nodeType;
+
+            if (childType === DOM_TEXT_NODE || childType === DOM_CDATA_SECTION_NODE) {
+                const text = child.nodeValue ? child.nodeValue.trim() : '';
+                if (text.length > 0) {
+                    textContent += text;
+                }
+            } else if (childType === DOM_ELEMENT_NODE) {
+                hasElementChildren = true;
+                const childElement = child as any;
+                const childName = childElement.localName || childElement.nodeName;
+                const childObj = nodeToJsonObject(child);
+
+                if (childObj !== null) {
+                    if (childElements[childName]) {
+                        // Multiple elements with same name - convert to array
+                        if (!Array.isArray(childElements[childName])) {
+                            childElements[childName] = [childElements[childName]];
+                        }
+                        childElements[childName].push(childObj);
+                    } else {
+                        childElements[childName] = childObj;
+                    }
+                }
+            }
+        }
+
+        // Add child elements to object
+        Object.assign(obj, childElements);
+
+        // Add text content if no element children and has text
+        if (!hasElementChildren && textContent.length > 0) {
+            if (!hasAttributes && Object.keys(childElements).length === 0) {
+                // Only text, no attributes or element children
+                return textContent;
+            } else {
+                // Has attributes and/or element children plus text
+                obj['#text'] = textContent;
+            }
+        }
+
+        // If completely empty (no attributes, no children, no text), return null
+        if (Object.keys(obj).length === 0) {
+            return null;
+        }
+
+        return obj;
+    }
+
+    return null;
+}
+
+/**
+ * Converts an XML document to a JSON string.
+ * The root element becomes the top-level object.
+ * Element attributes are prefixed with '@'.
+ * Text nodes become the '#text' property or the value itself.
+ * @param node The root node to convert.
+ * @returns A JSON string representation of the document.
+ */
+export function xmlToJson(node: XNode): string {
+    if (!node) {
+        return '{}';
+    }
+
+    // For document nodes, find the root element and wrap it
+    let rootElement: XNode = node;
+    if (node.nodeType === DOM_DOCUMENT_NODE || node.nodeType === DOM_DOCUMENT_FRAGMENT_NODE) {
+        const children = node.childNodes || [];
+        for (let i = 0; i < children.length; i++) {
+            if (children[i].nodeType === DOM_ELEMENT_NODE) {
+                rootElement = children[i];
+                break;
+            }
+        }
+    }
+
+    // Convert the root element to JSON
+    const element = rootElement as any;
+    const rootName = element.localName || element.nodeName;
+    const jsonObj: any = {};
+
+    // Build the root element object
+    const elementContent = nodeToJsonObject(rootElement);
+
+    if (elementContent === null) {
+        // Empty root element
+        jsonObj[rootName] = {};
+    } else if (typeof elementContent === 'object' && !Array.isArray(elementContent)) {
+        // Object with properties/attributes
+        jsonObj[rootName] = elementContent;
+    } else {
+        // Simple text content
+        jsonObj[rootName] = elementContent;
+    }
+
+    // Use JSON.stringify to clean up the object and then JSON.parse and stringify again
+    // This ensures we only have plain properties without circular references
+    try {
+        const cleaned = JSON.parse(JSON.stringify(jsonObj));
+        return JSON.stringify(cleaned);
+    } catch (error) {
+        // Fallback if stringification fails
+        return JSON.stringify(jsonObj);
+    }
+}

src/xslt/xslt-options.ts

@@ -4,5 +4,6 @@ export type XsltOptions = {
     cData: boolean,
     escape: boolean,
     selfClosingTags: boolean,
+    outputMethod?: 'xml' | 'html' | 'text' | 'xhtml' | 'json',
     parameters?: XsltParameter[]
 }

src/xslt/xslt.ts

@@ -19,6 +19,7 @@ import {
     domSetAttribute,
     xmlGetAttribute,
     xmlTransformedText,
+    xmlToJson,
     xmlValue,
     xmlValueLegacyBehavior
 } from '../dom';
@@ -76,7 +77,7 @@ export class Xslt {
     decimalFormatSettings: XsltDecimalFormatSettings;
 
     outputDocument: XDocument;
-    outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml';
+    outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml' | 'json';
     outputOmitXmlDeclaration: string;
     version: string;
     firstTemplateRan: boolean;
@@ -115,9 +116,10 @@ export class Xslt {
             cData: options.cData === true,
             escape: options.escape === true,
             selfClosingTags: options.selfClosingTags === true,
+            outputMethod: options.outputMethod,
             parameters: options.parameters || []
         };
-        this.outputMethod = 'xml';
+        this.outputMethod = options.outputMethod || 'xml';
         this.outputOmitXmlDeclaration = 'no';
         this.stripSpacePatterns = [];
         this.preserveSpacePatterns = [];
@@ -141,7 +143,7 @@ export class Xslt {
      * The exported entry point of the XSL-T processor.
      * @param xmlDoc The input document root, as DOM node.
      * @param stylesheet The stylesheet document root, as DOM node.
-     * @returns the processed document, as XML text in a string.
+     * @returns the processed document, as XML text in a string, or JSON string if outputMethod is 'json'.
      */
     async xsltProcess(xmlDoc: XDocument, stylesheet: XDocument) {
         const outputDocument = new XDocument();
@@ -155,6 +157,12 @@ export class Xslt {
         }
 
         await this.xsltProcessContext(expressionContext, stylesheet, this.outputDocument);
+
+        // Handle JSON output format
+        if (this.outputMethod === 'json') {
+            return xmlToJson(outputDocument);
+        }
+
         const transformedOutputXml: string = xmlTransformedText(outputDocument, {
             cData: this.options.cData,
             escape: this.options.escape,