@tradik/xslt-processor 1.0.3 → 1.3.0

package/src/xslt/literalResult.js

@@ -0,0 +1,223 @@
+/**
+ * Literal result element support: namespace aliasing and attribute filtering.
+ *
+ * `xsl:namespace-alias` rewrites the namespace of literal result elements and
+ * attributes, which is what makes it possible for a stylesheet to generate
+ * another stylesheet. Attribute filtering keeps XSLT-only attributes such as
+ * `xsl:use-attribute-sets` out of the result tree.
+ */
+
+"use strict";
+
+/**
+ * Resolve a namespace prefix against the declarations in scope of a node.
+ *
+ * Falls back to walking `xmlns` attributes when the DOM implementation does not
+ * provide `lookupNamespaceURI`.
+ *
+ * @param {Element} node - The element whose scope is searched
+ * @param {string|null} prefix - The prefix, or null for the default namespace
+ * @returns {string|null} The namespace URI, or null when undeclared
+ *
+ * @example
+ * lookupNamespaceUri(stylesheetElement, 'xsl');
+ */
+export function lookupNamespaceUri(node, prefix) {
+  if (typeof node.lookupNamespaceURI === "function") {
+    const found = node.lookupNamespaceURI(prefix);
+    if (found) return found;
+  }
+
+  const attributeName = prefix ? `xmlns:${prefix}` : "xmlns";
+  let current = node;
+
+  while (current?.nodeType === 1) {
+    const value = current.getAttribute(attributeName);
+    if (value) return value;
+    current = current.parentNode;
+  }
+
+  return null;
+}
+
+/**
+ * The `xsl:namespace-alias` declarations of a stylesheet.
+ *
+ * Literal result names are aliased as libxslt (and so Chrome) does, see
+ * {@link NamespaceAliasMap#resolveLiteral}: the namespace URI is replaced and
+ * the prefix written in the stylesheet is kept (`axsl:stylesheet` with
+ * `xmlns:axsl` bound to the XSLT namespace); `result-prefix="#default"`
+ * without a default namespace in scope gives names in no namespace, and
+ * `stylesheet-prefix="#default"` without a default namespace in scope
+ * aliases the elements in no namespace, which then take the result prefix.
+ */
+export class NamespaceAliasMap {
+  constructor() {
+    this.byUri = new Map();
+    /** Alias of elements in no namespace (`#default` stylesheet prefix). */
+    this.noNamespaceAlias = null;
+  }
+
+  /**
+   * Record one `xsl:namespace-alias` declaration.
+   *
+   * @param {Element} node - The `xsl:namespace-alias` element
+   * @returns {void}
+   *
+   * @example
+   * aliases.add(namespaceAliasElement);
+   */
+  add(node) {
+    const stylesheetPrefix = node.getAttribute("stylesheet-prefix");
+    const resultPrefix = node.getAttribute("result-prefix");
+    if (!stylesheetPrefix || !resultPrefix) return;
+
+    const isDefaultSource = stylesheetPrefix === "#default";
+    const fromUri = lookupNamespaceUri(
+      node,
+      isDefaultSource ? null : stylesheetPrefix,
+    );
+    if (!fromUri && !isDefaultSource) return;
+
+    const isDefaultResult = resultPrefix === "#default";
+    const toUri = lookupNamespaceUri(
+      node,
+      isDefaultResult ? null : resultPrefix,
+    );
+    const alias = { uri: toUri, prefix: isDefaultResult ? null : resultPrefix };
+
+    if (fromUri) this.byUri.set(fromUri, alias);
+    else if (toUri) this.noNamespaceAlias = alias;
+  }
+
+  /**
+   * Whether any alias was declared.
+   *
+   * @returns {boolean} True when at least one alias is known
+   *
+   * @example
+   * aliases.isEmpty();
+   */
+  isEmpty() {
+    return this.byUri.size === 0 && this.noNamespaceAlias === null;
+  }
+
+  /**
+   * Whether a namespace is the stylesheet side of an alias.
+   *
+   * @param {string} uri - A namespace URI
+   * @returns {boolean} True when literal result names in it are aliased
+   *
+   * @example
+   * aliases.isAliased('http://www.w3.org/1999/XSL/TransformAlias'); // true
+   */
+  isAliased(uri) {
+    return this.byUri.has(uri);
+  }
+
+  /**
+   * Apply aliasing to a literal result name.
+   *
+   * @param {string|null} namespaceUri - The namespace of the stylesheet node
+   * @param {string} localName - The local name of the stylesheet node
+   * @returns {{namespaceUri: (string|null), qname: string}|null} The aliased name, or null when no alias applies
+   *
+   * @example
+   * aliases.resolve('http://www.w3.org/1999/XSL/TransformAlias', 'stylesheet');
+   * // { namespaceUri: 'http://www.w3.org/1999/XSL/Transform', qname: 'xsl:stylesheet' }
+   */
+  resolve(namespaceUri, localName) {
+    const alias = namespaceUri ? this.byUri.get(namespaceUri) : undefined;
+    if (!alias) return null;
+
+    return {
+      namespaceUri: alias.uri,
+      qname: alias.prefix ? `${alias.prefix}:${localName}` : localName,
+    };
+  }
+
+  /**
+   * Apply aliasing to the name of a literal result element or attribute as
+   * libxslt does: the namespace URI is replaced and the stylesheet prefix
+   * kept. An element in no namespace takes the `#default` stylesheet-prefix
+   * alias with its result prefix; an alias to no namespace drops the prefix.
+   *
+   * @param {Element|Attr} node - The literal result element or attribute
+   * @returns {{namespaceUri: (string|null), qname: string}|null} The aliased
+   *   name, or null when no alias applies
+   *
+   * @example
+   * // xmlns:axsl="urn:alias", <xsl:namespace-alias stylesheet-prefix="axsl"
+   * //   result-prefix="xsl"/>
+   * aliases.resolveLiteral(axslStylesheetElement);
+   * // { namespaceUri: 'http://www.w3.org/1999/XSL/Transform', qname: 'axsl:stylesheet' }
+   */
+  resolveLiteral(node) {
+    const { localName } = node;
+    if (!node.namespaceURI) {
+      const alias = node.nodeType === 1 ? this.noNamespaceAlias : null;
+      return alias
+        ? { namespaceUri: alias.uri, qname: `${alias.prefix}:${localName}` }
+        : null;
+    }
+    const alias = this.byUri.get(node.namespaceURI);
+    if (!alias) return null;
+    if (!alias.uri) return { namespaceUri: null, qname: localName };
+    return {
+      namespaceUri: alias.uri,
+      qname: node.prefix ? `${node.prefix}:${localName}` : localName,
+    };
+  }
+}
+
+/**
+ * Whether an attribute of a literal result element is copied to the output.
+ *
+ * Namespace declarations are re-created from the element namespaces themselves,
+ * and every XSLT attribute (`xsl:use-attribute-sets`, `xsl:version`,
+ * `xsl:exclude-result-prefixes`, `xsl:extension-element-prefixes`) is an
+ * instruction to the processor rather than result tree content.
+ *
+ * @param {Attr} attribute - The attribute of the stylesheet element
+ * @param {string} xsltNamespace - The XSLT namespace URI
+ * @returns {boolean} True when the attribute belongs in the result
+ *
+ * @example
+ * shouldCopyAttribute(attr, 'http://www.w3.org/1999/XSL/Transform');
+ */
+export function shouldCopyAttribute(attribute, xsltNamespace) {
+  if (attribute.namespaceURI === xsltNamespace) return false;
+  if (attribute.name === "xmlns" || attribute.name.startsWith("xmlns:")) {
+    return false;
+  }
+  return !attribute.name.startsWith("xsl:");
+}
+
+/**
+ * Read an XSLT attribute from a literal result element.
+ *
+ * Works both for namespace aware DOMs and for documents where the attribute is
+ * only known by its `xsl:` qualified name.
+ *
+ * @param {Element} node - The literal result element
+ * @param {string} localName - The XSLT attribute local name
+ * @param {string} xsltNamespace - The XSLT namespace URI
+ * @returns {string|null} The attribute value, or null when absent
+ *
+ * @example
+ * getXsltAttribute(element, 'use-attribute-sets', XSLT_NS);
+ */
+export function getXsltAttribute(node, localName, xsltNamespace) {
+  if (!node.attributes) return null;
+
+  for (const attribute of node.attributes) {
+    const matchesNamespace =
+      attribute.namespaceURI === xsltNamespace &&
+      (attribute.localName || attribute.name) === localName;
+    if (matchesNamespace || attribute.name === `xsl:${localName}`) {
+      return attribute.value;
+    }
+  }
+
+  return null;
+}

package/src/xslt/matchScope.js

@@ -0,0 +1,116 @@
+/**
+ * Helpers of the XSLT pattern matcher (see patterns.js): node relationships
+ * in the XPath data model and the per-call {@link MatchScope} that builds the
+ * XPath contexts predicates and `id()`/`key()` anchors are evaluated in.
+ *
+ * @module xslt/matchScope
+ */
+
+"use strict";
+
+import { XPathContext } from "../xpath/evaluator.js";
+import { parentOf } from "../xpath/axes.js";
+
+const XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
+const EMPTY_VARIABLES = Object.freeze({});
+const EMPTY_NAMESPACES = Object.freeze({});
+
+export { parentOf };
+
+/**
+ * The root of the tree holding a node (its document, or the top of a
+ * detached subtree or result tree fragment).
+ *
+ * @param {Node} node - Any node
+ * @returns {Node} The outermost ancestor
+ */
+export function rootOf(node) {
+  let root = node;
+  for (let parent = parentOf(root); parent; parent = parentOf(parent)) {
+    root = parent;
+  }
+  return root;
+}
+
+/**
+ * Whether a node is a root node (a document or a result tree fragment).
+ *
+ * @param {Node|null} node - Any node
+ * @returns {boolean} True for document and document fragment nodes
+ */
+export function isRoot(node) {
+  return node !== null && (node.nodeType === 9 || node.nodeType === 11);
+}
+
+/**
+ * Whether an attribute is a namespace declaration, which XPath does not
+ * expose on the attribute axis.
+ *
+ * @param {Attr} attribute - An attribute node
+ * @returns {boolean} True for `xmlns` and `xmlns:*` attributes
+ */
+export function isNamespaceDeclaration(attribute) {
+  return (
+    attribute.namespaceURI === XMLNS_NAMESPACE ||
+    attribute.name === "xmlns" ||
+    attribute.name.startsWith("xmlns:")
+  );
+}
+
+/**
+ * State of a single match call: lazily merges the XSLT variables once.
+ */
+export class MatchScope {
+  /**
+   * @param {object|null} host - XSLT context (variables, parameters, namespaces)
+   * @param {Object<string, string>} [namespaces] - Prefix bindings, when they
+   *   differ from the host's (e.g. those in scope on an xsl:template)
+   */
+  constructor(host, namespaces) {
+    this.host = host;
+    this.namespaces = namespaces ?? host?.namespaces ?? EMPTY_NAMESPACES;
+    this.variables = null;
+  }
+
+  /**
+   * Build an XPath context for evaluating a predicate or anchor call.
+   *
+   * @param {Node} node - Context node
+   * @param {number} position - Context position
+   * @param {number} size - Context size
+   * @returns {XPathContext} The evaluation context
+   */
+  context(node, position, size) {
+    if (!this.variables) {
+      this.variables = this.host?.xpathVariables ?? {
+        ...this.host?.variables,
+        ...this.host?.parameters,
+      };
+    }
+    return new XPathContext(
+      node,
+      position,
+      size,
+      this.variables,
+      this.namespaces,
+      this.host,
+    );
+  }
+
+  /**
+   * Build a cheap XPath context for node tests (namespaces only).
+   *
+   * @param {Node} node - Context node
+   * @returns {XPathContext} The evaluation context
+   */
+  testContext(node) {
+    return new XPathContext(
+      node,
+      1,
+      1,
+      EMPTY_VARIABLES,
+      this.namespaces,
+      this.host,
+    );
+  }
+}

package/src/xslt/number.js

@@ -0,0 +1,271 @@
+/**
+ * `xsl:number` counting (XSLT 1.0 section 7.7).
+ *
+ * Counting is kept independent from the engine: callers pass a `matcher`
+ * callback that answers "does this node match this XSLT pattern", which keeps
+ * this module free of the XPath evaluator and easy to test in isolation.
+ *
+ * Numbering every node of a long list would be quadratic if each call counted
+ * from scratch, so a call may be given a memo (one per instruction and
+ * transformation, see {@link isMemoizable}) remembering the numbers already
+ * computed: a later call stops at the nearest numbered node. The tree is
+ * walked with previousSibling/lastChild/parentNode only.
+ */
+
+"use strict";
+
+import { isParserArtifact } from "../xpath/axes.js";
+
+/** Node types that participate in `xsl:number` counting. */
+const COUNTABLE_NODE_TYPES = new Set([1, 3, 4, 7, 8]);
+
+/**
+ * Whether a node takes part in counting: an element, text, processing
+ * instruction or comment of the data model (not a parser artifact, see
+ * axes.js).
+ *
+ * @param {Node} node - Any node
+ * @returns {boolean} True for countable nodes
+ */
+function isCountable(node) {
+  return COUNTABLE_NODE_TYPES.has(node.nodeType) && !isParserArtifact(node);
+}
+
+/**
+ * The XPath node kind of a DOM node: CDATA sections are text nodes.
+ *
+ * @param {Node} node - Any node
+ * @returns {number} The DOM node type, 3 for CDATA sections
+ */
+function nodeKind(node) {
+  return node.nodeType === 4 ? 3 : node.nodeType;
+}
+
+/**
+ * Default `count` pattern: nodes of the same kind as the numbered node and,
+ * for elements and attributes, the same expanded name; for processing
+ * instructions, the same target.
+ *
+ * @param {Node} candidate - The node being considered
+ * @param {Node} node - The node `xsl:number` is numbering
+ * @returns {boolean} True when the candidate is counted
+ */
+function matchesDefaultCount(candidate, node) {
+  if (nodeKind(candidate) !== nodeKind(node)) return false;
+  switch (node.nodeType) {
+    case 1:
+    case 2:
+      return (
+        candidate.localName === node.localName &&
+        (candidate.namespaceURI ?? null) === (node.namespaceURI ?? null)
+      );
+    case 7:
+      return candidate.target === node.target;
+    default:
+      return true;
+  }
+}
+
+/**
+ * Key telling apart the node kinds the default `count` pattern selects, so
+ * memoized numbers are only reused for the same kind.
+ *
+ * @param {Node} node - The numbered node
+ * @returns {string} e.g. `1|urn:x|item`
+ */
+function defaultCountKey(node) {
+  if (node.nodeType === 7) return `7|${node.target}`;
+  if (node.nodeType === 1 || node.nodeType === 2) {
+    return `${node.nodeType}|${node.namespaceURI ?? ""}|${node.localName}`;
+  }
+  return String(nodeKind(node));
+}
+
+/**
+ * Whether the numbers of an instruction may be memoized: its patterns must
+ * not depend on variables or on the current node, whose values may differ
+ * between invocations of the same instruction.
+ *
+ * @param {string|null} count - The `count` pattern
+ * @param {string|null} from - The `from` pattern
+ * @returns {boolean} True when counting only depends on the source tree
+ *
+ * @example
+ * isMemoizable("item", null);        // true
+ * isMemoizable("item[@k=$k]", null); // false
+ */
+export function isMemoizable(count, from) {
+  return !/\$|current\s*\(/.test(`${count ?? ""} ${from ?? ""}`);
+}
+
+/**
+ * Count a node's preceding siblings satisfying the predicate, stopping at the
+ * nearest one whose position is memoized.
+ *
+ * @param {Node} node - The (counted) node whose position is computed
+ * @param {(candidate: Node) => boolean} isCounted - Counting predicate
+ * @param {WeakMap<Node, number>|null} positions - Memoized positions
+ * @returns {number} The 1-based position
+ */
+function siblingPosition(node, isCounted, positions) {
+  const own = positions?.get(node);
+  if (own !== undefined) return own;
+
+  let position = 1;
+  for (let sibling = node.previousSibling; sibling;) {
+    const known = positions?.get(sibling);
+    if (known !== undefined) {
+      position += known;
+      break;
+    }
+    if (isCountable(sibling) && isCounted(sibling)) {
+      position++;
+    }
+    sibling = sibling.previousSibling;
+  }
+  positions?.set(node, position);
+  return position;
+}
+
+/**
+ * Whether a node hangs off an element without being its child: an
+ * attribute or a namespace node, whose parent is `ownerElement`.
+ *
+ * @param {Node} node - Any node
+ * @returns {boolean} True for attribute and namespace nodes
+ */
+function isAttachedNode(node) {
+  return node.nodeType === 2 || node.nodeType === 13;
+}
+
+/**
+ * The node before another one in document order (its preceding node or its
+ * parent).
+ *
+ * @param {Node} node - A child node
+ * @returns {Node|null} The previous node, null at the root
+ */
+function previousInDocumentOrder(node) {
+  let previous = node.previousSibling;
+  if (!previous) return node.parentNode;
+  while (previous.lastChild) previous = previous.lastChild;
+  return previous;
+}
+
+/**
+ * Count the ancestors-or-self of a node according to `level="single"` or
+ * `level="multiple"`.
+ *
+ * @param {Node} node - The node being numbered
+ * @param {boolean} multiple - Whether every counted ancestor is numbered
+ * @param {(candidate: Node) => boolean} isCounted - Counting predicate
+ * @param {(candidate: Node) => boolean} isFrom - Boundary predicate
+ * @param {WeakMap<Node, number>|null} positions - Memoized positions
+ * @returns {number[]} Numbers from the outermost ancestor inwards
+ */
+function countAncestors(node, multiple, isCounted, isFrom, positions) {
+  const numbers = [];
+  let current = node;
+
+  while (current && current.nodeType !== 9) {
+    if (isFrom(current)) break;
+    if (isCounted(current)) {
+      numbers.unshift(siblingPosition(current, isCounted, positions));
+      if (!multiple) break;
+    }
+    current = isAttachedNode(current)
+      ? current.ownerElement
+      : current.parentNode;
+  }
+
+  return numbers;
+}
+
+/**
+ * Count a node according to `level="any"`: walk backwards in document order
+ * until a `from` node, the root, or a node whose total is memoized. An
+ * attribute or namespace node counts itself, then its element and the nodes
+ * before it: other attributes are neither preceding nor ancestor nodes (as
+ * in libxslt).
+ *
+ * @param {Node} node - The node being numbered
+ * @param {(candidate: Node) => boolean} isCounted - Counting predicate
+ * @param {(candidate: Node) => boolean} isFrom - Boundary predicate
+ * @param {WeakMap<Node, number>|null} totals - Memoized totals
+ * @returns {number[]} A single number, or an empty list when nothing matches
+ */
+function countAny(node, isCounted, isFrom, totals) {
+  let total = 0;
+  let current = node;
+  if (isAttachedNode(node)) {
+    if (isFrom(node)) return [];
+    if (isCounted(node)) total++;
+    current = node.ownerElement;
+  }
+
+  while (current && current.nodeType !== 9) {
+    const known = totals?.get(current);
+    if (known !== undefined) {
+      total += known;
+      break;
+    }
+    if (isCountable(current)) {
+      if (isFrom(current)) break;
+      if (isCounted(current)) total++;
+    }
+    current = previousInDocumentOrder(current);
+  }
+
+  totals?.set(node, total);
+  return total > 0 ? [total] : [];
+}
+
+/**
+ * The memo tables of one kind of counted node.
+ *
+ * @param {Map<string, {positions: WeakMap, totals: WeakMap}>|null} memo - The instruction's memo
+ * @param {string} key - The counted kind
+ * @returns {{positions: WeakMap, totals: WeakMap}|null} The tables, null without memo
+ */
+function memoTables(memo, key) {
+  if (!memo) return null;
+  let tables = memo.get(key);
+  if (!tables) {
+    tables = { positions: new WeakMap(), totals: new WeakMap() };
+    memo.set(key, tables);
+  }
+  return tables;
+}
+
+/**
+ * Compute the number sequence for an `xsl:number` instruction.
+ *
+ * @param {Node} node - The current node
+ * @param {{level?: string, count?: string|null, from?: string|null}} options - Instruction attributes
+ * @param {(node: Node, pattern: string) => boolean} matcher - XSLT pattern matcher
+ * @param {Map|null} [memo] - Memo of the instruction for the current
+ *   transformation (a Map owned by the caller), or null to count from scratch
+ * @returns {number[]} The computed numbers, outermost first
+ *
+ * @example
+ * countXsltNumber(item, { level: 'any' }, matcher); // [2]
+ */
+export function countXsltNumber(node, options, matcher, memo = null) {
+  const { level = "single", count = null, from = null } = options;
+  const isCounted = count
+    ? (candidate) => matcher(candidate, count)
+    : (candidate) => matchesDefaultCount(candidate, node);
+  const isFrom = from ? (candidate) => matcher(candidate, from) : () => false;
+  const tables = memoTables(memo, count ? "" : defaultCountKey(node));
+
+  if (level === "any") {
+    return countAny(node, isCounted, isFrom, tables?.totals ?? null);
+  }
+  return countAncestors(
+    node,
+    level === "multiple",
+    isCounted,
+    isFrom,
+    tables?.positions ?? null,
+  );
+}