@tradik/xslt-processor 1.1.1 → 1.3.0

package/src/xslt/functions.js

@@ -1,9 +1,12 @@
 /**
  * XSLT-defined XPath functions.
  *
- * XSLT 1.0 section 12 adds functions to the XPath function library. They live
- * here rather than in `src/xpath` so that module stays a pure XPath 1.0
- * implementation; the engine registers this map on its evaluator through
+ * XSLT 1.0 section 12 adds functions to the XPath function library, and the
+ * EXSLT `node-set()` extension (also under the msxsl namespace) is registered
+ * by expanded name next to them, together with the other EXSLT functions of
+ * `./exslt/index.js`. They live here rather than in `src/xpath` so
+ * that module stays a pure XPath 1.0 implementation; the engine registers this
+ * map on its evaluator through
  * {@link XPathEvaluator#registerFunctions}.
  */
 
@@ -11,6 +14,18 @@
 
 import { formatNumber, DEFAULT_DECIMAL_FORMAT } from "./formatNumber.js";
 import { isXsltElementAvailable, XSLT_NAMESPACE } from "./elements.js";
+import {
+  expandedFunctionName,
+  resolveNamespacePrefix,
+} from "../xpath/evaluator.js";
+import { rootNodeOf } from "../xpath/axes.js";
+import { EXSLT_COMMON, createExsltFunctions } from "./exslt/index.js";
+
+/** Namespace of the EXSLT common module (`exsl:node-set()`). */
+export const EXSLT_COMMON_NAMESPACE = EXSLT_COMMON;
+
+/** Namespace of the MSXML extension functions (`msxsl:node-set()`). */
+export const MSXSL_NAMESPACE = "urn:schemas-microsoft-com:xslt";
 
 /** Vendor identification reported by `system-property()`. */
 export const VENDOR = "@tradik/xslt-processor";
@@ -72,6 +87,29 @@ function splitQName(qname) {
   };
 }
 
+/**
+ * Expanded name key of the decimal format named by the third argument of
+ * `format-number()`, with the prefix resolved in the expression's scope
+ * (XSLT 1.0 section 12.3); the table is keyed the same way (see
+ * declarationNames.js).
+ *
+ * @param {string} qname - The decimal format QName
+ * @param {{namespaces: Object<string, string>}} ctx - The XPath context
+ * @returns {string} `{uri}local`, or the local name in no namespace
+ * @throws {Error} When the prefix is not declared
+ */
+function decimalFormatKey(qname, ctx) {
+  const { prefix, localName } = splitQName(qname);
+  if (prefix === null) return localName;
+  const namespaceUri = resolveNamespacePrefix(prefix, ctx.namespaces);
+  if (!namespaceUri) {
+    throw new Error(
+      `format-number(): undeclared namespace prefix "${prefix}" in "${qname}"`,
+    );
+  }
+  return `{${namespaceUri}}${localName}`;
+}
+
 /**
  * Build the XSLT function map for an engine.
  *
@@ -96,7 +134,30 @@ export function createXsltFunctions(engine) {
   const evaluate = (arg, ctx) => evaluator.evaluate(arg, ctx);
   const asString = (arg, ctx) => stringify(evaluate(arg, ctx));
 
+  /**
+   * `exsl:node-set(object)` - EXSLT common, also known as `msxsl:node-set()`.
+   *
+   * A result tree fragment (a DocumentFragment in this engine) becomes a
+   * node-set holding its root node, so `exsl:node-set($rtf)/item` selects the
+   * fragment's top-level `item` elements. A node-set is returned unchanged; any
+   * other value becomes a node-set holding one text node with its string value.
+   *
+   * @param {Array} args - Argument expressions
+   * @param {import('../xpath/evaluator.js').XPathContext} ctx - Evaluation context
+   * @returns {Node[]} The node-set
+   */
+  const nodeSet = (args, ctx) => {
+    const value = evaluate(args[0], ctx);
+    if (Array.isArray(value)) return value;
+    if (value?.nodeType) return [value];
+    return [ownerDocumentOf(ctx.node).createTextNode(stringify(value))];
+  };
+
   return {
+    ...createExsltFunctions(engine),
+    [expandedFunctionName(EXSLT_COMMON_NAMESPACE, "node-set")]: nodeSet,
+    [expandedFunctionName(MSXSL_NAMESPACE, "node-set")]: nodeSet,
+
     /**
      * `document(object, base?)` - load external XML documents.
      *
@@ -117,18 +178,23 @@ export function createXsltFunctions(engine) {
       return result;
     },
 
-    /** `key(name, value)` - look up nodes through an `xsl:key` index. */
+    /**
+     * `key(name, value)` - look up nodes through an `xsl:key` index of the
+     * tree containing the context node: its document, or the fragment of a
+     * result tree fragment converted with `exsl:node-set()`.
+     */
     key: (args, ctx) => {
       const name = asString(args[0], ctx);
       const values = toStringList(evaluator, stringify, evaluate(args[1], ctx));
-      return engine.keyRegistry.lookup(name, values, ownerDocumentOf(ctx.node));
+      return engine.keyRegistry.lookup(name, values, rootNodeOf(ctx.node));
     },
 
     /** `format-number(number, pattern, decimalFormat?)`. */
     "format-number": (args, ctx) => {
       const value = evaluator.toNumber(evaluate(args[0], ctx));
       const pattern = asString(args[1], ctx);
-      const formatName = args.length > 2 ? asString(args[2], ctx) : "";
+      const formatName =
+        args.length > 2 ? decimalFormatKey(asString(args[2], ctx), ctx) : "";
       const format =
         engine.decimalFormats[formatName] || DEFAULT_DECIMAL_FORMAT;
       return formatNumber(value, pattern, format);
@@ -160,22 +226,35 @@ export function createXsltFunctions(engine) {
         : "";
     },
 
-    /** `function-available(name)` - reflects the evaluator function table. */
+    /**
+     * `function-available(name)` - reflects the evaluator function table. A
+     * prefixed name is resolved through the stylesheet's namespace bindings,
+     * just as a call of that function would be. A function can report itself
+     * unavailable through an `isAvailable()` property (`dyn:evaluate()` does
+     * until the engine enables it).
+     */
     "function-available": (args, ctx) => {
-      const name = asString(args[0], ctx);
-      return Object.hasOwn(evaluator.functions, name);
+      const { prefix, localName } = splitQName(asString(args[0], ctx));
+      const fn = evaluator.resolveFunction(localName, prefix, ctx.namespaces);
+      return fn !== null && fn.isAvailable?.() !== false;
     },
 
     /** `element-available(name)` - reflects the XSLT elements the engine runs. */
     "element-available": (args, ctx) => {
       const { prefix, localName } = splitQName(asString(args[0], ctx));
-      if (!prefix) return false;
+      // An unprefixed name is in the default namespace (XSLT 1.0 section
+      // 15), which may be the XSLT namespace itself (libxslt bug-200)
+      const namespaceUri = prefix
+        ? (ctx.namespaces[prefix] ?? (prefix === "xsl" ? XSLT_NAMESPACE : null))
+        : ctx.namespaces[""] || null;
+      if (!namespaceUri) return false;
 
-      const namespaceUri =
-        ctx.namespaces[prefix] ?? (prefix === "xsl" ? XSLT_NAMESPACE : null);
-
-      return (
-        namespaceUri === XSLT_NAMESPACE && isXsltElementAvailable(localName)
+      if (namespaceUri === XSLT_NAMESPACE) {
+        return isXsltElementAvailable(localName);
+      }
+      // Extension elements with an implementation (registerExtensionElement)
+      return Boolean(
+        engine.extensionElements?.has(`{${namespaceUri}}${localName}`),
       );
     },
 

package/src/xslt/index.js

@@ -3,7 +3,13 @@
  * Based on W3C XSLT 1.0 Specification: http://www.w3.org/TR/1999/REC-xslt-19991116
  */
 
-export { XsltContext, XsltEngine } from "./engine.js";
+export {
+  XSLT_MAX_EXPRESSION_DEPTH,
+  XSLT_MAX_RESULT_SIZE,
+  XSLT_MAX_TEMPLATE_DEPTH,
+  XsltContext,
+  XsltEngine,
+} from "./engine.js";
 
 // XSLT vocabulary and function library (advanced usage)
 export {

package/src/xslt/keys.js

@@ -1,8 +1,10 @@
 /**
  * `xsl:key` indexing for the XSLT `key()` function.
  *
- * Indexes are built lazily, once per (document, key name) pair, and cached in a
- * `WeakMap` so source documents stay garbage collectable. The registry is
+ * Indexes are built lazily, once per (root node, key name) pair, and cached in
+ * a `WeakMap` so source documents stay garbage collectable. The root node is
+ * the document of the context node, or the DocumentFragment of a result tree
+ * fragment converted with `exsl:node-set()` (see `rootNodeOf` in xpath/axes). The registry is
  * deliberately decoupled from the engine: pattern matching and `use` evaluation
  * are injected as callbacks.
  */
@@ -10,14 +12,27 @@
 "use strict";
 
 /**
- * Lazily built, per-document indexes for all declared keys.
+ * @typedef {Object} KeyDefinition
+ * @property {string} match - Pattern of the nodes to index
+ * @property {string} use - Expression computing the key values
+ * @property {Object<string, string>} [namespaces] - Prefixes in scope on the xsl:key element
+ */
+
+/**
+ * @typedef {Object} KeyIndex
+ * @property {Map<string, Node[]>} buckets - Key value to nodes, in document order
+ * @property {Map<Node, number>} order - Document order position of every node
+ */
+
+/**
+ * Lazily built, per-tree indexes for all declared keys.
  */
 export class KeyIndexRegistry {
   /**
    * @param {Object} options - Registry configuration
-   * @param {Object<string, {match: string, use: string}>} options.keys - Declared keys by name
-   * @param {(node: Node, pattern: string) => boolean} options.matchesPattern - XSLT pattern matcher
-   * @param {(node: Node, expression: string) => string[]} options.evaluateUse - `use` evaluator returning key values
+   * @param {Object<string, (KeyDefinition|KeyDefinition[])>} options.keys - Declared keys by name; several xsl:key elements may share a name
+   * @param {(node: Node, pattern: string, definition: KeyDefinition) => boolean} options.matchesPattern - XSLT pattern matcher
+   * @param {(node: Node, expression: string, definition: KeyDefinition) => string[]} options.evaluateUse - `use` evaluator returning key values
    */
   constructor({ keys, matchesPattern, evaluateUse }) {
     this.keys = keys;
@@ -43,7 +58,7 @@ export class KeyIndexRegistry {
    *
    * @param {string} name - The key name
    * @param {string|string[]} values - One key value, or several to union
-   * @param {Document} doc - The document to search
+   * @param {Node} doc - Root of the tree to search (Document or DocumentFragment)
    * @returns {Node[]} Matching nodes in document order, without duplicates
    * @throws {Error} When the key name was never declared
    *
@@ -55,25 +70,23 @@ export class KeyIndexRegistry {
       throw new Error(`Undefined key: ${name}`);
     }
 
-    const index = this.getIndex(name, doc);
+    const { buckets, order } = this.getIndex(name, doc);
     const wanted = Array.isArray(values) ? values : [values];
-    const result = [];
+    if (wanted.length === 1) return [...(buckets.get(wanted[0]) || [])];
 
+    const found = new Set();
     for (const value of wanted) {
-      for (const node of index.get(value) || []) {
-        if (!result.includes(node)) result.push(node);
-      }
+      for (const node of buckets.get(value) || []) found.add(node);
     }
-
-    return result;
+    return [...found].sort((a, b) => order.get(a) - order.get(b));
   }
 
   /**
    * Get (building if needed) the index of one key for one document.
    *
    * @param {string} name - The key name
-   * @param {Document} doc - The document being indexed
-   * @returns {Map<string, Node[]>} Key value to nodes
+   * @param {Node} doc - Root of the tree being indexed
+   * @returns {KeyIndex} The index
    */
   getIndex(name, doc) {
     let byName = this.cache.get(doc);
@@ -92,27 +105,37 @@ export class KeyIndexRegistry {
   }
 
   /**
-   * Build the index of one key for one document.
+   * Build the index of one key for one document, merging every declaration
+   * of that key name.
    *
    * @param {string} name - The key name
-   * @param {Document} doc - The document being indexed
-   * @returns {Map<string, Node[]>} Key value to nodes
+   * @param {Node} doc - Root of the tree being indexed
+   * @returns {KeyIndex} The index
    */
   buildIndex(name, doc) {
-    const { match, use } = this.keys[name];
-    const index = new Map();
+    const definitions = [this.keys[name]].flat();
+    const buckets = new Map();
+    const order = new Map();
 
     for (const node of documentOrderNodes(doc)) {
-      if (!this.matchesPattern(node, match)) continue;
-
-      for (const value of this.evaluateUse(node, use)) {
-        const bucket = index.get(value);
-        if (bucket) bucket.push(node);
-        else index.set(value, [node]);
+      order.set(node, order.size);
+
+      for (const definition of definitions) {
+        if (!this.matchesPattern(node, definition.match, definition)) continue;
+
+        for (const value of this.evaluateUse(
+          node,
+          definition.use,
+          definition,
+        )) {
+          const bucket = buckets.get(value);
+          if (!bucket) buckets.set(value, [node]);
+          else if (bucket[bucket.length - 1] !== node) bucket.push(node);
+        }
       }
     }
 
-    return index;
+    return { buckets, order };
   }
 }
 

package/src/xslt/literalResult.js

@@ -42,10 +42,20 @@ export function lookupNamespaceUri(node, prefix) {
 
 /**
  * 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;
   }
 
   /**
@@ -62,22 +72,22 @@ export class NamespaceAliasMap {
     const resultPrefix = node.getAttribute("result-prefix");
     if (!stylesheetPrefix || !resultPrefix) return;
 
+    const isDefaultSource = stylesheetPrefix === "#default";
     const fromUri = lookupNamespaceUri(
       node,
-      stylesheetPrefix === "#default" ? null : stylesheetPrefix,
+      isDefaultSource ? null : stylesheetPrefix,
     );
-    if (!fromUri) return;
+    if (!fromUri && !isDefaultSource) return;
 
     const isDefaultResult = resultPrefix === "#default";
     const toUri = lookupNamespaceUri(
       node,
       isDefaultResult ? null : resultPrefix,
     );
+    const alias = { uri: toUri, prefix: isDefaultResult ? null : resultPrefix };
 
-    this.byUri.set(fromUri, {
-      uri: toUri,
-      prefix: isDefaultResult ? null : resultPrefix,
-    });
+    if (fromUri) this.byUri.set(fromUri, alias);
+    else if (toUri) this.noNamespaceAlias = alias;
   }
 
   /**
@@ -89,7 +99,20 @@ export class NamespaceAliasMap {
    * aliases.isEmpty();
    */
   isEmpty() {
-    return this.byUri.size === 0;
+    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);
   }
 
   /**
@@ -112,6 +135,39 @@ export class NamespaceAliasMap {
       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,
+    };
+  }
 }
 
 /**

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,
+    );
+  }
+}