@tradik/xslt-processor 1.0.2 → 1.1.1

package/src/xslt/literalResult.js

@@ -0,0 +1,167 @@
+/**
+ * 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.
+ */
+export class NamespaceAliasMap {
+  constructor() {
+    this.byUri = new Map();
+  }
+
+  /**
+   * 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 fromUri = lookupNamespaceUri(
+      node,
+      stylesheetPrefix === "#default" ? null : stylesheetPrefix,
+    );
+    if (!fromUri) return;
+
+    const isDefaultResult = resultPrefix === "#default";
+    const toUri = lookupNamespaceUri(
+      node,
+      isDefaultResult ? null : resultPrefix,
+    );
+
+    this.byUri.set(fromUri, {
+      uri: toUri,
+      prefix: isDefaultResult ? null : resultPrefix,
+    });
+  }
+
+  /**
+   * Whether any alias was declared.
+   *
+   * @returns {boolean} True when at least one alias is known
+   *
+   * @example
+   * aliases.isEmpty();
+   */
+  isEmpty() {
+    return this.byUri.size === 0;
+  }
+
+  /**
+   * 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,
+    };
+  }
+}
+
+/**
+ * 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/number.js

@@ -0,0 +1,178 @@
+/**
+ * `xsl:number` counting and number-to-string conversion.
+ *
+ * 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.
+ */
+
+"use strict";
+
+/** 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.
+ *
+ * @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
+ */
+function matchesDefaultCount(candidate, node) {
+  if (candidate.nodeType !== node.nodeType) return false;
+  if (candidate.nodeType === 1) return candidate.nodeName === node.nodeName;
+  return true;
+}
+
+/**
+ * Build the predicate used to decide whether a node is counted.
+ *
+ * @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
+ */
+function createCountPredicate(node, count, matcher) {
+  if (count) return (candidate) => matcher(candidate, count);
+  return (candidate) => matchesDefaultCount(candidate, node);
+}
+
+/**
+ * Build the predicate marking `from` boundaries.
+ *
+ * @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`
+ */
+function createFromPredicate(from, matcher) {
+  if (!from) return () => false;
+  return (candidate) => matcher(candidate, from);
+}
+
+/**
+ * Count preceding siblings of a node that satisfy the predicate.
+ *
+ * @param {Node} node - The node whose position is computed
+ * @param {(candidate: Node) => boolean} isCounted - Counting predicate
+ * @returns {number} The 1-based position
+ */
+function siblingPosition(node, isCounted) {
+  let position = 1;
+  let sibling = node.previousSibling;
+  while (sibling) {
+    if (COUNTABLE_NODE_TYPES.has(sibling.nodeType) && isCounted(sibling)) {
+      position++;
+    }
+    sibling = sibling.previousSibling;
+  }
+  return position;
+}
+
+/**
+ * Collect nodes in document order up to and including a target node.
+ *
+ * @param {Node} target - The node at which traversal stops
+ * @returns {Node[]} Nodes in document order, ending with the target
+ */
+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;
+}
+
+/**
+ * Count a node according to `level="single"`.
+ *
+ * @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
+ */
+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 [];
+}
+
+/**
+ * Count a node according to `level="multiple"`.
+ *
+ * @param {Node} node - The node being numbered
+ * @param {(candidate: Node) => boolean} isCounted - Counting predicate
+ * @param {(candidate: Node) => boolean} isFrom - Boundary predicate
+ * @returns {number[]} Numbers from the outermost ancestor inwards
+ */
+function countMultiple(node, isCounted, isFrom) {
+  const numbers = [];
+  let current = node;
+
+  while (current && current.nodeType !== 9) {
+    if (isFrom(current)) break;
+    if (isCounted(current)) {
+      numbers.unshift(siblingPosition(current, isCounted));
+    }
+    current = current.parentNode;
+  }
+
+  return numbers;
+}
+
+/**
+ * Count a node according to `level="any"`.
+ *
+ * @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
+ */
+function countAny(node, isCounted, isFrom) {
+  let total = 0;
+
+  for (const candidate of nodesUpToTarget(node)) {
+    if (!COUNTABLE_NODE_TYPES.has(candidate.nodeType)) continue;
+    if (isFrom(candidate)) {
+      total = 0;
+      continue;
+    }
+    if (isCounted(candidate)) total++;
+  }
+
+  return total > 0 ? [total] : [];
+}
+
+/**
+ * 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
+ * @returns {number[]} The computed numbers, outermost first
+ *
+ * @example
+ * countXsltNumber(item, { level: 'any' }, matcher); // [2]
+ */
+export function countXsltNumber(node, options, matcher) {
+  const { level = "single", count = null, from = null } = options;
+  const isCounted = createCountPredicate(node, count, matcher);
+  const isFrom = createFromPredicate(from, matcher);
+
+  if (level === "any") return countAny(node, isCounted, isFrom);
+  if (level === "multiple") return countMultiple(node, isCounted, isFrom);
+  return countSingle(node, isCounted, isFrom);
+}

package/src/xslt/numberFormat.js

@@ -0,0 +1,155 @@
+/**
+ * `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.
+ */
+
+"use strict";
+
+/**
+ * Convert a positive integer to a bijective base-26 alphabetic sequence.
+ *
+ * @param {number} value - The number to convert
+ * @param {boolean} upperCase - Whether to emit upper case letters
+ * @returns {string} The alphabetic representation, e.g. `27` becomes `aa`
+ */
+function toAlphabetic(value, upperCase) {
+  let remaining = value;
+  let result = "";
+
+  while (remaining > 0) {
+    const index = (remaining - 1) % 26;
+    result = String.fromCodePoint((upperCase ? 65 : 97) + index) + result;
+    remaining = Math.floor((remaining - 1) / 26);
+  }
+
+  return result;
+}
+
+/** Roman numeral building blocks, largest first. */
+const ROMAN_NUMERALS = Object.freeze([
+  ["M", 1000],
+  ["CM", 900],
+  ["D", 500],
+  ["CD", 400],
+  ["C", 100],
+  ["XC", 90],
+  ["L", 50],
+  ["XL", 40],
+  ["X", 10],
+  ["IX", 9],
+  ["V", 5],
+  ["IV", 4],
+  ["I", 1],
+]);
+
+/**
+ * Convert a positive integer to a Roman numeral.
+ *
+ * @param {number} value - The number to convert
+ * @returns {string} The upper case Roman numeral
+ *
+ * @example
+ * toRoman(2004); // 'MMIV'
+ */
+export function toRoman(value) {
+  let remaining = value;
+  let result = "";
+
+  for (const [numeral, amount] of ROMAN_NUMERALS) {
+    while (remaining >= amount) {
+      result += numeral;
+      remaining -= amount;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * 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`
+ * @returns {string} The rendered number
+ */
+function formatToken(value, token) {
+  if (/^\d+$/.test(token)) {
+    return String(value).padStart(token.length, "0");
+  }
+
+  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);
+  }
+}
+
+/**
+ * Split an `xsl:number` format string into prefix, tokens, separators, suffix.
+ *
+ * @param {string} format - The format attribute value
+ * @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 tokens = [];
+  const separators = [];
+  let prefix = "";
+  let suffix = "";
+
+  for (const part of parts) {
+    if (isToken(part)) tokens.push(part);
+    else if (tokens.length === 0) prefix = part;
+    else separators.push(part);
+  }
+
+  if (parts.length > 0 && tokens.length > 0 && !isToken(parts.at(-1))) {
+    suffix = separators.pop();
+  }
+
+  if (tokens.length === 0) tokens.push("1");
+
+  return { prefix, suffix, tokens, separators };
+}
+
+/**
+ * Format a number sequence produced by {@link countXsltNumber}.
+ *
+ * @param {number[]} numbers - The numbers, outermost first
+ * @param {string} [format] - The `format` attribute value
+ * @returns {string} The formatted string, empty when there is nothing to number
+ *
+ * @example
+ * formatXsltNumber([2, 3], '1.1'); // '2.3'
+ */
+export function formatXsltNumber(numbers, format = "1") {
+  if (numbers.length === 0) return "";
+
+  const { prefix, suffix, tokens, separators } = parseFormat(format);
+  let result = prefix;
+
+  numbers.forEach((value, index) => {
+    if (index > 0) {
+      const separator = separators[index - 1] ?? separators.at(-1) ?? ".";
+      result += separator;
+    }
+    result += formatToken(value, tokens[index] ?? tokens.at(-1));
+  });
+
+  return result + suffix;
+}

package/src/xslt/resultTree.js

@@ -0,0 +1,74 @@
+/**
+ * Result tree construction helpers.
+ *
+ * XSLT builds its result tree in a neutral XML document: building directly in
+ * an HTML owner document would lower case element names and force the XHTML
+ * namespace on every created element. The finished tree is imported into the
+ * caller's document only at the very end, which keeps names, namespaces and the
+ * `disable-output-escaping` markers intact.
+ */
+
+"use strict";
+
+/**
+ * Create an empty, namespace neutral XML document.
+ *
+ * @param {Document} ownerDocument - Any document, used for its DOM implementation
+ * @returns {Document} A fresh empty XML document
+ *
+ * @example
+ * const resultDoc = createResultDocument(window.document);
+ */
+export function createResultDocument(ownerDocument) {
+  return ownerDocument.implementation.createDocument(null, null, null);
+}
+
+/**
+ * Deep-import a result tree node into another document.
+ *
+ * Unlike `Document.importNode` this preserves the internal
+ * `_disableOutputEscaping` marker set by `disable-output-escaping`.
+ *
+ * @param {Node} node - The node to import
+ * @param {Document} targetDoc - The document that will own the copy
+ * @returns {Node} The imported copy
+ *
+ * @example
+ * const copy = importResultNode(element, window.document);
+ */
+export function importResultNode(node, targetDoc) {
+  const copy = targetDoc.importNode(node, false);
+
+  if (node._disableOutputEscaping) {
+    copy._disableOutputEscaping = true;
+  }
+
+  if (node.childNodes) {
+    for (const child of node.childNodes) {
+      copy.appendChild(importResultNode(child, targetDoc));
+    }
+  }
+
+  return copy;
+}
+
+/**
+ * Move a finished result fragment into the caller's output document.
+ *
+ * @param {DocumentFragment} fragment - The fragment built in the neutral document
+ * @param {Document} targetDoc - The document that will own the result
+ * @returns {DocumentFragment} A fragment owned by `targetDoc`
+ *
+ * @example
+ * const result = importResultFragment(fragment, window.document);
+ */
+export function importResultFragment(fragment, targetDoc) {
+  if (fragment.ownerDocument === targetDoc) return fragment;
+
+  const imported = targetDoc.createDocumentFragment();
+  for (const child of fragment.childNodes) {
+    imported.appendChild(importResultNode(child, targetDoc));
+  }
+
+  return imported;
+}