@tradik/xslt-processor 1.0.3 → 1.3.0

package/src/xslt/numberFormat.js

@@ -0,0 +1,253 @@
+/**
+ * `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`, 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";
+
+/**
+ * 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],
+]);
+
+/** Largest number written with Roman numerals, as in libxslt. */
+const MAX_ROMAN = 5000;
+
+/**
+ * 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) {
+    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, 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 formatDecimal(number, 0x30, token.length, grouping);
+  }
+  const zero = decimalTokenZero(token);
+  if (zero !== null) {
+    return formatDecimal(number, zero, Array.from(token).length, grouping);
+  }
+
+  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();
+}
+
+/**
+ * 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(/[\p{L}\p{N}]+|[^\p{L}\p{N}]+/gu) || [];
+  const isToken = (part) => /^[\p{L}\p{N}]+$/u.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}.
+ *
+ * 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", grouping = {}) {
+  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), 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;
+}

package/src/xslt/patternCompiler.js

@@ -0,0 +1,175 @@
+/**
+ * Compilation of XSLT 1.0 patterns (section 5.2).
+ *
+ * A pattern is parsed with the XPath parser and turned into a list of
+ * alternatives (one per union member). Each alternative has an anchor (the
+ * root for absolute paths, an `id()`/`key()` call, or none) and a list of
+ * child or attribute steps, each remembering the separator (`/` or `//`)
+ * that links it to the step on its left.
+ *
+ * @module xslt/patternCompiler
+ */
+
+import { NodeType, parse } from "../xpath/parser.js";
+
+/** Number of (literal) arguments of the anchor functions of patterns. */
+const ANCHOR_ARITY = Object.freeze({ id: 1, key: 2 });
+const POSITIONAL_FUNCTIONS = new Set(["position", "last"]);
+
+/** Marker anchor of absolute location path patterns. */
+export const ROOT = Symbol("root");
+
+/**
+ * Whether an expression calls `position()` or `last()` anywhere.
+ *
+ * @param {*} ast - XPath AST node (or any nested value)
+ * @returns {boolean} True when the expression may depend on the position
+ */
+function usesPosition(ast) {
+  if (Array.isArray(ast)) return ast.some(usesPosition);
+  if (!ast || typeof ast !== "object") return false;
+  if (
+    ast.type === NodeType.FUNCTION_CALL &&
+    !ast.prefix &&
+    POSITIONAL_FUNCTIONS.has(ast.name)
+  ) {
+    return true;
+  }
+  return Object.values(ast).some(usesPosition);
+}
+
+/**
+ * Whether a step is the `descendant-or-self::node()` step that `//` expands to.
+ *
+ * @param {object} step - Step AST node
+ * @returns {boolean} True for the abbreviated `//` step
+ */
+function isDescendantSeparator(step) {
+  return (
+    step.axis === "descendant-or-self" &&
+    step.nodeTest.type === NodeType.NODE_TYPE_TEST &&
+    step.nodeTest.nodeType === "node" &&
+    step.predicates.length === 0
+  );
+}
+
+/**
+ * Split a parsed union into its alternatives.
+ *
+ * @param {object} ast - XPath AST
+ * @param {object[]} [result] - Array to append to
+ * @returns {object[]} The alternatives in pattern order
+ */
+function unionAlternatives(ast, result = []) {
+  if (ast.type === NodeType.UNION_EXPR) {
+    unionAlternatives(ast.left, result);
+    unionAlternatives(ast.right, result);
+  } else {
+    result.push(ast);
+  }
+  return result;
+}
+
+/**
+ * Whether an AST node is an `id()` or `key()` call.
+ *
+ * @param {object} ast - XPath AST node
+ * @returns {boolean} True for an anchor function call
+ */
+function isAnchorCall(ast) {
+  return (
+    ast?.type === NodeType.FUNCTION_CALL &&
+    !ast.prefix &&
+    Object.hasOwn(ANCHOR_ARITY, ast.name)
+  );
+}
+
+/**
+ * Check the arguments of an `id()`/`key()` pattern anchor: XSLT 1.0
+ * (section 5.2, production IdKeyPattern) only allows string literals, as
+ * libxslt enforces.
+ *
+ * @param {object} call - Function call AST of the anchor
+ * @returns {object} The call
+ * @throws {Error} When the arguments are not the right number of literals
+ */
+function checkAnchorArguments(call) {
+  const arity = ANCHOR_ARITY[call.name];
+  const literals = call.args.every((arg) => arg.type === NodeType.LITERAL);
+  if (call.args.length !== arity || !literals) {
+    const noun = arity === 1 ? "literal" : "literals";
+    throw new Error(
+      `${call.name}() expects ${arity} ${noun} in a pattern (XSLT 1.0 section 5.2)`,
+    );
+  }
+  return call;
+}
+
+/**
+ * Compile one location path pattern.
+ *
+ * @param {object} ast - AST of one union alternative
+ * @returns {{anchor: (symbol|object|null), steps: object[]}} Compiled alternative
+ * @throws {Error} When the expression is not a valid pattern
+ */
+function compileAlternative(ast) {
+  let anchor;
+  let steps;
+
+  if (ast.type === NodeType.LOCATION_PATH) {
+    anchor = ast.absolute ? ROOT : null;
+    steps = ast.steps;
+  } else if (isAnchorCall(ast)) {
+    anchor = checkAnchorArguments(ast);
+    steps = [];
+  } else if (
+    ast.type === NodeType.PATH_EXPR &&
+    isAnchorCall(ast.filter) &&
+    !ast.predicates
+  ) {
+    anchor = checkAnchorArguments(ast.filter);
+    steps = ast.steps;
+  } else {
+    throw new Error(`Unsupported pattern expression: ${ast.type}`);
+  }
+
+  const compiled = [];
+  let separator = anchor ? "/" : null;
+
+  for (const step of steps) {
+    if (isDescendantSeparator(step)) {
+      separator = "//";
+      continue;
+    }
+    if (step.axis !== "child" && step.axis !== "attribute") {
+      throw new Error(`Axis not allowed in a pattern: ${step.axis}`);
+    }
+    compiled.push({
+      axis: step.axis,
+      nodeTest: step.nodeTest,
+      separator,
+      predicates: step.predicates.map((predicate) => ({
+        expr: predicate.expr,
+        positional: usesPosition(predicate.expr),
+      })),
+    });
+    separator = "/";
+  }
+
+  if (separator === "//") throw new Error("Pattern cannot end with //");
+  return { anchor, steps: compiled };
+}
+
+/**
+ * Parse and compile a pattern string.
+ *
+ * @param {string} pattern - The XSLT pattern
+ * @returns {object[]} The compiled alternatives
+ * @throws {Error} When the pattern is not valid
+ *
+ * @example
+ * compilePattern('chapter/title | appendix//title');
+ */
+export function compilePattern(pattern) {
+  return unionAlternatives(parse(pattern)).map(compileAlternative);
+}