@tradik/xslt-processor 1.0.3 → 1.3.0

package/src/xpath/index.js

@@ -22,12 +22,18 @@ import { XPathEvaluator, XPathContext } from "./evaluator.js";
  *
  * @param {string} expression - XPath expression
  * @param {Node} contextNode - Context node
- * @param {Object} options - Options (variables, namespaces)
+ * @param {Object} options - Options: variables, namespaces, and the
+ *   evaluator limits maxResultSize, maxRecursionDepth and maxStringLength
+ *   (defaults in XPathLimits)
  * @returns {*} Evaluation result
  */
 export function evaluate(expression, contextNode, options = {}) {
   const ast = parse(expression);
-  const evaluator = new XPathEvaluator();
+  const evaluator = new XPathEvaluator({
+    maxResultSize: options.maxResultSize,
+    maxRecursionDepth: options.maxRecursionDepth,
+    maxStringLength: options.maxStringLength,
+  });
   const context = new XPathContext(
     contextNode,
     1,

package/src/xpath/namespaceNodes.js

@@ -0,0 +1,172 @@
+/**
+ * Namespace nodes and the `namespace` axis (XPath 1.0 sections 2.2, 5.4).
+ *
+ * The DOM has no namespace nodes, so they are synthesized: an element has one
+ * namespace node for every namespace binding in scope on it, the implicit
+ * `xml` binding included, and an undeclared default namespace (`xmlns=""`)
+ * has none. Bindings come from `xmlns` attributes of the element and its
+ * ancestors and, for trees built with `createElementNS`, from the prefixes of
+ * the element and attribute names themselves. HTML documents are treated as
+ * libxslt sees them after re-parsing their markup: their elements are in no
+ * namespace, so only explicit `xmlns` attributes (and `xml`) bind prefixes.
+ *
+ * A namespace node looks like a DOM node where the processor reads one:
+ * `nodeType` 13, `localName`/`nodeName` = the prefix ("" for the default
+ * namespace), `namespaceURI` = null (the expanded-name of a namespace node
+ * has a null URI), `nodeValue`/`textContent` = the namespace URI and
+ * `ownerElement` = its parent element. Nodes are created once per element and
+ * cache, so the same binding is the same object: unions deduplicate it and
+ * `generate-id()` is stable. In document order the namespace nodes of an
+ * element follow the element and precede its attributes (section 5).
+ *
+ * @module xpath/namespaceNodes
+ */
+
+"use strict";
+
+/** Node type of a namespace node (the DOM XPath XPathNamespace type). */
+export const NAMESPACE_NODE = 13;
+
+/** Namespace bound to the `xml` prefix (Namespaces in XML 1.0). */
+const XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+
+/** Namespace of `xmlns` and `xmlns:*` attributes. */
+const XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
+
+/**
+ * A synthesized XPath namespace node.
+ */
+export class NamespaceNode {
+  /**
+   * @param {Element} element - The element the node belongs to (its parent)
+   * @param {string} prefix - The bound prefix, "" for the default namespace
+   * @param {string} uri - The namespace URI
+   * @param {number} index - Position among the element's namespace nodes
+   */
+  constructor(element, prefix, uri, index) {
+    this.nodeType = NAMESPACE_NODE;
+    this.ownerElement = element;
+    this.ownerDocument = element.ownerDocument;
+    this.localName = prefix;
+    this.nodeName = prefix;
+    this.namespaceURI = null;
+    this.prefix = null;
+    this.nodeValue = uri;
+    this.textContent = uri;
+    this.index = index;
+    this.parentNode = null;
+    this.firstChild = null;
+    this.lastChild = null;
+    this.previousSibling = null;
+    this.nextSibling = null;
+    this.childNodes = [];
+  }
+}
+
+/**
+ * Whether a node is a synthesized namespace node.
+ *
+ * @param {*} node - Any value
+ * @returns {boolean} True for namespace nodes
+ */
+export function isNamespaceNode(node) {
+  return node?.nodeType === NAMESPACE_NODE;
+}
+
+/**
+ * The prefix declared by an `xmlns` or `xmlns:*` attribute.
+ *
+ * @param {Attr} attr - Any attribute
+ * @returns {string|null} The prefix ("" for `xmlns`), or null for any other attribute
+ */
+function declaredPrefix(attr) {
+  const name = attr.name;
+  if (name === "xmlns") return "";
+  return name.startsWith("xmlns:") ? name.slice(6) : null;
+}
+
+/**
+ * Record the bindings one element contributes, nearest binding first: an
+ * ancestor cannot override what a descendant already bound.
+ *
+ * @param {Element} element - An element on the ancestor-or-self axis
+ * @param {boolean} fromNames - Whether prefixes of element and attribute names count
+ * @param {Map<string, string>} bindings - URIs by prefix, "" marking an undeclared prefix
+ * @returns {void}
+ */
+function addBindings(element, fromNames, bindings) {
+  const bind = (prefix, uri) => {
+    if (prefix !== "xml" && !bindings.has(prefix)) bindings.set(prefix, uri);
+  };
+  for (const attr of element.attributes) {
+    const prefix = declaredPrefix(attr);
+    if (prefix !== null) bind(prefix, attr.value);
+  }
+  if (!fromNames) return;
+  bind(element.prefix ?? "", element.namespaceURI ?? "");
+  for (const attr of element.attributes) {
+    if (attr.prefix && attr.namespaceURI !== XMLNS_NAMESPACE) {
+      bind(attr.prefix, attr.namespaceURI);
+    }
+  }
+}
+
+/**
+ * The namespace bindings in scope on an element, `xml` first.
+ *
+ * @param {Element} element - The element
+ * @returns {Array<[string, string]>} `[prefix, uri]` pairs
+ *
+ * @example
+ * // <r xmlns:a="u"/>
+ * inScopeBindings(r); // [["xml", "http://www.w3.org/XML/1998/namespace"], ["a", "u"]]
+ */
+export function inScopeBindings(element) {
+  const fromNames = element.ownerDocument?.contentType !== "text/html";
+  const bindings = new Map();
+  for (let node = element; node?.nodeType === 1; node = node.parentNode) {
+    addBindings(node, fromNames, bindings);
+  }
+  const result = [["xml", XML_NAMESPACE]];
+  for (const [prefix, uri] of bindings) {
+    if (uri !== "") result.push([prefix, uri]);
+  }
+  return result;
+}
+
+/**
+ * The namespace axis of a node: the namespace nodes of an element, nothing
+ * for any other node. Nodes are cached per element in `cache`, so repeated
+ * evaluations return identical objects.
+ *
+ * @param {Node} node - Context node
+ * @param {WeakMap<Element, NamespaceNode[]>} cache - Namespace nodes by element
+ * @returns {NamespaceNode[]} The namespace nodes, in document order
+ *
+ * @example
+ * namespaceAxis(element, new WeakMap()).map((ns) => ns.localName); // ["xml", "a"]
+ */
+export function namespaceAxis(node, cache) {
+  if (node.nodeType !== 1) return [];
+  let nodes = cache.get(node);
+  if (!nodes) {
+    nodes = inScopeBindings(node).map(
+      ([prefix, uri], index) => new NamespaceNode(node, prefix, uri, index),
+    );
+    cache.set(node, nodes);
+  }
+  return nodes.slice();
+}
+
+/**
+ * Match a name test against a namespace node: its name is the prefix, with a
+ * null namespace URI, so only unprefixed tests can match (section 2.3).
+ *
+ * @param {{name: string, prefix: (string|null)}} nodeTest - Name test AST node
+ * @param {NamespaceNode} node - The namespace node
+ * @returns {boolean} Whether the node matches
+ */
+export function matchNamespaceNameTest(nodeTest, node) {
+  if (nodeTest.prefix) return false;
+  return nodeTest.name === "*" || nodeTest.name === node.localName;
+}

package/src/xpath/nodeSetFunctions.js

@@ -0,0 +1,169 @@
+/**
+ * XPath 1.0 node-set functions (section 4.1), plus `sum()` (4.4) and `lang()`
+ * (4.3), which also take node-sets or walk the tree.
+ *
+ * Functions whose argument must be a node-set raise a type error for any other
+ * value, as libxslt does ("count() expects a node-set"). A single node, which
+ * is how this processor represents a result tree fragment, is accepted as a
+ * node-set of that node: XSLT 1.0 forbids it, but libxslt accepts
+ * `count($rtf)` and stylesheets rely on it.
+ *
+ * @module xpath/nodeSetFunctions
+ */
+
+"use strict";
+
+import { splitXmlSpace } from "./strings.js";
+import { parentOf } from "./axes.js";
+import { NAMESPACE_NODE } from "./namespaceNodes.js";
+
+/** Qualified name of the attribute read by `lang()`. */
+const XML_LANG = "xml:lang";
+
+/**
+ * Whether a node has an expanded name made of a namespace URI and a local
+ * part: elements and attributes (XPath 5.2, 5.3).
+ *
+ * @param {Node} node - Any node
+ * @returns {boolean} True for element and attribute nodes
+ */
+function hasQualifiedName(node) {
+  const type = node.nodeType;
+  return type === 1 || type === 2;
+}
+
+/**
+ * Whether a node has a name without a namespace part: processing
+ * instructions (their target) and namespace nodes (their prefix).
+ *
+ * @param {Node} node - Any node
+ * @returns {boolean} True for processing instruction and namespace nodes
+ */
+function hasLocalNameOnly(node) {
+  const type = node.nodeType;
+  return type === 7 || type === NAMESPACE_NODE;
+}
+
+/**
+ * The element whose `xml:lang` decides the language of a node: the node
+ * itself for an element, the element of an attribute or namespace node, the
+ * parent of any other node.
+ *
+ * @param {Node} node - Context node
+ * @returns {Node|null} The first node to inspect
+ */
+function languageStart(node) {
+  return node.nodeType === 1 ? node : parentOf(node);
+}
+
+/**
+ * Build the node-set functions for an evaluator.
+ *
+ * @param {import('./evaluator.js').XPathEvaluator} evaluator - The evaluator
+ * @returns {Object<string, Function>} Functions by name
+ */
+export function createNodeSetFunctions(evaluator) {
+  /**
+   * Evaluate an argument that must be a node-set.
+   *
+   * @param {string} name - Function name, for the error message
+   * @param {object} arg - Argument expression
+   * @param {import('./evaluator.js').XPathContext} ctx - Evaluation context
+   * @returns {Node[]} The node-set
+   * @throws {TypeError} When the argument is not a node-set
+   */
+  const nodeSetArgument = (name, arg, ctx) => {
+    const value = evaluator.evaluate(arg, ctx);
+    if (Array.isArray(value)) return value;
+    if (value?.nodeType) return [value];
+    throw new TypeError(`${name}() expects a node-set`);
+  };
+
+  /**
+   * The node a name function applies to: the context node without argument,
+   * otherwise the first node of the node-set argument.
+   *
+   * @param {string} name - Function name, for the error message
+   * @param {object[]} args - Argument expressions
+   * @param {import('./evaluator.js').XPathContext} ctx - Evaluation context
+   * @returns {Node|undefined} The node, undefined for an empty node-set
+   */
+  const nameTarget = (name, args, ctx) =>
+    args.length === 0 ? ctx.node : nodeSetArgument(name, args[0], ctx)[0];
+
+  return {
+    count: (args, ctx) => nodeSetArgument("count", args[0], ctx).length,
+
+    /**
+     * `id(object)`: every whitespace separated token of the argument (of the
+     * string value of every node, for a node-set) names an ID; the result is
+     * in document order without duplicates.
+     */
+    id: (args, ctx) => {
+      const value = evaluator.evaluate(args[0], ctx);
+      const strings = Array.isArray(value)
+        ? value.map((node) => evaluator.getStringValue(node))
+        : [evaluator.toString(value)];
+      const doc = ctx.node.ownerDocument || ctx.node;
+      const found = new Set();
+      for (const string of strings) {
+        for (const token of splitXmlSpace(string)) {
+          const element = doc.getElementById(token);
+          if (element) found.add(element);
+        }
+      }
+      return evaluator.sortByDocumentOrder([...found]);
+    },
+
+    "local-name": (args, ctx) => {
+      const node = nameTarget("local-name", args, ctx);
+      if (!node) return "";
+      if (hasQualifiedName(node)) return node.localName;
+      return hasLocalNameOnly(node) ? node.nodeName : "";
+    },
+
+    "namespace-uri": (args, ctx) => {
+      const node = nameTarget("namespace-uri", args, ctx);
+      return node && hasQualifiedName(node) ? node.namespaceURI || "" : "";
+    },
+
+    name: (args, ctx) => {
+      const node = nameTarget("name", args, ctx);
+      if (!node) return "";
+      return hasQualifiedName(node) || hasLocalNameOnly(node)
+        ? node.nodeName
+        : "";
+    },
+
+    sum: (args, ctx) =>
+      nodeSetArgument("sum", args[0], ctx).reduce(
+        (total, node) =>
+          total + evaluator.toNumber(evaluator.getStringValue(node)),
+        0,
+      ),
+
+    /**
+     * `lang(string)`: whether the `xml:lang` of the nearest element at or
+     * above the context node (an attribute or text node looks from its
+     * element) is the language or one of its sublanguages. A plain `lang`
+     * attribute is not `xml:lang` and is ignored.
+     */
+    lang: (args, ctx) => {
+      const wanted = evaluator.toString(evaluator.evaluate(args[0], ctx));
+      const lang = wanted.toLowerCase();
+      for (
+        let node = languageStart(ctx.node);
+        node?.nodeType === 1;
+        node = node.parentNode
+      ) {
+        // The xml prefix is always bound to one namespace, so the qualified
+        // name also finds attributes created without a namespace URI
+        if (node.hasAttribute(XML_LANG)) {
+          const actual = node.getAttribute(XML_LANG).toLowerCase();
+          return actual === lang || actual.startsWith(`${lang}-`);
+        }
+      }
+      return false;
+    },
+  };
+}

package/src/xpath/parser.js

@@ -248,7 +248,7 @@ export class XPathParser {
     }
 
     // Check if this looks like a location path starting with step
-    if (this.isStepStart()) {
+    if (this.isStepStart() && !this.isPrefixedFunctionCall()) {
       return this.parseLocationPath();
     }
 
@@ -505,16 +505,21 @@ export class XPathParser {
       return this.parseFunctionCall();
     }
 
+    // Prefixed function call: the tokenizer emits NAME ':' FUNCTION
+    if (this.isPrefixedFunctionCall()) {
+      const prefix = this.advance().value;
+      this.advance(); // ':'
+      return this.parseFunctionCallArgs(this.advance().value, prefix);
+    }
+
     throw new Error(
       `Unexpected token ${this.peek().type} at position ${this.peek().position}`,
     );
   }
 
   // FunctionCall ::= FunctionName '(' ( Argument ( ',' Argument )* )? ')'
-  // Note: Prefixed function calls (prefix:fn()) are not supported because
-  // the tokenizer identifies functions by NAME followed by '(' - prefixed
-  // names like 'fn:name()' are tokenized as NAME:NAME() which is parsed
-  // as a location path, not a function call.
+  // FunctionName is a QName: an unprefixed name arrives as one FUNCTION
+  // token, a prefixed one as NAME ':' FUNCTION (see isPrefixedFunctionCall).
   parseFunctionCall() {
     const name = this.advance().value;
     return this.parseFunctionCallArgs(name, null);
@@ -537,6 +542,26 @@ export class XPathParser {
   }
 
   // Helper methods
+
+  /**
+   * Whether the next tokens form a prefixed function name, `prefix:name(`.
+   *
+   * The tokenizer classifies the local part as a FUNCTION token (or as a
+   * NODE_TYPE token when it is spelled like one, as in `f:node()`), so
+   * `NAME ':' (FUNCTION | NODE_TYPE)` can only start a function call; a
+   * prefixed name test is `NAME ':' (NAME | '*')`.
+   *
+   * @returns {boolean} True when a prefixed function call follows
+   */
+  isPrefixedFunctionCall() {
+    const next = this.tokens[this.position + 2];
+    return (
+      this.check(TokenType.NAME) &&
+      this.tokens[this.position + 1].type === TokenType.COLON &&
+      (next.type === TokenType.FUNCTION || next.type === TokenType.NODE_TYPE)
+    );
+  }
+
   isStepStart() {
     const type = this.peek().type;
     return (

package/src/xpath/strings.js

@@ -0,0 +1,183 @@
+/**
+ * String and number conversions of the XPath 1.0 data model.
+ *
+ * JavaScript's own conversions are close to XPath's but not equal: `\s` and
+ * `trim()` know Unicode spaces, `Number()` reads exponents, hexadecimal and
+ * `Infinity`, `String()` writes exponents, and string indexes count UTF-16
+ * code units. The helpers here follow the recommendation instead: XML
+ * whitespace only (#x20 #x9 #xD #xA), the Number grammar of section 4.4, the
+ * decimal form of section 4.2 and characters counted as code points.
+ *
+ * @module xpath/strings
+ */
+
+/** A run of XML whitespace characters. */
+const XML_WHITESPACE_RUN = /[ \t\r\n]+/g;
+
+/**
+ * Whether a character is XML whitespace (#x20, #x9, #xD, #xA).
+ *
+ * @param {string} char - A single character
+ * @returns {boolean} True for XML whitespace
+ */
+function isXmlSpace(char) {
+  return char === " " || char === "\t" || char === "\r" || char === "\n";
+}
+
+/**
+ * Strip leading and trailing XML whitespace in linear time (a regular
+ * expression such as `/\s+$/` backtracks quadratically on long runs).
+ *
+ * @param {string} str - Any string
+ * @returns {string} The trimmed string
+ */
+export function trimXmlSpace(str) {
+  let start = 0;
+  let end = str.length;
+  while (start < end && isXmlSpace(str[start])) start++;
+  while (end > start && isXmlSpace(str[end - 1])) end--;
+  return str.slice(start, end);
+}
+
+/** `S? '-'? (Digits ('.' Digits?)? | '.' Digits) S?` (XPath 4.4 number()). */
+const XPATH_NUMBER = /^-?(?:\d+(?:\.\d*)?|\.\d+)$/;
+
+/** Any UTF-16 surrogate code unit. */
+const SURROGATE = /[\uD800-\uDFFF]/;
+
+/**
+ * Strip leading and trailing XML whitespace and collapse inner runs of it to
+ * one space, as `normalize-space()` does.
+ *
+ * @param {string} str - Any string
+ * @returns {string} The normalized string
+ *
+ * @example
+ * normalizeXmlSpace(" a \n b "); // "a b" - a no-break space is kept
+ */
+export function normalizeXmlSpace(str) {
+  return trimXmlSpace(str).replace(XML_WHITESPACE_RUN, " ");
+}
+
+/**
+ * Split a string on XML whitespace, dropping empty tokens.
+ *
+ * @param {string} str - Whitespace separated tokens
+ * @returns {string[]} The tokens
+ */
+export function splitXmlSpace(str) {
+  return str.split(XML_WHITESPACE_RUN).filter((token) => token !== "");
+}
+
+/**
+ * Convert a string to a number following the XPath Number grammar: optional
+ * XML whitespace, an optional minus sign, digits with an optional decimal
+ * point. Anything else, including the empty string, is NaN.
+ *
+ * @param {string} str - The string to convert
+ * @returns {number} The number, or NaN
+ *
+ * @example
+ * parseXPathNumber(" -3.5 "); // -3.5
+ * parseXPathNumber("1e3"); // NaN
+ */
+export function parseXPathNumber(str) {
+  const trimmed = trimXmlSpace(str);
+  if (!XPATH_NUMBER.test(trimmed)) return Number.NaN;
+  return Number(trimmed);
+}
+
+/**
+ * Convert a number to its XPath string form: NaN, Infinity and -Infinity by
+ * name, zero as "0", every other number in decimal notation without an
+ * exponent. The digits are those of `Number#toString`; exponent forms are
+ * rewritten by moving the decimal point in the string, so no floating point
+ * arithmetic can alter them.
+ *
+ * @param {number} value - The number
+ * @returns {string} The string form
+ *
+ * @example
+ * formatXPathNumber(1e21); // "1000000000000000000000"
+ * formatXPathNumber(1e-7); // "0.0000001"
+ */
+export function formatXPathNumber(value) {
+  if (Number.isNaN(value)) return "NaN";
+  if (value === Infinity) return "Infinity";
+  if (value === -Infinity) return "-Infinity";
+  if (value === 0) return "0";
+
+  const text = String(value);
+  const exponentAt = text.indexOf("e");
+  if (exponentAt === -1) return text;
+
+  // Exponent forms are "d.ddde+NN" (|value| >= 1e21) or "d.ddde-N" (< 1e-6)
+  const sign = value < 0 ? "-" : "";
+  const exponent = Number(text.substring(exponentAt + 1));
+  const digits = text.substring(sign.length, exponentAt).replace(".", "");
+
+  if (exponent < 0) {
+    return `${sign}0.${"0".repeat(-exponent - 1)}${digits}`;
+  }
+  return sign + digits + "0".repeat(exponent + 1 - digits.length);
+}
+
+/**
+ * Number of characters (Unicode code points) in a string.
+ *
+ * @param {string} str - Any string
+ * @returns {number} The number of code points
+ */
+export function codePointLength(str) {
+  if (!SURROGATE.test(str)) return str.length;
+  return Array.from(str).length;
+}
+
+/**
+ * XPath `substring()` on code points: the characters whose 1-based position
+ * p satisfies `p >= round(start)` and, with a length, `p < round(start) +
+ * round(length)`. NaN and infinite arguments follow from those comparisons.
+ *
+ * @param {string} str - The string
+ * @param {number} start - Start position, not yet rounded
+ * @param {number} [length] - Number of characters, not yet rounded
+ * @returns {string} The substring
+ *
+ * @example
+ * xpathSubstring("12345", 1.5, 2.6); // "234"
+ */
+export function xpathSubstring(str, start, length) {
+  const first = Math.round(start);
+  const end = length === undefined ? Infinity : first + Math.round(length);
+  const from = Math.max(first, 1);
+  if (Number.isNaN(end) || Number.isNaN(from) || end <= from) return "";
+
+  const chars = SURROGATE.test(str) ? Array.from(str) : null;
+  if (chars === null) return str.slice(from - 1, end - 1);
+  return chars.slice(from - 1, end - 1).join("");
+}
+
+/**
+ * XPath `translate()` on code points: each character of `str` found in
+ * `from` is replaced by the character at the same position in `to`, or
+ * removed when `to` is shorter. The first occurrence in `from` wins.
+ *
+ * @param {string} str - The string to translate
+ * @param {string} from - Characters to replace
+ * @param {string} to - Replacement characters
+ * @returns {string} The translated string
+ */
+export function xpathTranslate(str, from, to) {
+  const fromChars = Array.from(from);
+  const toChars = Array.from(to);
+  let result = "";
+  for (const char of str) {
+    const index = fromChars.indexOf(char);
+    if (index === -1) {
+      result += char;
+    } else if (index < toChars.length) {
+      result += toChars[index];
+    }
+  }
+  return result;
+}