@tradik/xslt-processor 1.1.1 → 1.3.0

package/src/xslt/number.js

@@ -1,178 +1,271 @@
 /**
- * `xsl:number` counting and number-to-string conversion.
+ * `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 any XPath dependency and easy to test in isolation.
+ * 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]);
 
 /**
- * Default `count` pattern behaviour: match nodes of the same type and name.
+ * 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 of the same kind
+ * @returns {boolean} True when the candidate is counted
  */
 function matchesDefaultCount(candidate, node) {
-  if (candidate.nodeType !== node.nodeType) return false;
-  if (candidate.nodeType === 1) return candidate.nodeName === node.nodeName;
-  return true;
+  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;
+  }
 }
 
 /**
- * Build the predicate used to decide whether a node is counted.
+ * 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 node being numbered
- * @param {string|null} count - The `count` pattern, if any
- * @param {(node: Node, pattern: string) => boolean} matcher - Pattern matcher
- * @returns {(candidate: Node) => boolean} The predicate
+ * @param {Node} node - The numbered node
+ * @returns {string} e.g. `1|urn:x|item`
  */
-function createCountPredicate(node, count, matcher) {
-  if (count) return (candidate) => matcher(candidate, count);
-  return (candidate) => matchesDefaultCount(candidate, node);
+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));
 }
 
 /**
- * Build the predicate marking `from` boundaries.
+ * 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} from - The `from` pattern, if any
- * @param {(node: Node, pattern: string) => boolean} matcher - Pattern matcher
- * @returns {(candidate: Node) => boolean} The predicate, always false without `from`
+ * @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
  */
-function createFromPredicate(from, matcher) {
-  if (!from) return () => false;
-  return (candidate) => matcher(candidate, from);
+export function isMemoizable(count, from) {
+  return !/\$|current\s*\(/.test(`${count ?? ""} ${from ?? ""}`);
 }
 
 /**
- * Count preceding siblings of a node that satisfy the predicate.
+ * Count a node's preceding siblings satisfying the predicate, stopping at the
+ * nearest one whose position is memoized.
  *
- * @param {Node} node - The node whose position is computed
+ * @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) {
+function siblingPosition(node, isCounted, positions) {
+  const own = positions?.get(node);
+  if (own !== undefined) return own;
+
   let position = 1;
-  let sibling = node.previousSibling;
-  while (sibling) {
-    if (COUNTABLE_NODE_TYPES.has(sibling.nodeType) && isCounted(sibling)) {
+  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;
 }
 
 /**
- * Collect nodes in document order up to and including a target node.
+ * Whether a node hangs off an element without being its child: an
+ * attribute or a namespace node, whose parent is `ownerElement`.
  *
- * @param {Node} target - The node at which traversal stops
- * @returns {Node[]} Nodes in document order, ending with the target
+ * @param {Node} node - Any node
+ * @returns {boolean} True for attribute and namespace nodes
  */
-function nodesUpToTarget(target) {
-  const root = target.ownerDocument || target;
-  const result = [];
-  const stack = [root];
-
-  while (stack.length > 0) {
-    const current = stack.pop();
-    result.push(current);
-    if (current === target) break;
-    const children = current.childNodes;
-    if (children) {
-      for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]);
-    }
-  }
-
-  return result;
+function isAttachedNode(node) {
+  return node.nodeType === 2 || node.nodeType === 13;
 }
 
 /**
- * Count a node according to `level="single"`.
+ * The node before another one in document order (its preceding node or its
+ * parent).
  *
- * @param {Node} node - The node being numbered
- * @param {(candidate: Node) => boolean} isCounted - Counting predicate
- * @param {(candidate: Node) => boolean} isFrom - Boundary predicate
- * @returns {number[]} A single number, or an empty list when nothing matches
+ * @param {Node} node - A child node
+ * @returns {Node|null} The previous node, null at the root
  */
-function countSingle(node, isCounted, isFrom) {
-  let current = node;
-  while (current && current.nodeType !== 9) {
-    if (isFrom(current)) return [];
-    if (isCounted(current)) return [siblingPosition(current, isCounted)];
-    current = current.parentNode;
-  }
-  return [];
+function previousInDocumentOrder(node) {
+  let previous = node.previousSibling;
+  if (!previous) return node.parentNode;
+  while (previous.lastChild) previous = previous.lastChild;
+  return previous;
 }
 
 /**
- * Count a node according to `level="multiple"`.
+ * 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 countMultiple(node, isCounted, isFrom) {
+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));
+      numbers.unshift(siblingPosition(current, isCounted, positions));
+      if (!multiple) break;
     }
-    current = current.parentNode;
+    current = isAttachedNode(current)
+      ? current.ownerElement
+      : current.parentNode;
   }
 
   return numbers;
 }
 
 /**
- * Count a node according to `level="any"`.
+ * 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) {
+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;
+  }
 
-  for (const candidate of nodesUpToTarget(node)) {
-    if (!COUNTABLE_NODE_TYPES.has(candidate.nodeType)) continue;
-    if (isFrom(candidate)) {
-      total = 0;
-      continue;
+  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++;
     }
-    if (isCounted(candidate)) 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) {
+export function countXsltNumber(node, options, matcher, memo = null) {
   const { level = "single", count = null, from = null } = options;
-  const isCounted = createCountPredicate(node, count, matcher);
-  const isFrom = createFromPredicate(from, matcher);
+  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);
-  if (level === "multiple") return countMultiple(node, isCounted, isFrom);
-  return countSingle(node, isCounted, isFrom);
+  if (level === "any") {
+    return countAny(node, isCounted, isFrom, tables?.totals ?? null);
+  }
+  return countAncestors(
+    node,
+    level === "multiple",
+    isCounted,
+    isFrom,
+    tables?.positions ?? null,
+  );
 }

package/src/xslt/numberFormat.js

@@ -2,9 +2,15 @@
  * `xsl:number` number-to-string conversion.
  *
  * Renders the number sequence produced by {@link countXsltNumber} using the
- * `format` attribute of `xsl:number`: numeric tokens (`1`, `01`), alphabetic
- * tokens (`a`, `A`) and Roman numerals (`i`, `I`), together with the prefix,
- * separators and suffix taken from the format string itself.
+ * `format` attribute of `xsl:number`: numeric tokens (`1`, `01`, and the
+ * same in any Unicode digit family, e.g. `٠١`), alphabetic tokens (`a`, `A`)
+ * and Roman numerals (`i`, `I`), together with the prefix, separators and
+ * suffix taken from the format string itself.
+ *
+ * Extreme values follow libxslt: a negative number is formatted as 0, NaN
+ * and Infinity as by `string()`, alphabetic and Roman tokens use decimals
+ * below 1 (and Roman ones above 5000), and every conversion takes O(log n)
+ * steps, so a huge value cannot stall the transformation.
  */
 
 "use strict";
@@ -46,6 +52,9 @@ const ROMAN_NUMERALS = Object.freeze([
   ["I", 1],
 ]);
 
+/** Largest number written with Roman numerals, as in libxslt. */
+const MAX_ROMAN = 5000;
+
 /**
  * Convert a positive integer to a Roman numeral.
  *
@@ -60,41 +69,124 @@ export function toRoman(value) {
   let result = "";
 
   for (const [numeral, amount] of ROMAN_NUMERALS) {
-    while (remaining >= amount) {
-      result += numeral;
-      remaining -= amount;
-    }
+    result += numeral.repeat(Math.floor(remaining / amount));
+    remaining %= amount;
   }
 
   return result;
 }
 
+/**
+ * Insert a grouping separator every `size` digits, counting from the right.
+ *
+ * @param {string} digits - The decimal digits
+ * @param {{separator?: string, size?: number}} grouping - The grouping settings
+ * @returns {string} The grouped digits
+ */
+function groupDigits(digits, { separator, size }) {
+  if (!separator || Number.isNaN(size) || size <= 0) return digits;
+
+  let result = "";
+  for (let end = digits.length; end > 0; end -= size) {
+    const group = digits.slice(Math.max(0, end - size), end);
+    result = result ? `${group}${separator}${result}` : group;
+  }
+  return result;
+}
+
+/** A Unicode decimal digit (general category Nd). */
+const DECIMAL_DIGIT = /^\p{Nd}$/u;
+
+/**
+ * Whether a code point is a Unicode decimal digit.
+ *
+ * @param {number} codePoint - Any code point
+ * @returns {boolean} True for characters of category Nd
+ */
+function isDecimalDigit(codePoint) {
+  return DECIMAL_DIGIT.test(String.fromCodePoint(codePoint));
+}
+
+/**
+ * The zero of the digit family of a decimal format token: a token whose
+ * last character has the digit value 1 and whose other characters are the
+ * zero of that family (XSLT 1.0 section 7.7.1), e.g. `1`, `01`, `٠١`.
+ * Digit families are runs of ten code points, which may follow each other
+ * (the mathematical digits), so the value is counted from the run start.
+ *
+ * @param {string} token - A format token
+ * @returns {number|null} The code point of the family's zero, or null
+ */
+function decimalTokenZero(token) {
+  const digits = Array.from(token, (char) => char.codePointAt(0));
+  const one = digits.at(-1);
+  if (!isDecimalDigit(one)) return null;
+  let start = one;
+  while (isDecimalDigit(start - 1)) start--;
+  const zero = one - 1;
+  if ((one - start) % 10 !== 1) return null;
+  return digits.slice(0, -1).every((digit) => digit === zero) ? zero : null;
+}
+
+/**
+ * The decimal digits of a non-negative integer, without exponent notation.
+ *
+ * @param {number} value - A finite, non-negative integer
+ * @returns {string} Its ASCII decimal digits
+ */
+function decimalDigits(value) {
+  return Number.isSafeInteger(value) ? String(value) : BigInt(value).toString();
+}
+
+/**
+ * Write a number with decimal digits of a family, padded with zeros to a
+ * minimum width and grouped.
+ *
+ * @param {number} value - A finite, non-negative integer
+ * @param {number} zero - Code point of the family's zero
+ * @param {number} width - Minimum number of digits
+ * @param {{separator?: string, size?: number}} grouping - Digit grouping
+ * @returns {string} The rendered number
+ */
+function formatDecimal(value, zero, width, grouping) {
+  const ascii = decimalDigits(value).padStart(width, "0");
+  const digits =
+    zero === 0x30
+      ? ascii
+      : Array.from(ascii, (digit) =>
+          String.fromCodePoint(zero + Number(digit)),
+        ).join("");
+  return groupDigits(digits, grouping);
+}
+
 /**
  * Render one number with a single `xsl:number` format token.
  *
  * @param {number} value - The number to render
  * @param {string} token - The format token, e.g. `1`, `01`, `a`, `I`
+ * @param {{separator?: string, size?: number}} grouping - Digit grouping
  * @returns {string} The rendered number
  */
-function formatToken(value, token) {
+function formatToken(value, token, grouping) {
+  if (Number.isNaN(value) || value === Infinity) return String(value);
+  // Negative numbers are an error that libxslt recovers from with 0
+  const number = value < 0 ? 0 : Math.round(value);
+
   if (/^\d+$/.test(token)) {
-    return String(value).padStart(token.length, "0");
+    return formatDecimal(number, 0x30, token.length, grouping);
+  }
+  const zero = decimalTokenZero(token);
+  if (zero !== null) {
+    return formatDecimal(number, zero, Array.from(token).length, grouping);
   }
 
-  if (value <= 0) return String(value);
-
-  switch (token) {
-    case "a":
-      return toAlphabetic(value, false);
-    case "A":
-      return toAlphabetic(value, true);
-    case "i":
-      return toRoman(value).toLowerCase();
-    case "I":
-      return toRoman(value);
-    default:
-      return String(value);
+  const alphabetic = token === "a" || token === "A";
+  const roman = token === "i" || token === "I";
+  if (number < 1 || (roman && number > MAX_ROMAN) || (!alphabetic && !roman)) {
+    return decimalDigits(number);
   }
+  if (alphabetic) return toAlphabetic(number, token === "A");
+  return token === "I" ? toRoman(number) : toRoman(number).toLowerCase();
 }
 
 /**
@@ -104,8 +196,8 @@ function formatToken(value, token) {
  * @returns {{prefix: string, suffix: string, tokens: string[], separators: string[]}} The parsed format
  */
 function parseFormat(format) {
-  const parts = format.match(/[a-zA-Z0-9]+|[^a-zA-Z0-9]+/g) || [];
-  const isToken = (part) => /^[a-zA-Z0-9]+$/.test(part);
+  const parts = format.match(/[\p{L}\p{N}]+|[^\p{L}\p{N}]+/gu) || [];
+  const isToken = (part) => /^[\p{L}\p{N}]+$/u.test(part);
 
   const tokens = [];
   const separators = [];
@@ -130,14 +222,20 @@ function parseFormat(format) {
 /**
  * Format a number sequence produced by {@link countXsltNumber}.
  *
+ * Decimal tokens are grouped when both `grouping.separator` and a positive
+ * `grouping.size` are given (the `grouping-separator` and `grouping-size`
+ * attributes).
+ *
  * @param {number[]} numbers - The numbers, outermost first
  * @param {string} [format] - The `format` attribute value
+ * @param {{separator?: string, size?: number}} [grouping] - Digit grouping
  * @returns {string} The formatted string, empty when there is nothing to number
  *
  * @example
  * formatXsltNumber([2, 3], '1.1'); // '2.3'
+ * formatXsltNumber([1234567], '1', { separator: ',', size: 3 }); // '1,234,567'
  */
-export function formatXsltNumber(numbers, format = "1") {
+export function formatXsltNumber(numbers, format = "1", grouping = {}) {
   if (numbers.length === 0) return "";
 
   const { prefix, suffix, tokens, separators } = parseFormat(format);
@@ -148,7 +246,7 @@ export function formatXsltNumber(numbers, format = "1") {
       const separator = separators[index - 1] ?? separators.at(-1) ?? ".";
       result += separator;
     }
-    result += formatToken(value, tokens[index] ?? tokens.at(-1));
+    result += formatToken(value, tokens[index] ?? tokens.at(-1), grouping);
   });
 
   return result + suffix;

package/src/xslt/outputNames.js

@@ -0,0 +1,58 @@
+/**
+ * QName-valued attributes of `xsl:output` (XSLT 1.0 section 16).
+ *
+ * `cdata-section-elements` lists QNames that are expanded with the namespace
+ * declarations in scope on the `xsl:output` element, the default namespace
+ * included for unprefixed names (section 16.1). The serializer then compares
+ * expanded names, so the prefixes used in the result do not matter.
+ *
+ * @module xslt/outputNames
+ */
+
+"use strict";
+
+import { isQName } from "./qname.js";
+import { splitQName } from "./resultNamespaces.js";
+import { resolvePrefix } from "./stylesheetNamespaces.js";
+
+/**
+ * @typedef {{namespaceUri: (string|null), localName: string}} ExpandedName
+ */
+
+/**
+ * Expand the QNames of a `cdata-section-elements` attribute and add them to
+ * the names already declared (several xsl:output elements are merged, so the
+ * lists are united). Invalid names and undeclared prefixes are reported and
+ * skipped.
+ *
+ * @param {string} value - Whitespace separated QNames
+ * @param {Object<string, string>} scope - Namespaces in scope on xsl:output
+ * @param {ExpandedName[]} declared - Names declared by earlier xsl:output elements
+ * @param {(message: string) => void} warn - Reports a name that is skipped
+ * @returns {ExpandedName[]} The union, without duplicates
+ *
+ * @example
+ * cdataSectionNames("p:c d", { p: "urn:p" }, [], console.warn);
+ * // [{ namespaceUri: "urn:p", localName: "c" },
+ * //  { namespaceUri: null, localName: "d" }]
+ */
+export function cdataSectionNames(value, scope, declared, warn) {
+  const names = [...declared];
+  const seen = new Set(names.map((n) => `{${n.namespaceUri}}${n.localName}`));
+
+  for (const qname of value.split(/[ \t\r\n]+/).filter(Boolean)) {
+    const { prefix, localName } = splitQName(qname);
+    const namespaceUri = resolvePrefix(scope, prefix);
+    if (!isQName(qname) || (prefix && !namespaceUri)) {
+      warn(
+        `xsl:output cdata-section-elements: "${qname}" is not a QName with a declared prefix and is ignored`,
+      );
+      continue;
+    }
+    const key = `{${namespaceUri}}${localName}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    names.push({ namespaceUri, localName });
+  }
+  return names;
+}