@tradik/xslt-processor 1.0.3 → 1.3.0

package/src/xslt/exslt/duration.js

@@ -0,0 +1,207 @@
+/**
+ * xs:duration values of the EXSLT dates-and-times module, ported from
+ * libexslt `date.c`: parsing, formatting and addition.
+ *
+ * A duration is `{mon, day, sec}`: years are folded into months, hours and
+ * minutes into seconds, and `0 <= sec < 86400`. A negative duration has
+ * negative months/days and borrows one day for a non-zero `sec`.
+ */
+
+"use strict";
+
+import { SECS_PER_DAY } from "./calendar.js";
+
+/** Designators in the order they may appear; "T" precedes index 3. */
+const DESIGNATORS = "YMDHMS";
+
+/** Index of the first time designator. */
+const TIME_PART = 3;
+
+/** Index of the seconds designator, the only one allowing a fraction. */
+const SECONDS_PART = 5;
+
+/** Seconds per unit of the time designators, by index. */
+const UNIT_SECONDS = [0, 0, 0, 3600, 60, 1];
+
+/**
+ * Create a zero duration.
+ *
+ * @returns {{mon: number, day: number, sec: number}} The duration
+ */
+export function createDuration() {
+  return { mon: 0, day: 0, sec: 0 };
+}
+
+/**
+ * Read the number before a designator: digits and an optional fraction.
+ *
+ * @param {string} text - The duration text
+ * @param {number} at - Start index
+ * @returns {{num: number, fraction: number, hasDigits: boolean, hasFraction: boolean, end: number}} The number
+ */
+function readNumber(text, at) {
+  const [whole, digits, dot, fractionDigits] = /^(\d*)(\.?)(\d*)/.exec(
+    text.substring(at),
+  );
+  let fraction = 0;
+  let scale = 1;
+  for (const digit of dot ? fractionDigits : "") {
+    scale /= 10;
+    fraction += Number(digit) * scale;
+  }
+  return {
+    num: Number(digits || "0"),
+    fraction,
+    hasDigits: digits !== "" || (dot !== "" && fractionDigits !== ""),
+    hasFraction: dot !== "",
+    end: at + whole.length,
+  };
+}
+
+/**
+ * Parse an xs:duration such as "-P1Y2M3DT4H5M6.5S"
+ * (libexslt `exsltDateParseDuration`).
+ *
+ * @param {string} text - The lexical form
+ * @returns {{mon: number, day: number, sec: number}|null} The duration, null when invalid
+ */
+export function parseDuration(text) {
+  const negative = text.startsWith("-");
+  let at = negative ? 1 : 0;
+  if (text.charAt(at) !== "P" || at + 1 === text.length) return null;
+  at++;
+
+  const dur = createDuration();
+  let seq = 0;
+  let secs = 0;
+  let fraction = 0;
+  while (at < text.length) {
+    if (seq >= DESIGNATORS.length) return null;
+    if (text.charAt(at) === "T") {
+      if (seq > TIME_PART) return null;
+      at++;
+      seq = TIME_PART;
+    } else if (seq === TIME_PART) {
+      return null;
+    }
+
+    const number = readNumber(text, at);
+    at = number.end;
+    while (text.charAt(at) !== DESIGNATORS[seq]) {
+      seq++;
+      if (seq === TIME_PART || seq === DESIGNATORS.length) return null;
+    }
+    at++;
+    if (!number.hasDigits || (number.hasFraction && seq !== SECONDS_PART)) {
+      return null;
+    }
+    if (!Number.isSafeInteger(number.num)) return null;
+    fraction += number.fraction;
+
+    if (seq === 0) dur.mon = number.num * 12;
+    else if (seq === 1) dur.mon += number.num;
+    else if (seq === 2) dur.day = number.num;
+    else {
+      const seconds = number.num * UNIT_SECONDS[seq];
+      dur.day += Math.floor(seconds / SECS_PER_DAY);
+      secs += seconds % SECS_PER_DAY;
+    }
+    seq++;
+  }
+
+  dur.day += Math.floor(secs / SECS_PER_DAY);
+  dur.sec = (secs % SECS_PER_DAY) + fraction;
+  if (negative) {
+    // 0 - x rather than -x: integers in C have no negative zero
+    dur.mon = 0 - dur.mon;
+    dur.day = 0 - dur.day;
+    if (dur.sec !== 0) {
+      dur.sec = SECS_PER_DAY - dur.sec;
+      dur.day -= 1;
+    }
+  }
+  return dur;
+}
+
+/**
+ * Decimal digits of a fraction of a second, without trailing zeros
+ * (libexslt `exsltFormatNanoseconds`).
+ *
+ * @param {number} nanoseconds - Nanoseconds, 0-999999999
+ * @returns {string} "" for zero, else "." and up to nine digits
+ */
+export function formatNanoseconds(nanoseconds) {
+  if (nanoseconds <= 0) return "";
+  return `.${String(nanoseconds).padStart(9, "0").replace(/0+$/, "")}`;
+}
+
+/**
+ * Format a duration (libexslt `exsltDateFormatDuration`), e.g. "P1Y2MT3S".
+ *
+ * @param {{mon: number, day: number, sec: number}} dur - The duration
+ * @returns {string} The lexical form, "P0D" for a zero duration
+ */
+export function formatDuration(dur) {
+  if (dur.sec === 0 && dur.day === 0 && dur.mon === 0) return "P0D";
+
+  let { sec: secs, day: days, mon: months } = dur;
+  let sign = "";
+  if (days < 0) {
+    if (secs !== 0) {
+      secs = SECS_PER_DAY - secs;
+      days += 1;
+    }
+    days = -days;
+    sign = "-";
+  }
+  if (months < 0) {
+    months = -months;
+    sign = "-";
+  }
+
+  let result = `${sign}P`;
+  const years = Math.trunc(months / 12);
+  months -= years * 12;
+  if (years > 0) result += `${years}Y`;
+  if (months !== 0) result += `${months}M`;
+  if (days !== 0) result += `${days}D`;
+
+  let intSecs = Math.floor(secs);
+  let nanoseconds = Math.floor((secs - intSecs) * 1e9 + 0.5);
+  if (nanoseconds >= 1e9) {
+    nanoseconds -= 1e9;
+    intSecs += 1;
+  }
+  if (intSecs === 0 && nanoseconds === 0) return result;
+
+  result += "T";
+  const hours = Math.floor(intSecs / 3600);
+  const minutes = Math.floor((intSecs % 3600) / 60);
+  intSecs %= 60;
+  if (hours > 0) result += `${hours}H`;
+  if (minutes > 0) result += `${minutes}M`;
+  if (intSecs > 0 || nanoseconds > 0) {
+    result += `${intSecs}${formatNanoseconds(nanoseconds)}S`;
+  }
+  return result;
+}
+
+/**
+ * Add two durations (libexslt `_exsltDateAddDurCalc`).
+ *
+ * @param {{mon: number, day: number, sec: number}} x - First duration
+ * @param {{mon: number, day: number, sec: number}} y - Second duration
+ * @returns {{mon: number, day: number, sec: number}|null} The sum, null when
+ *   months and days would have opposite signs (an indeterminate result)
+ */
+export function addDurations(x, y) {
+  const sum = { mon: x.mon + y.mon, day: x.day + y.day, sec: x.sec + y.sec };
+  if (sum.sec >= SECS_PER_DAY) {
+    sum.sec -= SECS_PER_DAY;
+    sum.day += 1;
+  }
+  if (sum.day >= 0) {
+    return (sum.day > 0 || sum.sec > 0) && sum.mon < 0 ? null : sum;
+  }
+  return sum.mon > 0 ? null : sum;
+}

package/src/xslt/exslt/dynamic.js

@@ -0,0 +1,59 @@
+/**
+ * EXSLT dynamic module (http://exslt.org/dynamic): `dyn:evaluate()` only,
+ * following libexslt `dynamic.c`.
+ *
+ * Security: a stylesheet is trusted code, but the string handed to
+ * `dyn:evaluate()` often comes from the transformed document. The function
+ * is therefore disabled unless the engine opts in with
+ * `engine.enableDynamicEvaluate = true`; while disabled,
+ * `function-available('dyn:evaluate')` is false and a call throws. The
+ * expression runs with the evaluator's recursion and result size limits.
+ */
+
+"use strict";
+
+import { expandedFunctionName } from "../../xpath/evaluator.js";
+import { parse } from "../../xpath/parser.js";
+import { EXSLT_DYNAMIC, checkArity } from "./arguments.js";
+
+/**
+ * Build the EXSLT dynamic functions.
+ *
+ * @param {import('../../xpath/evaluator.js').XPathEvaluator} evaluator - Evaluates the expressions
+ * @param {() => boolean} isEnabled - Whether `dyn:evaluate()` may run, asked at each call
+ * @returns {Object<string, Function>} Functions keyed by expanded name
+ */
+export function createDynamicFunctions(evaluator, isEnabled) {
+  /**
+   * `dyn:evaluate(string)`: evaluate the string as an XPath expression in
+   * the current context (context node, position, size, variables and
+   * namespaces). An empty string, or an expression that fails to parse,
+   * yields an empty node-set, as in libexslt. Evaluation errors propagate,
+   * so the evaluator's limits cannot be defeated by swallowing them.
+   *
+   * @param {Array} args - Argument expressions
+   * @param {import('../../xpath/evaluator.js').XPathContext} ctx - Evaluation context
+   * @returns {*} The value of the expression
+   * @throws {Error} When dynamic evaluation is disabled
+   */
+  const evaluate = (args, ctx) => {
+    if (!isEnabled()) {
+      throw new Error(
+        "dyn:evaluate() is disabled; set enableDynamicEvaluate on the engine to allow it",
+      );
+    }
+    checkArity("dyn:evaluate", args, 1);
+    const expression = evaluator.toString(evaluator.evaluate(args[0], ctx));
+    if (expression === "") return [];
+    let ast;
+    try {
+      ast = parse(expression);
+    } catch {
+      return [];
+    }
+    return evaluator.evaluate(ast, ctx);
+  };
+  evaluate.isAvailable = isEnabled;
+
+  return { [expandedFunctionName(EXSLT_DYNAMIC, "evaluate")]: evaluate };
+}

package/src/xslt/exslt/index.js

@@ -0,0 +1,59 @@
+/**
+ * EXSLT extension functions (https://exslt.org/), the set libexslt provides
+ * to libxslt and so to Chrome's native XSLTProcessor: common, math, sets,
+ * strings, dates-and-times and dynamic.
+ *
+ * `../functions.js` merges this map into the XSLT function library, so the
+ * functions are found by expanded name through any prefix bound to their
+ * namespace and are reported by `function-available()`.
+ *
+ * Engine properties read at call time (all optional):
+ * - `clock()`: returns the current instant as a Date (or any object with
+ *   `getTime()` and `getTimezoneOffset()`), for deterministic dates;
+ * - `enableDynamicEvaluate`: `true` enables `dyn:evaluate()`.
+ */
+
+"use strict";
+
+import { createCommonFunctions } from "./common.js";
+import { createDatesFunctions, systemClock } from "./dates.js";
+import { createDynamicFunctions } from "./dynamic.js";
+import { createMathFunctions } from "./math.js";
+import { createSetsFunctions } from "./sets.js";
+import { createStringsFunctions } from "./strings.js";
+
+export {
+  EXSLT_COMMON,
+  EXSLT_DATES,
+  EXSLT_DYNAMIC,
+  EXSLT_MATH,
+  EXSLT_SETS,
+  EXSLT_STRINGS,
+} from "./arguments.js";
+
+/**
+ * Build the EXSLT function map of an engine.
+ *
+ * @param {{xpathEvaluator: import('../../xpath/evaluator.js').XPathEvaluator, clock?: Function, enableDynamicEvaluate?: boolean}} engine - The engine
+ * @returns {Object<string, Function>} Functions keyed by expanded name
+ *
+ * @example
+ * evaluator.registerFunctions(createExsltFunctions(engine));
+ */
+export function createExsltFunctions(engine) {
+  const evaluator = engine.xpathEvaluator;
+  const clock = () =>
+    typeof engine.clock === "function" ? engine.clock() : systemClock();
+
+  return {
+    ...createCommonFunctions(evaluator),
+    ...createMathFunctions(evaluator),
+    ...createSetsFunctions(evaluator),
+    ...createStringsFunctions(evaluator),
+    ...createDatesFunctions(evaluator, clock),
+    ...createDynamicFunctions(
+      evaluator,
+      () => engine.enableDynamicEvaluate === true,
+    ),
+  };
+}

package/src/xslt/exslt/math.js

@@ -0,0 +1,177 @@
+/**
+ * EXSLT math module (http://exslt.org/math), following libexslt `math.c`.
+ *
+ * - `min()` / `max()` are NaN for an empty node-set or when any node is NaN.
+ * - `highest()` / `lowest()` are empty in the same cases.
+ * - `constant(name, precision)` truncates the constant's decimal text to
+ *   `precision` characters (the leading "3." of PI counts), NaN otherwise.
+ * - Every numeric function returns NaN for a NaN argument.
+ */
+
+"use strict";
+
+import { expandedFunctionName } from "../../xpath/evaluator.js";
+import { parseXPathNumber } from "../../xpath/strings.js";
+import {
+  EXSLT_MATH,
+  checkArity,
+  inDocumentOrder,
+  toNodeSet,
+} from "./arguments.js";
+
+/** Decimal text of the constants known to `math:constant()`. */
+const CONSTANTS = Object.freeze({
+  PI: "3.1415926535897932384626433832795028841971693993751",
+  E: "2.71828182845904523536028747135266249775724709369996",
+  SQRRT2: "1.41421356237309504880168872420969807856967187537694",
+  LN2: "0.69314718055994530941723212145817656807550013436025",
+  LN10: "2.30258509299404568402",
+  LOG2E: "1.4426950408889634074",
+  SQRT1_2: "0.70710678118654752440",
+});
+
+/**
+ * `math:constant(name, precision)`.
+ *
+ * @param {string} name - Constant name, case-sensitive
+ * @param {number} precision - Number of characters of the decimal text
+ * @returns {number} The truncated constant, NaN for an unknown name
+ */
+export function mathConstant(name, precision) {
+  if (Number.isNaN(precision) || precision < 1) return Number.NaN;
+  if (!Object.hasOwn(CONSTANTS, name)) return Number.NaN;
+  const text = CONSTANTS[name];
+  return parseXPathNumber(
+    text.substring(0, Math.min(text.length, Math.trunc(precision))),
+  );
+}
+
+/**
+ * `math:power(base, power)` with C `pow()` semantics: 1 raised to anything,
+ * and -1 raised to an infinity, are 1 (JavaScript gives NaN).
+ *
+ * @param {number} base - The base
+ * @param {number} power - The exponent
+ * @returns {number} The power, NaN when either argument is NaN
+ */
+export function mathPower(base, power) {
+  if (Number.isNaN(base) || Number.isNaN(power)) return Number.NaN;
+  if (base === 1 || (base === -1 && !Number.isFinite(power))) return 1;
+  return Math.pow(base, power);
+}
+
+/**
+ * Extreme nodes of a node-set: those whose number is the best one.
+ *
+ * @param {number[]} values - Numbers of the nodes, in node order
+ * @param {(a: number, b: number) => boolean} better - Whether a beats b
+ * @returns {number[]} Indexes of the extreme nodes, empty when any is NaN
+ */
+function extremeIndexes(values, better) {
+  if (values.length === 0 || values.some(Number.isNaN)) return [];
+  let best = values[0];
+  let indexes = [];
+  values.forEach((value, index) => {
+    if (better(value, best)) {
+      best = value;
+      indexes = [index];
+    } else if (value === best) {
+      indexes.push(index);
+    }
+  });
+  return indexes;
+}
+
+/** One-argument numeric functions and their implementation. */
+const UNARY = Object.freeze({
+  abs: Math.abs,
+  sqrt: Math.sqrt,
+  log: Math.log,
+  sin: Math.sin,
+  cos: Math.cos,
+  tan: Math.tan,
+  asin: Math.asin,
+  acos: Math.acos,
+  atan: Math.atan,
+  exp: Math.exp,
+});
+
+/**
+ * Build the EXSLT math functions.
+ *
+ * @param {import('../../xpath/evaluator.js').XPathEvaluator} evaluator - Evaluates the arguments
+ * @param {{random?: () => number}} [options] - `random` replaces `Math.random` (tests)
+ * @returns {Object<string, Function>} Functions keyed by expanded name
+ */
+export function createMathFunctions(evaluator, options = {}) {
+  const random = options.random ?? Math.random;
+  const number = (arg, ctx) => evaluator.toNumber(evaluator.evaluate(arg, ctx));
+
+  /**
+   * Numbers of the nodes of a node-set argument, in document order.
+   *
+   * @param {string} name - Function name, for errors
+   * @param {Array} args - Argument expressions
+   * @param {object} ctx - Evaluation context
+   * @returns {{nodes: Node[], values: number[]}} The nodes and their numbers
+   */
+  const numbered = (name, args, ctx) => {
+    checkArity(name, args, 1);
+    const nodes = inDocumentOrder(
+      evaluator,
+      toNodeSet(name, evaluator.evaluate(args[0], ctx)),
+    );
+    const values = nodes.map((node) =>
+      evaluator.toNumber(evaluator.getStringValue(node)),
+    );
+    return { nodes, values };
+  };
+
+  const extremeValue = (name, better) => (args, ctx) => {
+    const { values } = numbered(name, args, ctx);
+    const indexes = extremeIndexes(values, better);
+    return indexes.length === 0 ? Number.NaN : values[indexes[0]];
+  };
+
+  const extremeNodes = (name, better) => (args, ctx) => {
+    const { nodes, values } = numbered(name, args, ctx);
+    return extremeIndexes(values, better).map((index) => nodes[index]);
+  };
+
+  const less = (a, b) => a < b;
+  const greater = (a, b) => a > b;
+  const key = (local) => expandedFunctionName(EXSLT_MATH, local);
+
+  const functions = {
+    [key("min")]: extremeValue("math:min", less),
+    [key("max")]: extremeValue("math:max", greater),
+    [key("lowest")]: extremeNodes("math:lowest", less),
+    [key("highest")]: extremeNodes("math:highest", greater),
+    [key("constant")]: (args, ctx) => {
+      checkArity("math:constant", args, 2);
+      const name = evaluator.toString(evaluator.evaluate(args[0], ctx));
+      return mathConstant(name, number(args[1], ctx));
+    },
+    [key("random")]: (args) => {
+      checkArity("math:random", args, 0);
+      return random();
+    },
+    [key("power")]: (args, ctx) => {
+      checkArity("math:power", args, 2);
+      return mathPower(number(args[0], ctx), number(args[1], ctx));
+    },
+    [key("atan2")]: (args, ctx) => {
+      checkArity("math:atan2", args, 2);
+      return Math.atan2(number(args[0], ctx), number(args[1], ctx));
+    },
+  };
+
+  for (const [local, fn] of Object.entries(UNARY)) {
+    functions[key(local)] = (args, ctx) => {
+      checkArity(`math:${local}`, args, 1);
+      return fn(number(args[0], ctx));
+    };
+  }
+
+  return functions;
+}

package/src/xslt/exslt/sets.js

@@ -0,0 +1,96 @@
+/**
+ * EXSLT sets module (http://exslt.org/sets), following libexslt `sets.c` and
+ * the libxml2 node-set primitives it calls.
+ *
+ * Every argument must be a node-set and every node-set result is in document
+ * order. `leading()` / `trailing()` return the first node-set unchanged when
+ * the second is empty, and an empty node-set when the first node of the
+ * second is not in the first.
+ */
+
+"use strict";
+
+import { expandedFunctionName } from "../../xpath/evaluator.js";
+import {
+  EXSLT_SETS,
+  checkArity,
+  inDocumentOrder,
+  toNodeSet,
+} from "./arguments.js";
+
+/**
+ * Build the EXSLT sets functions.
+ *
+ * @param {import('../../xpath/evaluator.js').XPathEvaluator} evaluator - Evaluates the arguments
+ * @returns {Object<string, Function>} Functions keyed by expanded name
+ */
+export function createSetsFunctions(evaluator) {
+  /**
+   * Evaluate the node-set arguments of a call, each in document order.
+   *
+   * @param {string} name - Function name, for errors
+   * @param {Array} args - Argument expressions
+   * @param {object} ctx - Evaluation context
+   * @param {number} count - Required number of arguments
+   * @returns {Node[][]} The node-sets
+   */
+  const nodeSets = (name, args, ctx, count) => {
+    checkArity(name, args, count);
+    return args.map((arg) =>
+      inDocumentOrder(evaluator, toNodeSet(name, evaluator.evaluate(arg, ctx))),
+    );
+  };
+
+  /**
+   * `leading()` / `trailing()`: the nodes of the first node-set before or
+   * after the first node of the second one.
+   *
+   * @param {string} name - Function name, for errors
+   * @param {boolean} before - True for leading, false for trailing
+   * @returns {Function} The XPath function
+   */
+  const around = (name, before) => (args, ctx) => {
+    const [nodes, others] = nodeSets(name, args, ctx, 2);
+    if (others.length === 0) return nodes;
+
+    const index = nodes.indexOf(others[0]);
+    if (index === -1) return [];
+    return before ? nodes.slice(0, index) : nodes.slice(index + 1);
+  };
+
+  const key = (local) => expandedFunctionName(EXSLT_SETS, local);
+
+  return {
+    [key("difference")]: (args, ctx) => {
+      const [nodes, others] = nodeSets("set:difference", args, ctx, 2);
+      const excluded = new Set(others);
+      return nodes.filter((node) => !excluded.has(node));
+    },
+
+    [key("intersection")]: (args, ctx) => {
+      const [nodes, others] = nodeSets("set:intersection", args, ctx, 2);
+      const included = new Set(others);
+      return nodes.filter((node) => included.has(node));
+    },
+
+    [key("distinct")]: (args, ctx) => {
+      const [nodes] = nodeSets("set:distinct", args, ctx, 1);
+      const seen = new Set();
+      return nodes.filter((node) => {
+        const value = evaluator.getStringValue(node);
+        if (seen.has(value)) return false;
+        seen.add(value);
+        return true;
+      });
+    },
+
+    [key("has-same-node")]: (args, ctx) => {
+      const [nodes, others] = nodeSets("set:has-same-node", args, ctx, 2);
+      const included = new Set(others);
+      return nodes.some((node) => included.has(node));
+    },
+
+    [key("leading")]: around("set:leading", true),
+    [key("trailing")]: around("set:trailing", false),
+  };
+}