@tradik/xslt-processor 1.0.3 → 1.3.0

package/src/xslt/patterns.js

@@ -0,0 +1,324 @@
+/**
+ * XSLT 1.0 pattern matching (section 5.2).
+ *
+ * A pattern is a union of location path patterns. Each alternative is an
+ * absolute or relative location path that only uses the child and attribute
+ * axes and the `/` and `//` separators, optionally anchored on an `id()` or
+ * `key()` call. Patterns are parsed once with the XPath parser and the
+ * compiled form is cached per pattern string.
+ *
+ * Matching runs right to left: the node is tested against the last step, then
+ * its parent (for `/`) or any ancestor (for `//`) against the previous step.
+ * This costs O(depth) per node instead of evaluating the pattern as an
+ * expression from the parent, which is O(siblings) and made
+ * `xsl:apply-templates` quadratic in the number of children.
+ *
+ * Predicates follow the "position in the context of the parent" rule: a
+ * predicate is evaluated with the node's position among its siblings that
+ * pass the step's node test and the preceding predicates. That sibling list is
+ * only built when the predicate uses `position()`/`last()` or evaluates to a
+ * number, and it is cached per parent until {@link PatternMatcher#reset}.
+ *
+ * @module xslt/patterns
+ */
+
+import { childAxis } from "../xpath/axes.js";
+import { ROOT, compilePattern } from "./patternCompiler.js";
+import {
+  MatchScope,
+  isNamespaceDeclaration,
+  isRoot,
+  parentOf,
+  rootOf,
+} from "./matchScope.js";
+
+export { compilePattern };
+
+/**
+ * Matches nodes against XSLT patterns with an XPath evaluator.
+ */
+export class PatternMatcher {
+  /**
+   * @param {import('../xpath/evaluator.js').XPathEvaluator} evaluator - Evaluator used for node tests, predicates and anchors
+   */
+  constructor(evaluator) {
+    this.evaluator = evaluator;
+    this.compiled = new Map();
+    this.positions = new WeakMap();
+    this.anchors = new WeakMap();
+  }
+
+  /**
+   * Forget cached sibling positions and anchor node-sets, e.g. before a new
+   * transformation (the source tree may have been modified in between).
+   *
+   * @returns {void}
+   */
+  reset() {
+    this.positions = new WeakMap();
+    this.anchors = new WeakMap();
+  }
+
+  /**
+   * Compile a pattern, reusing the cached form.
+   *
+   * @param {string} pattern - The XSLT pattern
+   * @returns {object[]} The compiled alternatives
+   * @throws {Error} When the string is not a valid pattern (XSLT 1.0
+   *   section 5.2); the message names the pattern
+   */
+  compile(pattern) {
+    let compiled = this.compiled.get(pattern);
+    if (!compiled) {
+      try {
+        compiled = compilePattern(pattern);
+      } catch (error) {
+        throw new Error(`Invalid pattern "${pattern}": ${error.message}`, {
+          cause: error,
+        });
+      }
+      this.compiled.set(pattern, compiled);
+    }
+    return compiled;
+  }
+
+  /**
+   * Test whether a node matches a pattern.
+   *
+   * @param {Node} node - The candidate node
+   * @param {string} pattern - The XSLT pattern
+   * @param {object|null} [host] - XSLT context supplying variables and namespaces
+   * @param {Object<string, string>} [namespaces] - Prefix bindings overriding the host's
+   * @returns {boolean} True when the node matches any alternative
+   *
+   * @example
+   * matcher.matches(titleElement, 'chapter/title', xsltContext); // true
+   */
+  matches(node, pattern, host = null, namespaces = undefined) {
+    const scope = new MatchScope(host, namespaces);
+    for (const alternative of this.compile(pattern)) {
+      if (this.matchesAlternative(node, alternative, scope)) return true;
+    }
+    return false;
+  }
+
+  /**
+   * @param {Node} node - Candidate node
+   * @param {object} alternative - Compiled alternative
+   * @param {MatchScope} scope - Match state
+   * @returns {boolean} Whether the node matches the alternative
+   */
+  matchesAlternative(node, alternative, scope) {
+    const { anchor, steps } = alternative;
+    if (steps.length > 0) {
+      return this.matchesStep(node, alternative, steps.length - 1, scope);
+    }
+    if (anchor === ROOT) return isRoot(node);
+    return this.anchorNodes(anchor, node, scope).has(node);
+  }
+
+  /**
+   * Match a node against step `index`, then the rest of the path leftwards.
+   *
+   * @param {Node} node - Candidate node
+   * @param {object} alternative - Compiled alternative
+   * @param {number} index - Index of the step to test
+   * @param {MatchScope} scope - Match state
+   * @returns {boolean} Whether the node matches steps 0..index
+   */
+  matchesStep(node, alternative, index, scope) {
+    const step = alternative.steps[index];
+    if (!this.testStep(node, step, scope)) return false;
+
+    const parent = parentOf(node);
+    if (step.separator === null) return true;
+
+    let accepts;
+    if (index > 0) {
+      accepts = (candidate) =>
+        this.matchesStep(candidate, alternative, index - 1, scope);
+    } else if (alternative.anchor === ROOT) {
+      accepts = isRoot;
+    } else {
+      const anchors = this.anchorNodes(alternative.anchor, node, scope);
+      accepts = (candidate) => anchors.has(candidate);
+    }
+
+    if (step.separator === "/") return parent !== null && accepts(parent);
+    for (let ancestor = parent; ancestor; ancestor = parentOf(ancestor)) {
+      if (accepts(ancestor)) return true;
+    }
+    return false;
+  }
+
+  /**
+   * Test a node against the axis, node test and predicates of one step.
+   *
+   * @param {Node} node - Candidate node
+   * @param {object} step - Compiled step
+   * @param {MatchScope} scope - Match state
+   * @returns {boolean} Whether the node satisfies the step
+   */
+  testStep(node, step, scope) {
+    const type = node.nodeType;
+    if (step.axis === "attribute") {
+      if (type !== 2 || isNamespaceDeclaration(node)) return false;
+    } else if (type === 2 || type === 9 || type === 11 || type === 13) {
+      // Patterns only use the child and attribute axes: roots, attributes
+      // and namespace nodes are never children
+      return false;
+    }
+    if (
+      !this.evaluator.matchNodeTest(
+        step.nodeTest,
+        node,
+        scope.testContext(node),
+      )
+    ) {
+      return false;
+    }
+
+    for (let k = 0; k < step.predicates.length; k++) {
+      if (!this.testPredicate(node, step, k, scope)) return false;
+    }
+    return true;
+  }
+
+  /**
+   * Evaluate predicate `k` of a step for a node.
+   *
+   * @param {Node} node - Candidate node
+   * @param {object} step - Compiled step
+   * @param {number} k - Predicate index
+   * @param {MatchScope} scope - Match state
+   * @returns {boolean} Whether the predicate holds
+   */
+  testPredicate(node, step, k, scope) {
+    const predicate = step.predicates[k];
+    let position = 1;
+    let size = 1;
+
+    if (predicate.positional) {
+      ({ position, size } = this.siblingPosition(node, step, k, scope));
+    }
+
+    const value = this.evaluator.evaluate(
+      predicate.expr,
+      scope.context(node, position, size),
+    );
+    if (typeof value !== "number") return this.evaluator.toBoolean(value);
+    if (!predicate.positional) {
+      position = this.siblingPosition(node, step, k, scope).position;
+    }
+    return value === position;
+  }
+
+  /**
+   * Position and size of a node among its siblings that pass the step's node
+   * test and its predicates before `k`. Cached per parent and predicate.
+   *
+   * @param {Node} node - Candidate node
+   * @param {object} step - Compiled step
+   * @param {number} k - Predicate index
+   * @param {MatchScope} scope - Match state
+   * @returns {{position: number, size: number}} Context position and size
+   */
+  siblingPosition(node, step, k, scope) {
+    const parent = parentOf(node);
+    if (!parent) return { position: 1, size: 1 };
+
+    let byPredicate = this.positions.get(parent);
+    if (!byPredicate) {
+      byPredicate = new Map();
+      this.positions.set(parent, byPredicate);
+    }
+
+    const predicate = step.predicates[k];
+    let entry = byPredicate.get(predicate);
+    if (!entry) {
+      const nodes = this.candidateSiblings(parent, step, k, scope);
+      const index = new Map();
+      nodes.forEach((sibling, i) => index.set(sibling, i + 1));
+      entry = { index, size: nodes.length };
+      byPredicate.set(predicate, entry);
+    }
+
+    return { position: entry.index.get(node) ?? 0, size: entry.size };
+  }
+
+  /**
+   * Siblings selected by a step before predicate `k` is applied.
+   *
+   * @param {Node} parent - The common parent
+   * @param {object} step - Compiled step
+   * @param {number} k - Predicate index
+   * @param {MatchScope} scope - Match state
+   * @returns {Node[]} The candidate siblings in document order
+   */
+  candidateSiblings(parent, step, k, scope) {
+    const all =
+      step.axis === "attribute"
+        ? Array.from(parent.attributes || [])
+        : childAxis(parent);
+    let nodes = all.filter(
+      (sibling) =>
+        (sibling.nodeType === 2) === (step.axis === "attribute") &&
+        !(sibling.nodeType === 2 && isNamespaceDeclaration(sibling)) &&
+        this.evaluator.matchNodeTest(
+          step.nodeTest,
+          sibling,
+          scope.testContext(sibling),
+        ),
+    );
+    const base = scope.context(parent, 1, 1);
+    for (let i = 0; i < k; i++) {
+      nodes = this.evaluator.filterByPredicate(nodes, step.predicates[i], base);
+    }
+    return nodes;
+  }
+
+  /**
+   * The nodes selected by the `id()`/`key()` anchor of a pattern relative to
+   * a node. Anchors only have literal arguments (see patternCompiler.js), so
+   * the set only depends on the node's tree and the prefixes in scope: it is
+   * computed once per root until {@link PatternMatcher#reset}, instead of
+   * once per candidate node.
+   *
+   * @param {object} anchor - Function call AST
+   * @param {Node} node - Node providing the document
+   * @param {MatchScope} scope - Match state
+   * @returns {Set<Node>} The anchor nodes
+   */
+  anchorNodes(anchor, node, scope) {
+    const root = rootOf(node);
+    let byAnchor = this.anchors.get(root);
+    if (!byAnchor) {
+      byAnchor = new Map();
+      this.anchors.set(root, byAnchor);
+    }
+    let byScope = byAnchor.get(anchor);
+    if (!byScope) {
+      byScope = new Map();
+      byAnchor.set(anchor, byScope);
+    }
+    let nodes = byScope.get(scope.namespaces);
+    if (!nodes) {
+      nodes = this.evaluateAnchor(anchor, node, scope);
+      byScope.set(scope.namespaces, nodes);
+    }
+    return nodes;
+  }
+
+  /**
+   * Evaluate the `id()`/`key()` anchor of a pattern relative to a node.
+   *
+   * @param {object} anchor - Function call AST
+   * @param {Node} node - Node providing the document
+   * @param {MatchScope} scope - Match state
+   * @returns {Set<Node>} The anchor nodes
+   */
+  evaluateAnchor(anchor, node, scope) {
+    const result = this.evaluator.evaluate(anchor, scope.context(node, 1, 1));
+    return new Set(Array.isArray(result) ? result : []);
+  }
+}

package/src/xslt/qname.js

@@ -0,0 +1,90 @@
+/**
+ * XML names (XML 1.0 fifth edition, section 2.3) and qualified names
+ * (Namespaces in XML 1.0, section 4).
+ *
+ * Used to validate names computed at run time by `xsl:element` and
+ * `xsl:attribute` (XSLT 1.0 sections 7.1.2 and 7.1.3) before they reach the
+ * DOM, so an invalid name is reported instead of producing malformed output.
+ *
+ * @module xslt/qname
+ */
+
+"use strict";
+
+/** NameStartChar code point ranges, without ":" (production [4]). */
+const NAME_START_RANGES = [
+  [0x41, 0x5a], // A-Z
+  [0x5f, 0x5f], // _
+  [0x61, 0x7a], // a-z
+  [0xc0, 0xd6],
+  [0xd8, 0xf6],
+  [0xf8, 0x2ff],
+  [0x370, 0x37d],
+  [0x37f, 0x1fff],
+  [0x200c, 0x200d],
+  [0x2070, 0x218f],
+  [0x2c00, 0x2fef],
+  [0x3001, 0xd7ff],
+  [0xf900, 0xfdcf],
+  [0xfdf0, 0xfffd],
+  [0x10000, 0xeffff],
+];
+
+/** Extra NameChar code point ranges (production [4a]). */
+const NAME_CHAR_RANGES = [
+  [0x2d, 0x2e], // - .
+  [0x30, 0x39], // 0-9
+  [0xb7, 0xb7],
+  [0x300, 0x36f],
+  [0x203f, 0x2040],
+];
+
+/**
+ * Whether a code point lies in one of the ranges.
+ *
+ * @param {number} code - A Unicode code point
+ * @param {number[][]} ranges - Inclusive `[first, last]` ranges
+ * @returns {boolean} True when the code point is in a range
+ */
+function inRanges(code, ranges) {
+  return ranges.some(([first, last]) => code >= first && code <= last);
+}
+
+/**
+ * Whether a string is an NCName (a name without a colon).
+ *
+ * @param {string} name - The candidate name
+ * @returns {boolean} True for a valid NCName
+ *
+ * @example
+ * isNcName("item-1"); // true
+ * isNcName("1item");  // false
+ */
+export function isNcName(name) {
+  let first = true;
+  for (const char of name) {
+    const code = char.codePointAt(0);
+    const valid =
+      inRanges(code, NAME_START_RANGES) ||
+      (!first && inRanges(code, NAME_CHAR_RANGES));
+    if (!valid) return false;
+    first = false;
+  }
+  return !first;
+}
+
+/**
+ * Whether a string is a QName: an NCName, optionally prefixed by another
+ * NCName and a single colon.
+ *
+ * @param {string} name - The candidate name
+ * @returns {boolean} True for a valid QName
+ *
+ * @example
+ * isQName("xl:href"); // true
+ * isQName("a:b:c");   // false
+ */
+export function isQName(name) {
+  const parts = name.split(":");
+  return parts.length <= 2 && parts.every(isNcName);
+}

package/src/xslt/resultDocument.js

@@ -0,0 +1,98 @@
+/**
+ * The document returned by `transformToDocument`, built like Chrome's
+ * `XSLTProcessor` builds it from the serialized output:
+ *
+ * - xml output: the result tree nodes, minus whitespace-only text at the
+ *   document level (the XML parser drops it, and a document cannot hold
+ *   text), with a document type node when `xsl:output` declares
+ *   `doctype-public` or `doctype-system` (as libxslt creates one);
+ * - html output: an HTML document parsed from the serialized html output,
+ *   so it has `html`, `head` and `body` elements that are HTMLElements;
+ * - text output: see wrapTextResult in resultTree.js.
+ *
+ * @module xslt/resultDocument
+ */
+
+"use strict";
+
+import { findRootElement } from "./serializer/settings.js";
+import { appendDoctype } from "./resultTree.js";
+import { findParseError } from "./domParsing.js";
+
+/** Text made only of XML whitespace (#x20 #x9 #xD #xA). */
+const WHITESPACE_ONLY = /^[ \t\r\n]*$/;
+
+/**
+ * Whether a result node is whitespace-only character data.
+ *
+ * @param {Node} node - A child of the result fragment
+ * @returns {boolean} True for text or CDATA holding only whitespace
+ */
+function isWhitespaceText(node) {
+  return (
+    (node.nodeType === 3 || node.nodeType === 4) &&
+    WHITESPACE_ONLY.test(node.nodeValue)
+  );
+}
+
+/**
+ * Move an xml result fragment into an empty document.
+ *
+ * @param {Document} doc - An empty XML document
+ * @param {DocumentFragment} fragment - The result, owned by `doc`
+ * @param {{doctypePublic?: string|null, doctypeSystem?: string|null}} settings -
+ *   The xsl:output settings
+ * @returns {Document} The same document, filled in
+ * @throws {Error} When the result cannot be a document (text or several
+ *   elements at the top level), as the DOM rejects it
+ *
+ * @example
+ * fillXmlDocument(doc, fragment, { doctypeSystem: "doc.dtd" }).doctype.name;
+ */
+export function fillXmlDocument(doc, fragment, settings) {
+  const { doctypePublic, doctypeSystem } = settings;
+  const root = findRootElement(fragment);
+  if (root && (doctypePublic || doctypeSystem)) {
+    appendDoctype(doc, root.nodeName, doctypePublic ?? "", doctypeSystem ?? "");
+  }
+  for (const child of Array.from(fragment.childNodes)) {
+    if (!isWhitespaceText(child)) doc.appendChild(child);
+  }
+  return doc;
+}
+
+/**
+ * Parse serialized html output into an HTML document, as Chrome does for
+ * `transformToDocument` with the html output method. The DOMParser of the
+ * host (global, or the window of the source document) is used; without one,
+ * an HTML document of the source's DOM implementation is filled through
+ * `innerHTML` (without a doctype node).
+ *
+ * xmldom parses `text/html` too, into a document without the HTML
+ * accessors (`body`, `head`, `title`); DOMs that can do neither, and markup
+ * the HTML parser rejects, leave the XML result in place.
+ *
+ * @param {string} markup - The serialized html output
+ * @param {Document} referenceDoc - A document of the DOM implementation to use
+ * @returns {Document|null} The HTML document, or null when the DOM cannot
+ *   create HTML documents (the caller then keeps the XML result)
+ *
+ * @example
+ * parseHtmlDocument("<html><body><p>x</p></body></html>", xmlDoc).body;
+ */
+export function parseHtmlDocument(markup, referenceDoc) {
+  const Parser =
+    globalThis.DOMParser ?? referenceDoc.defaultView?.DOMParser ?? null;
+  if (Parser) {
+    const doc = new Parser().parseFromString(markup, "text/html");
+    return findParseError(doc) ? null : doc;
+  }
+
+  const implementation = referenceDoc.implementation;
+  if (typeof implementation?.createHTMLDocument !== "function") return null;
+  const doc = implementation.createHTMLDocument("");
+  if (!("innerHTML" in doc.documentElement)) return null;
+  if (doc.doctype) doc.removeChild(doc.doctype);
+  doc.documentElement.innerHTML = markup;
+  return doc;
+}