@tradik/xslt-processor 1.1.1 → 1.3.0

package/src/xslt/serializer/xmlSerializer.js

@@ -6,9 +6,16 @@
  * the html serializer, which overrides the dialect hooks defined here.
  */
 
-import { TEXT_MODE, VOID_ELEMENTS } from "./constants.js";
+import { TEXT_MODE, VOID_ELEMENTS, XHTML_NAMESPACE } from "./constants.js";
 import { escapeXmlAttribute, escapeXmlText } from "./escape.js";
+import { characterReference } from "./encoding.js";
 import { BaseWriter } from "./baseWriter.js";
+import { expandedNameKey } from "./settings.js";
+import {
+  isXhtml1Doctype,
+  xhtmlHeadMeta,
+  xhtmlRootNamespace,
+} from "./xhtmlDocument.js";
 
 export class XmlWriter extends BaseWriter {
   /**
@@ -20,11 +27,26 @@ export class XmlWriter extends BaseWriter {
   }
 
   /**
-   * Whether namespace declarations have to be written.
-   * @returns {boolean} Always true for XML output
+   * Whether the output is an XHTML 1.0 document (see xhtmlDocument.js).
+   * @returns {boolean} True when an XHTML 1.0 doctype is declared
    */
-  get emitsNamespaces() {
-    return true;
+  get isXhtmlDocument() {
+    return isXhtml1Doctype(this.settings);
+  }
+
+  /**
+   * Namespace declarations of an element, plus the XHTML namespace libxml2
+   * adds to an `html` element in no namespace of an XHTML 1.0 document.
+   *
+   * @param {Array<{prefix: string, uri: string}>} declarations - Declarations
+   * @param {Element} element - The element they are written on
+   * @returns {string} Attribute markup, starting with a space when non-empty
+   */
+  namespaceMarkup(declarations, element) {
+    const markup = super.namespaceMarkup(declarations);
+    return this.isXhtmlDocument
+      ? markup + xhtmlRootNamespace(element, declarations)
+      : markup;
   }
 
   /**
@@ -43,6 +65,16 @@ export class XmlWriter extends BaseWriter {
     return TEXT_MODE.CDATA;
   }
 
+  /**
+   * Whether a line break follows a top-level comment that another node
+   * follows, as libxslt (xsltSaveResultTo) writes unless `indent="no"` is
+   * declared.
+   * @returns {boolean} True for xml output without `indent="no"`
+   */
+  get topLevelLineBreaks() {
+    return this.settings.topLevelLineBreaks === true;
+  }
+
   /**
    * Build the document type declaration for the xml output method.
    *
@@ -62,18 +94,55 @@ export class XmlWriter extends BaseWriter {
   }
 
   /**
-   * Determine how the character data children of an element are written.
+   * Determine how the character data children of an element are written:
+   * as CDATA sections when the expanded name of the element is listed in
+   * `cdata-section-elements` (XSLT 1.0 section 16.1).
    *
    * @param {Element} element - Parent element
    * @returns {string} A {@link TEXT_MODE} value
    */
   childTextMode(element) {
-    const names = this.settings.cdataSectionElements;
-    return names.has(element.nodeName) || names.has(element.localName)
+    return this.isCdataSectionElement(element)
       ? TEXT_MODE.CDATA
       : TEXT_MODE.ESCAPE;
   }
 
+  /**
+   * Whether an element is listed in `cdata-section-elements`. Prefixed names
+   * the engine passed unresolved are resolved with the element's in-scope
+   * namespaces.
+   *
+   * @param {Element} element - Element to test
+   * @returns {boolean} True when its text is written as CDATA sections
+   */
+  isCdataSectionElement(element) {
+    const { cdataSectionElements, cdataSectionQNames = [] } = this.settings;
+    const namespaceUri = element.namespaceURI || null;
+    const { localName } = element;
+    if (cdataSectionElements.has(expandedNameKey(namespaceUri, localName))) {
+      return true;
+    }
+    return cdataSectionQNames.some(
+      (qname) =>
+        qname.localName === localName &&
+        namespaceUri !== null &&
+        element.lookupNamespaceURI(qname.prefix) === namespaceUri,
+    );
+  }
+
+  /**
+   * Markup the serializer itself adds as the first child of an element: the
+   * Content-Type meta of an XHTML 1.0 document head, as libxml2 writes it.
+   *
+   * @param {Element} element - Element being written
+   * @returns {string} The meta element, or an empty string
+   */
+  leadingChildMarkup(element) {
+    return this.isXhtmlDocument
+      ? xhtmlHeadMeta(element, this.settings.encoding)
+      : "";
+  }
+
   /**
    * Whether the content of an element may be re-indented.
    *
@@ -87,12 +156,33 @@ export class XmlWriter extends BaseWriter {
   /**
    * Build the markup closing an element that has no children.
    *
+   * XHTML elements follow the XHTML compatibility guidelines, as libxml2
+   * (Chrome) and the DOM serializer (Firefox) do: void elements become
+   * `<br />` and every other empty element gets an explicit end tag, because
+   * `<script/>` or `<div/>` break when XHTML reaches an HTML parser. Other
+   * elements use the XML empty-element tag.
+   *
    * @param {Element} element - Empty element
-   * @param {string} _name - Element name as written
+   * @param {string} name - Element name as written
    * @returns {string} Markup terminating the start tag
    */
-  emptyElementMarkup(element, _name) {
-    return this.xhtml && this.isVoidElement(element) ? " />" : "/>";
+  emptyElementMarkup(element, name) {
+    if (!this.followsXhtmlConventions(element)) return "/>";
+    return this.isVoidElement(element) ? " />" : `></${name}>`;
+  }
+
+  /**
+   * Whether an element is written with the XHTML empty-element conventions:
+   * elements in the XHTML namespace, and namespace-less elements when the
+   * output method is `xhtml` or the document type is XHTML 1.0.
+   *
+   * @param {Element} element - Element to test
+   * @returns {boolean} True for XHTML elements
+   */
+  followsXhtmlConventions(element) {
+    const namespace = element.namespaceURI || null;
+    if (namespace === XHTML_NAMESPACE) return true;
+    return namespace === null && (this.xhtml || this.isXhtmlDocument);
   }
 
   /**
@@ -112,7 +202,7 @@ export class XmlWriter extends BaseWriter {
    * @returns {string} Escaped text
    */
   escapeText(value) {
-    return escapeXmlText(value);
+    return this.encodeReferences(escapeXmlText(value));
   }
 
   /**
@@ -122,6 +212,16 @@ export class XmlWriter extends BaseWriter {
    * @returns {string} Escaped value
    */
   escapeAttribute(value) {
-    return escapeXmlAttribute(value);
+    return this.encodeReferences(escapeXmlAttribute(value));
+  }
+
+  /**
+   * Reference to a character the output encoding cannot represent.
+   *
+   * @param {number} codePoint - The code point
+   * @returns {string} A numeric character reference
+   */
+  characterReference(codePoint) {
+    return characterReference(codePoint);
   }
 }

package/src/xslt/serializer.js

@@ -16,7 +16,8 @@
 import { resolveOutputSettings } from "./serializer/settings.js";
 import { XmlWriter } from "./serializer/xmlSerializer.js";
 import { HtmlWriter } from "./serializer/htmlSerializer.js";
-import { serializeText } from "./serializer/textSerializer.js";
+import { textChunks } from "./serializer/textSerializer.js";
+import { toChunkSize } from "./serializer/chunks.js";
 
 export { markRawText, isRawText, rawTextNodes } from "./serializer/rawText.js";
 export {
@@ -26,7 +27,50 @@ export {
 } from "./serializer/settings.js";
 export { XmlWriter } from "./serializer/xmlSerializer.js";
 export { HtmlWriter } from "./serializer/htmlSerializer.js";
-export { serializeText } from "./serializer/textSerializer.js";
+export { serializeText, textChunks } from "./serializer/textSerializer.js";
+export {
+  ChunkBuffer,
+  DEFAULT_CHUNK_SIZE,
+  toChunkSize,
+} from "./serializer/chunks.js";
+
+/**
+ * Serialize a transformation result incrementally, honoring the same
+ * `xsl:output` settings as {@link serializeResult}. The result tree must be
+ * complete (XSLT 1.0 builds it in memory); what is bounded is the output
+ * text: chunks are yielded as soon as they are full, so a consumer can write
+ * them out while the rest is being serialized.
+ *
+ * @param {Node|null} node - Result document, fragment or element
+ * @param {object} [outputSettings] - `xsl:output` settings (see serializeResult)
+ * @param {{chunkSize?: number}} [options] - `chunkSize` in UTF-16 code units,
+ *   {@link DEFAULT_CHUNK_SIZE} (16 KiB) by default, Infinity for one chunk
+ * @yields {string} Non-empty chunks of at most `chunkSize` code units (one
+ *   more when a surrogate pair straddles the boundary)
+ * @returns {Iterator<string>} The chunks; joined, they equal
+ *   `serializeResult(node, outputSettings)`
+ * @throws {RangeError} When `chunkSize` is not a positive integer or Infinity
+ *
+ * @example
+ * for (const chunk of serializeChunks(resultDocument, { method: "xml" })) {
+ *   stream.write(chunk);
+ * }
+ */
+export function serializeChunks(node, outputSettings = {}, options = {}) {
+  const chunkSize = toChunkSize(options.chunkSize);
+  if (!node) return [][Symbol.iterator]();
+
+  const settings = resolveOutputSettings(outputSettings, node);
+
+  if (settings.method === "text") {
+    return textChunks(node, chunkSize);
+  }
+  const writer =
+    settings.method === "html"
+      ? new HtmlWriter(settings)
+      : new XmlWriter(settings, { xhtml: settings.method === "xhtml" });
+  return writer.chunks(node, chunkSize);
+}
 
 /**
  * Serialize a transformation result to a string.
@@ -39,19 +83,8 @@ export { serializeText } from "./serializer/textSerializer.js";
  * @returns {string} The serialized result, or an empty string for a null node
  */
 export function serializeResult(node, outputSettings = {}) {
-  if (!node) {
-    return "";
-  }
-
-  const settings = resolveOutputSettings(outputSettings, node);
-
-  if (settings.method === "text") {
-    return serializeText(node);
-  }
-  if (settings.method === "html") {
-    return new HtmlWriter(settings).serialize(node);
-  }
-  return new XmlWriter(settings, {
-    xhtml: settings.method === "xhtml",
-  }).serialize(node);
+  const chunks = serializeChunks(node, outputSettings, { chunkSize: Infinity });
+  let output = "";
+  for (const chunk of chunks) output += chunk;
+  return output;
 }

package/src/xslt/sort.js

@@ -0,0 +1,151 @@
+/**
+ * xsl:sort (XSLT 1.0 section 10).
+ *
+ * Sort keys are computed once per node (decorate, sort, undecorate) instead of
+ * once per comparison, and the attributes `order`, `lang`, `data-type` and
+ * `case-order` are evaluated as attribute value templates.
+ *
+ * Text keys are compared by Unicode code point unless `lang` or `case-order`
+ * is given. That matches libxslt, the engine behind the native XSLTProcessor
+ * in Chromium browsers, so a stylesheet sorts the same way with this library
+ * as it did natively. With `lang` or `case-order` an `Intl.Collator` is used.
+ *
+ * @module xslt/sort
+ */
+
+/**
+ * Compare two strings by Unicode code point (not by UTF-16 code unit).
+ *
+ * @param {string} a - First string
+ * @param {string} b - Second string
+ * @returns {number} Negative, zero or positive
+ */
+export function compareCodePoints(a, b) {
+  const left = a[Symbol.iterator]();
+  const right = b[Symbol.iterator]();
+
+  for (;;) {
+    const x = left.next();
+    const y = right.next();
+    if (x.done || y.done) return Number(y.done) - Number(x.done) || 0;
+    const diff = x.value.codePointAt(0) - y.value.codePointAt(0);
+    if (diff !== 0) return diff;
+  }
+}
+
+/**
+ * Compare two numeric sort keys; NaN precedes every number (section 10).
+ *
+ * @param {number} a - First key
+ * @param {number} b - Second key
+ * @returns {number} Negative, zero or positive
+ */
+export function compareNumbers(a, b) {
+  const aNaN = Number.isNaN(a);
+  const bNaN = Number.isNaN(b);
+  if (aNaN || bNaN) return Number(bNaN) - Number(aNaN) || 0;
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+
+/**
+ * Build the text comparator for one sort key.
+ *
+ * @param {string} lang - Evaluated `lang` attribute (may be empty)
+ * @param {string} caseOrder - Evaluated `case-order` attribute (may be empty)
+ * @returns {(a: string, b: string) => number} The comparator
+ */
+function textComparator(lang, caseOrder) {
+  if (!lang && !caseOrder) return compareCodePoints;
+
+  let collator;
+  try {
+    collator = new Intl.Collator(lang || undefined, {
+      caseFirst: caseOrder === "lower-first" ? "lower" : "upper",
+      sensitivity: "variant",
+    });
+  } catch {
+    collator = new Intl.Collator(undefined, {
+      caseFirst: caseOrder === "lower-first" ? "lower" : "upper",
+      sensitivity: "variant",
+    });
+  }
+  return collator.compare;
+}
+
+/**
+ * @typedef {object} SortHost
+ * @property {(expr: string, context: object) => *} evaluate - Evaluate an XPath expression
+ * @property {(value: string, context: object) => string} avt - Evaluate an attribute value template
+ * @property {(value: *) => string} toString - XPath string() conversion
+ * @property {(value: *) => number} toNumber - XPath number() conversion
+ */
+
+/**
+ * Resolve one xsl:sort element into a key specification.
+ *
+ * @param {Element} element - The xsl:sort element
+ * @param {object} context - Context of the sorting instruction (for AVTs)
+ * @param {SortHost} host - Engine callbacks
+ * @returns {{select: string, descending: boolean, numeric: boolean, compare: Function}} Specification
+ */
+export function resolveSortSpec(element, context, host) {
+  const attribute = (name) => {
+    const raw = element.getAttribute(name);
+    return raw ? host.avt(raw, context).trim() : "";
+  };
+
+  const dataType = attribute("data-type");
+  const numeric = dataType === "number";
+
+  return {
+    select: element.getAttribute("select") || ".",
+    descending: attribute("order") === "descending",
+    numeric,
+    compare: numeric
+      ? compareNumbers
+      : textComparator(attribute("lang"), attribute("case-order")),
+  };
+}
+
+/**
+ * Sort a node list by the given xsl:sort elements.
+ *
+ * Each key is evaluated with the node as current node, the unsorted list as
+ * current node list and the node's position in that list, as the
+ * specification requires. Ties keep the original order.
+ *
+ * @param {Node[]} nodes - Nodes in their original (document) order
+ * @param {Element[]} sortElements - The xsl:sort children, in order
+ * @param {object} context - XSLT context of the sorting instruction
+ * @param {SortHost} host - Engine callbacks
+ * @returns {Node[]} A new, sorted array
+ */
+export function sortNodes(nodes, sortElements, context, host) {
+  if (sortElements.length === 0 || nodes.length < 2) return [...nodes];
+
+  const specs = sortElements.map((el) => resolveSortSpec(el, context, host));
+
+  const rows = nodes.map((node, index) => {
+    const nodeContext = context.clone({
+      currentNode: node,
+      currentNodeList: nodes,
+      position: index + 1,
+    });
+    const keys = specs.map((spec) => {
+      const text = host.toString(host.evaluate(spec.select, nodeContext));
+      return spec.numeric ? host.toNumber(text) : text;
+    });
+    return { node, index, keys };
+  });
+
+  rows.sort((a, b) => {
+    for (let k = 0; k < specs.length; k++) {
+      const cmp = specs[k].compare(a.keys[k], b.keys[k]);
+      if (cmp !== 0) return specs[k].descending ? -cmp : cmp;
+    }
+    return a.index - b.index;
+  });
+
+  return rows.map((row) => row.node);
+}

package/src/xslt/spaceNameTests.js

@@ -0,0 +1,115 @@
+/**
+ * Name tests of `xsl:strip-space` and `xsl:preserve-space` (XSLT 1.0
+ * section 3.4).
+ *
+ * The `elements` attribute lists XPath name tests: `*`, `prefix:*` or a
+ * QName. The prefixes are expanded with the namespace declarations in scope
+ * on the declaring element, and an unprefixed name only matches elements in
+ * no namespace (XPath 1.0 section 2.3), so `p:*` matches by namespace URI
+ * whatever prefix the source document uses. Name tests given as plain
+ * strings (the {@link WhitespaceFilter} API before 1.2.0) are still matched
+ * by their lexical name.
+ *
+ * @module xslt/spaceNameTests
+ */
+
+"use strict";
+
+import { isQName } from "./qname.js";
+import { splitQName } from "./resultNamespaces.js";
+import { inScopeNamespaces, resolvePrefix } from "./stylesheetNamespaces.js";
+
+/**
+ * @typedef {Object} ElementNameTest
+ * @property {string|null|undefined} namespaceUri - The namespace to match,
+ *   null for no namespace, undefined for any (the `*` test)
+ * @property {string} localName - The local name, `*` for any
+ */
+
+/**
+ * Expand the name tests of an `elements` attribute.
+ *
+ * @param {string|null} value - Whitespace separated name tests
+ * @param {Element} element - The xsl:strip-space or xsl:preserve-space element
+ * @param {(message: string) => void} warn - Reports a skipped name test
+ * @returns {ElementNameTest[]} The expanded name tests
+ *
+ * @example
+ * // <xsl:strip-space xmlns:m="urn:m" elements="m:* p *"/>
+ * compileSpaceNameTests("m:* p *", element, console.warn);
+ * // [{ namespaceUri: "urn:m", localName: "*" },
+ * //  { namespaceUri: null, localName: "p" },
+ * //  { namespaceUri: undefined, localName: "*" }]
+ */
+export function compileSpaceNameTests(value, element, warn) {
+  const tests = [];
+  for (const token of (value ?? "").split(/[ \t\r\n]+/).filter(Boolean)) {
+    if (token === "*") {
+      tests.push({ namespaceUri: undefined, localName: "*" });
+      continue;
+    }
+    const { prefix, localName } = splitQName(token);
+    const qname = localName === "*" ? `${prefix}:x` : token;
+    const namespaceUri = prefix
+      ? resolvePrefix(inScopeNamespaces(element), prefix)
+      : null;
+    if (!isQName(qname) || (prefix && !namespaceUri)) {
+      warn(
+        `xsl:${element.localName} elements: "${token}" is not a name test with a declared prefix and is ignored`,
+      );
+      continue;
+    }
+    tests.push({ namespaceUri, localName });
+  }
+  return tests;
+}
+
+/**
+ * The XSLT default priority of an element name test (section 5.5).
+ *
+ * @param {string|ElementNameTest} nameTest - A name test
+ * @returns {number} -0.5 for `*`, -0.25 for `prefix:*`, 0 for a name
+ */
+export function nameTestPriority(nameTest) {
+  if (typeof nameTest === "string") {
+    if (nameTest === "*") return -0.5;
+    return nameTest.endsWith(":*") ? -0.25 : 0;
+  }
+  if (nameTest.namespaceUri === undefined) return -0.5;
+  return nameTest.localName === "*" ? -0.25 : 0;
+}
+
+/**
+ * Whether an element matches a lexical name test (the string API).
+ *
+ * @param {Element} element - The element to test
+ * @param {string} nameTest - `*`, `prefix:*` or a name
+ * @returns {boolean} True when the element matches
+ */
+function matchesLexicalTest(element, nameTest) {
+  if (nameTest === "*") return true;
+  if (nameTest.endsWith(":*")) {
+    return element.nodeName.startsWith(`${nameTest.slice(0, -2)}:`);
+  }
+  return element.nodeName === nameTest || element.localName === nameTest;
+}
+
+/**
+ * Whether an element matches a name test.
+ *
+ * @param {Element} element - The element to test
+ * @param {string|ElementNameTest} nameTest - A name test
+ * @returns {boolean} True when the element matches
+ *
+ * @example
+ * matchesNameTest(pElement, { namespaceUri: null, localName: "p" }); // true
+ */
+export function matchesNameTest(element, nameTest) {
+  if (typeof nameTest === "string") {
+    return matchesLexicalTest(element, nameTest);
+  }
+  const { namespaceUri, localName } = nameTest;
+  if (namespaceUri === undefined) return true;
+  if ((element.namespaceURI || null) !== namespaceUri) return false;
+  return localName === "*" || element.localName === localName;
+}