@tradik/xslt-processor 1.0.2 → 1.1.1

package/src/xslt/serializer/baseWriter.js

@@ -0,0 +1,283 @@
+/**
+ * Result Tree Writer
+ *
+ * Walks a result tree and turns it into markup. Everything that differs
+ * between the xml, xhtml and html output methods of XSLT 1.0 section 16 is
+ * delegated to the dialect hooks implemented by the concrete writers.
+ */
+
+import {
+  INDENT_UNIT,
+  NODE_TYPE,
+  TEXT_MODE,
+  XMLNS_NAMESPACE,
+} from "./constants.js";
+import { wrapCdata } from "./escape.js";
+import {
+  collectNamespaceDeclarations,
+  createNamespaceScope,
+} from "./namespaces.js";
+import { getIndentableChildren } from "./indent.js";
+import { isRawText } from "./rawText.js";
+import { findRootElement } from "./settings.js";
+
+export class BaseWriter {
+  /**
+   * @param {object} settings - Normalized output settings
+   * @param {{xhtml?: boolean}} [options] - Dialect options
+   */
+  constructor(settings, options = {}) {
+    this.settings = settings;
+    this.xhtml = options.xhtml === true;
+    this.parts = [];
+  }
+
+  /**
+   * Serialize a result tree node.
+   *
+   * @param {Node} node - Document, fragment or element to serialize
+   * @returns {string} Serialized output
+   */
+  serialize(node) {
+    this.parts = [];
+    this.writeProlog(node);
+    this.writeNode(node, createNamespaceScope(), 0, TEXT_MODE.ESCAPE);
+    return this.parts.join("");
+  }
+
+  /**
+   * Write the XML declaration and the document type declaration.
+   *
+   * @param {Node} node - Result tree root
+   * @returns {void}
+   */
+  writeProlog(node) {
+    if (this.emitsXmlDeclaration) {
+      const { version, encoding, standalone } = this.settings;
+      const standalonePart = standalone ? ` standalone="${standalone}"` : "";
+      this.parts.push(
+        `<?xml version="${version}" encoding="${encoding}"${standalonePart}?>\n`,
+      );
+    }
+
+    const doctype = this.doctypeMarkup(findRootElement(node));
+    if (doctype) {
+      this.parts.push(`${doctype}\n`);
+    }
+  }
+
+  /**
+   * Write any result tree node.
+   *
+   * @param {Node} node - Node to write
+   * @param {Map<string, string>} scope - Namespace scope in effect
+   * @param {number} depth - Current indentation depth
+   * @param {string} textMode - {@link TEXT_MODE} for character data children
+   * @returns {void}
+   */
+  writeNode(node, scope, depth, textMode) {
+    switch (node.nodeType) {
+      case NODE_TYPE.ELEMENT:
+        this.writeElement(node, scope, depth);
+        break;
+      case NODE_TYPE.TEXT:
+      case NODE_TYPE.CDATA_SECTION:
+        this.writeText(node, textMode);
+        break;
+      case NODE_TYPE.COMMENT:
+        this.parts.push(`<!--${node.nodeValue}-->`);
+        break;
+      case NODE_TYPE.PROCESSING_INSTRUCTION:
+        this.writeProcessingInstruction(node);
+        break;
+      case NODE_TYPE.DOCUMENT:
+      case NODE_TYPE.DOCUMENT_FRAGMENT:
+        this.writeChildNodes(node, scope, depth, textMode);
+        break;
+      default:
+        break;
+    }
+  }
+
+  /**
+   * Write every child of a node without adding whitespace.
+   *
+   * @param {Node} node - Parent node
+   * @param {Map<string, string>} scope - Namespace scope in effect
+   * @param {number} depth - Current indentation depth
+   * @param {string} textMode - {@link TEXT_MODE} for character data children
+   * @returns {void}
+   */
+  writeChildNodes(node, scope, depth, textMode) {
+    for (const child of node.childNodes) {
+      this.writeNode(child, scope, depth, textMode);
+    }
+  }
+
+  /**
+   * Write an element with its namespaces, attributes and children.
+   *
+   * @param {Element} element - Element to write
+   * @param {Map<string, string>} scope - Namespace scope inherited from the parent
+   * @param {number} depth - Current indentation depth
+   * @returns {void}
+   */
+  writeElement(element, scope, depth) {
+    const namespaces = this.emitsNamespaces
+      ? collectNamespaceDeclarations(element, scope)
+      : { declarations: [], scope };
+    const name = element.nodeName;
+
+    this.parts.push(
+      `<${name}${this.namespaceMarkup(namespaces.declarations)}` +
+        this.attributesMarkup(element),
+    );
+
+    if (!element.firstChild) {
+      this.parts.push(this.emptyElementMarkup(element, name));
+      return;
+    }
+
+    this.parts.push(">");
+    this.writeElementChildren(element, namespaces.scope, depth);
+    this.parts.push(`</${name}>`);
+  }
+
+  /**
+   * Write the children of an element, indenting element-only content.
+   *
+   * @param {Element} element - Parent element
+   * @param {Map<string, string>} scope - Namespace scope in effect
+   * @param {number} depth - Depth of the parent element
+   * @returns {void}
+   */
+  writeElementChildren(element, scope, depth) {
+    const textMode = this.childTextMode(element);
+    const indentable = this.indentableChildren(element, textMode);
+
+    if (!indentable) {
+      this.writeChildNodes(element, scope, depth, textMode);
+      return;
+    }
+
+    const childIndent = `\n${INDENT_UNIT.repeat(depth + 1)}`;
+    for (const child of indentable) {
+      this.parts.push(childIndent);
+      this.writeNode(child, scope, depth + 1, textMode);
+    }
+    this.parts.push(`\n${INDENT_UNIT.repeat(depth)}`);
+  }
+
+  /**
+   * Determine the children to indent inside an element.
+   *
+   * @param {Element} element - Parent element
+   * @param {string} textMode - {@link TEXT_MODE} for character data children
+   * @returns {Node[]|null} Children to indent, or null when indenting is off
+   */
+  indentableChildren(element, textMode) {
+    if (!this.settings.indent || textMode !== TEXT_MODE.ESCAPE) {
+      return null;
+    }
+    if (!this.allowsIndentInside(element)) {
+      return null;
+    }
+    return getIndentableChildren(element);
+  }
+
+  /**
+   * Build the namespace declaration markup of an element.
+   *
+   * @param {Array<{prefix: string, uri: string}>} declarations - Declarations
+   * @returns {string} Attribute markup, starting with a space when non-empty
+   */
+  namespaceMarkup(declarations) {
+    return declarations
+      .map(({ prefix, uri }) => {
+        const name = prefix ? `xmlns:${prefix}` : "xmlns";
+        return ` ${name}="${this.escapeAttribute(uri)}"`;
+      })
+      .join("");
+  }
+
+  /**
+   * Build the attribute markup of an element, skipping namespace declarations.
+   *
+   * @param {Element} element - Element being written
+   * @returns {string} Attribute markup, starting with a space when non-empty
+   */
+  attributesMarkup(element) {
+    let markup = "";
+    for (const attribute of Array.from(element.attributes || [])) {
+      if (attribute.namespaceURI !== XMLNS_NAMESPACE) {
+        markup += this.attributeMarkup(attribute);
+      }
+    }
+    return markup;
+  }
+
+  /**
+   * Build the markup of a single attribute.
+   *
+   * @param {Attr} attribute - Attribute to write
+   * @returns {string} Attribute markup, starting with a space
+   */
+  attributeMarkup(attribute) {
+    return ` ${attribute.name}="${this.escapeAttribute(attribute.value)}"`;
+  }
+
+  /**
+   * Write a character data node.
+   *
+   * Nodes produced with `disable-output-escaping="yes"` are written verbatim.
+   *
+   * @param {Node} node - Text or CDATA section node
+   * @param {string} textMode - {@link TEXT_MODE} requested by the parent
+   * @returns {void}
+   */
+  writeText(node, textMode) {
+    const value = node.nodeValue || "";
+
+    if (isRawText(node)) {
+      this.parts.push(value);
+      return;
+    }
+
+    const mode = this.resolveTextMode(node, textMode);
+    if (mode === TEXT_MODE.CDATA) {
+      this.parts.push(wrapCdata(value));
+    } else if (mode === TEXT_MODE.RAW) {
+      this.parts.push(value);
+    } else {
+      this.parts.push(this.escapeText(value));
+    }
+  }
+
+  /**
+   * Resolve the effective text mode of a character data node.
+   *
+   * @param {Node} node - Text or CDATA section node
+   * @param {string} textMode - {@link TEXT_MODE} requested by the parent
+   * @returns {string} A {@link TEXT_MODE} value
+   */
+  resolveTextMode(node, textMode) {
+    if (textMode !== TEXT_MODE.ESCAPE) {
+      return textMode;
+    }
+    return node.nodeType === NODE_TYPE.CDATA_SECTION
+      ? this.cdataNodeMode
+      : TEXT_MODE.ESCAPE;
+  }
+
+  /**
+   * Write a processing instruction node.
+   *
+   * @param {ProcessingInstruction} node - Node to write
+   * @returns {void}
+   */
+  writeProcessingInstruction(node) {
+    const data = node.nodeValue || "";
+    const separator = data ? " " : "";
+    this.parts.push(`<?${node.target}${separator}${data}${this.piTerminator}`);
+  }
+}

package/src/xslt/serializer/constants.js

@@ -0,0 +1,78 @@
+/**
+ * Serializer Constants
+ *
+ * Shared node type codes, namespace URIs and HTML element tables used by the
+ * XSLT 1.0 output serializers (XSLT 1.0 section 16).
+ */
+
+/**
+ * DOM node type codes used by the serializers.
+ */
+export const NODE_TYPE = {
+  ELEMENT: 1,
+  TEXT: 3,
+  CDATA_SECTION: 4,
+  PROCESSING_INSTRUCTION: 7,
+  COMMENT: 8,
+  DOCUMENT: 9,
+  DOCUMENT_FRAGMENT: 11,
+};
+
+/**
+ * Namespace URI reserved for namespace declaration attributes.
+ */
+export const XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
+
+/**
+ * Namespace URI bound to the reserved `xml` prefix.
+ */
+export const XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+
+/**
+ * How the text children of an element have to be written out.
+ */
+export const TEXT_MODE = {
+  ESCAPE: "escape",
+  CDATA: "cdata",
+  RAW: "raw",
+};
+
+/**
+ * HTML elements that never have an end tag.
+ */
+export const VOID_ELEMENTS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr",
+]);
+
+/**
+ * HTML elements whose character data must not be escaped.
+ */
+export const RAW_TEXT_ELEMENTS = new Set(["script", "style"]);
+
+/**
+ * HTML elements whose content must never be re-indented.
+ */
+export const PRESERVE_SPACE_ELEMENTS = new Set([
+  "pre",
+  "script",
+  "style",
+  "textarea",
+]);
+
+/**
+ * Indentation unit used when `indent="yes"` is requested.
+ */
+export const INDENT_UNIT = "  ";

package/src/xslt/serializer/escape.js

@@ -0,0 +1,98 @@
+/**
+ * Output Escaping Helpers
+ *
+ * Character escaping rules for the xml, xhtml and html output methods
+ * (XSLT 1.0 section 16).
+ */
+
+const XML_TEXT_ESCAPES = { "&": "&amp;", "<": "&lt;" };
+
+const HTML_TEXT_ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;" };
+
+const XML_ATTRIBUTE_ESCAPES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "\t": "&#9;",
+  "\n": "&#10;",
+  "\r": "&#13;",
+};
+
+const HTML_ATTRIBUTE_ESCAPES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+};
+
+/**
+ * Replace every character matched by a pattern using a lookup table.
+ *
+ * @param {string} value - Text to escape
+ * @param {RegExp} pattern - Global pattern selecting the characters to replace
+ * @param {Record<string, string>} escapes - Character to replacement mapping
+ * @returns {string} Escaped text
+ */
+function escapeWith(value, pattern, escapes) {
+  return String(value).replaceAll(pattern, (character) => escapes[character]);
+}
+
+/**
+ * Escape character data for the xml output method.
+ *
+ * `>` is only escaped where it would close a CDATA section, matching the
+ * "minimal escaping" rule of XSLT 1.0 section 16.1.
+ *
+ * @param {string} value - Text content
+ * @returns {string} Escaped text
+ */
+export function escapeXmlText(value) {
+  return escapeWith(value, /[&<]/g, XML_TEXT_ESCAPES).replaceAll(
+    "]]>",
+    "]]&gt;",
+  );
+}
+
+/**
+ * Escape an attribute value for the xml output method.
+ *
+ * @param {string} value - Attribute value
+ * @returns {string} Escaped value
+ */
+export function escapeXmlAttribute(value) {
+  return escapeWith(value, /[&<>"\t\n\r]/g, XML_ATTRIBUTE_ESCAPES);
+}
+
+/**
+ * Escape character data for the html output method.
+ *
+ * @param {string} value - Text content
+ * @returns {string} Escaped text
+ */
+export function escapeHtmlText(value) {
+  return escapeWith(value, /[&<>]/g, HTML_TEXT_ESCAPES);
+}
+
+/**
+ * Escape an attribute value for the html output method.
+ *
+ * URI attributes keep their reserved characters; only markup significant
+ * characters are escaped (XSLT 1.0 section 16.2).
+ *
+ * @param {string} value - Attribute value
+ * @returns {string} Escaped value
+ */
+export function escapeHtmlAttribute(value) {
+  return escapeWith(value, /[&<>"]/g, HTML_ATTRIBUTE_ESCAPES);
+}
+
+/**
+ * Wrap text in a CDATA section, splitting it around any `]]>` terminator.
+ *
+ * @param {string} value - Text content
+ * @returns {string} One or more CDATA sections
+ */
+export function wrapCdata(value) {
+  return `<![CDATA[${String(value).replaceAll("]]>", "]]]]><![CDATA[>")}]]>`;
+}

package/src/xslt/serializer/htmlSerializer.js

@@ -0,0 +1,141 @@
+/**
+ * HTML Output Serializer
+ *
+ * Implements the `html` output method of XSLT 1.0 section 16.2 on top of the
+ * XML writer: no XML declaration, no namespace declarations, void elements
+ * without a closing slash, minimized boolean attributes and unescaped
+ * script/style content.
+ */
+
+import {
+  PRESERVE_SPACE_ELEMENTS,
+  RAW_TEXT_ELEMENTS,
+  TEXT_MODE,
+} from "./constants.js";
+import { escapeHtmlAttribute, escapeHtmlText } from "./escape.js";
+import { XmlWriter } from "./xmlSerializer.js";
+
+export class HtmlWriter extends XmlWriter {
+  /**
+   * The html output method never writes an XML declaration.
+   * @returns {boolean} Always false
+   */
+  get emitsXmlDeclaration() {
+    return false;
+  }
+
+  /**
+   * The html output method never writes namespace declarations.
+   * @returns {boolean} Always false
+   */
+  get emitsNamespaces() {
+    return false;
+  }
+
+  /**
+   * HTML processing instructions are terminated by `>` alone.
+   * @returns {string} The HTML processing instruction terminator
+   */
+  get piTerminator() {
+    return ">";
+  }
+
+  /**
+   * HTML has no CDATA sections, so such nodes are escaped as text.
+   * @returns {string} A {@link TEXT_MODE} value
+   */
+  get cdataNodeMode() {
+    return TEXT_MODE.ESCAPE;
+  }
+
+  /**
+   * Build the document type declaration for the html output method.
+   *
+   * @param {Element|null} rootElement - Result document element
+   * @returns {string} Doctype markup, or an empty string when not applicable
+   */
+  doctypeMarkup(rootElement) {
+    const { doctypePublic, doctypeSystem } = this.settings;
+    if (!doctypePublic && !doctypeSystem) {
+      return "";
+    }
+
+    const name = rootElement ? rootElement.nodeName : "html";
+    if (doctypePublic && doctypeSystem) {
+      return `<!DOCTYPE ${name} PUBLIC "${doctypePublic}" "${doctypeSystem}">`;
+    }
+    if (doctypePublic) {
+      return `<!DOCTYPE ${name} PUBLIC "${doctypePublic}">`;
+    }
+    return `<!DOCTYPE ${name} SYSTEM "${doctypeSystem}">`;
+  }
+
+  /**
+   * Script and style content is written verbatim.
+   *
+   * @param {Element} element - Parent element
+   * @returns {string} A {@link TEXT_MODE} value
+   */
+  childTextMode(element) {
+    return RAW_TEXT_ELEMENTS.has(String(element.localName).toLowerCase())
+      ? TEXT_MODE.RAW
+      : TEXT_MODE.ESCAPE;
+  }
+
+  /**
+   * Content of `pre`, `script`, `style` and `textarea` is never re-indented.
+   *
+   * @param {Element} element - Element being inspected
+   * @returns {boolean} True when the content may be indented
+   */
+  allowsIndentInside(element) {
+    return !PRESERVE_SPACE_ELEMENTS.has(
+      String(element.localName).toLowerCase(),
+    );
+  }
+
+  /**
+   * Void elements have no end tag; every other element gets one.
+   *
+   * @param {Element} element - Empty element
+   * @param {string} name - Element name as written
+   * @returns {string} Markup terminating the start tag
+   */
+  emptyElementMarkup(element, name) {
+    return this.isVoidElement(element) ? ">" : `></${name}>`;
+  }
+
+  /**
+   * Boolean attributes are minimized to their name alone.
+   *
+   * @param {Attr} attribute - Attribute to write
+   * @returns {string} Attribute markup, starting with a space
+   */
+  attributeMarkup(attribute) {
+    const { name, value } = attribute;
+    if (String(value).toLowerCase() === name.toLowerCase()) {
+      return ` ${name}`;
+    }
+    return ` ${name}="${this.escapeAttribute(value)}"`;
+  }
+
+  /**
+   * Escape character data for HTML.
+   *
+   * @param {string} value - Text content
+   * @returns {string} Escaped text
+   */
+  escapeText(value) {
+    return escapeHtmlText(value);
+  }
+
+  /**
+   * Escape an attribute value for HTML.
+   *
+   * @param {string} value - Attribute value
+   * @returns {string} Escaped value
+   */
+  escapeAttribute(value) {
+    return escapeHtmlAttribute(value);
+  }
+}

package/src/xslt/serializer/indent.js

@@ -0,0 +1,51 @@
+/**
+ * Indentation Rules
+ *
+ * Decides which elements may be pretty printed when `indent="yes"` is set.
+ * Only element-only content is indented; mixed content is left untouched so
+ * that the transformation result stays character-for-character faithful.
+ */
+
+import { NODE_TYPE } from "./constants.js";
+
+/**
+ * Test whether a character data node holds only whitespace.
+ *
+ * @param {Node} node - Text node to test
+ * @returns {boolean} True when the node contains no non-whitespace character
+ */
+export function isWhitespaceOnlyText(node) {
+  return !/\S/.test(node.nodeValue || "");
+}
+
+/**
+ * Collect the children to write when indenting an element.
+ *
+ * @param {Element} element - Element whose children are inspected
+ * @returns {Node[]|null} Children to indent, or null when the element must be
+ *   serialized without any added whitespace
+ */
+export function getIndentableChildren(element) {
+  const indentable = [];
+
+  for (const child of element.childNodes) {
+    if (child.nodeType === NODE_TYPE.TEXT) {
+      if (isWhitespaceOnlyText(child)) {
+        continue;
+      }
+      return null;
+    }
+
+    if (
+      child.nodeType !== NODE_TYPE.ELEMENT &&
+      child.nodeType !== NODE_TYPE.COMMENT &&
+      child.nodeType !== NODE_TYPE.PROCESSING_INSTRUCTION
+    ) {
+      return null;
+    }
+
+    indentable.push(child);
+  }
+
+  return indentable.length > 0 ? indentable : null;
+}