@tradik/xslt-processor 1.0.3 → 1.3.0

package/src/xslt/exslt/stringOps.js

@@ -0,0 +1,163 @@
+/**
+ * String algorithms of the EXSLT strings module, ported from libexslt
+ * `strings.c`. They work on plain strings; `strings.js` binds them to XPath.
+ * Lengths and positions count characters (Unicode code points).
+ */
+
+"use strict";
+
+import { characters } from "./arguments.js";
+
+/** Delimiters `str:tokenize()` uses without a second argument. */
+export const DEFAULT_TOKENIZE_DELIMITERS = "\t\r\n ";
+
+/** Longest string `str:padding()` builds (libexslt's limit). */
+export const MAX_PADDING = 100000;
+
+/**
+ * `str:tokenize()`: split on any of the delimiter characters, dropping empty
+ * tokens; an empty delimiter string makes every character a token.
+ *
+ * @param {string} str - The string to split
+ * @param {string} delimiters - Delimiter characters
+ * @returns {string[]} The tokens
+ */
+export function tokenizeString(str, delimiters) {
+  const chars = characters(str);
+  if (delimiters === "") return chars;
+
+  const separators = new Set(characters(delimiters));
+  const tokens = [];
+  let token = "";
+  for (const char of chars) {
+    if (!separators.has(char)) {
+      token += char;
+    } else if (token !== "") {
+      tokens.push(token);
+      token = "";
+    }
+  }
+  if (token !== "") tokens.push(token);
+  return tokens;
+}
+
+/**
+ * Lower-case the ASCII letters of a string, as libxml2 `xmlStrncasecmp`.
+ *
+ * @param {string} str - Any string
+ * @returns {string} The string with A-Z lower-cased
+ */
+function asciiLowerCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => letter.toLowerCase());
+}
+
+/**
+ * `str:split()`: split on a delimiter string, dropping empty tokens. As in
+ * libexslt the delimiter matches ASCII letters case-insensitively, and an
+ * empty delimiter makes every character a token.
+ *
+ * @param {string} str - The string to split
+ * @param {string} delimiter - The delimiter
+ * @returns {string[]} The tokens
+ */
+export function splitString(str, delimiter) {
+  if (delimiter === "") return characters(str);
+
+  const haystack = asciiLowerCase(str);
+  const needle = asciiLowerCase(delimiter);
+  const tokens = [];
+  let start = 0;
+  let at = haystack.indexOf(needle);
+  while (at !== -1) {
+    if (at > start) tokens.push(str.substring(start, at));
+    start = at + needle.length;
+    at = haystack.indexOf(needle, start);
+  }
+  if (start < str.length) tokens.push(str.substring(start));
+  return tokens;
+}
+
+/**
+ * `str:padding(length, chars)`: repeat `chars` (a space when empty) and
+ * truncate to `length` characters, capped at {@link MAX_PADDING}.
+ *
+ * @param {number} length - Requested length
+ * @param {string} chars - Padding characters
+ * @returns {string} The padding
+ */
+export function paddingString(length, chars) {
+  if (Number.isNaN(length) || length < 1) return "";
+  const count = Math.min(Math.trunc(length), MAX_PADDING);
+  const pattern = characters(chars === "" ? " " : chars);
+  const whole = Math.floor(count / pattern.length);
+  return (
+    pattern.join("").repeat(whole) +
+    pattern.slice(0, count - whole * pattern.length).join("")
+  );
+}
+
+/**
+ * `str:align(string, padding, alignment)`: overlay the string on the padding
+ * ("left" unless "right" or "center"), truncating a longer string.
+ *
+ * @param {string} str - The string to align
+ * @param {string} padding - The padding it is placed on
+ * @param {string|null} alignment - "left", "right" or "center"
+ * @returns {string} The aligned string
+ */
+export function alignString(str, padding, alignment) {
+  const text = characters(str);
+  const pad = characters(padding);
+  if (text.length >= pad.length) return text.slice(0, pad.length).join("");
+
+  const free = pad.length - text.length;
+  let left = 0;
+  if (alignment === "right") left = free;
+  else if (alignment === "center") left = Math.floor(free / 2);
+
+  return (
+    pad.slice(0, left).join("") + str + pad.slice(left + text.length).join("")
+  );
+}
+
+/**
+ * `str:replace()`: replace every occurrence of the search strings, longest
+ * match first (the earliest search string on ties). Search string `i` is
+ * replaced by replacement `i`, or removed when there is none. The first empty
+ * search string with a non-empty replacement inserts that replacement between
+ * the characters that no search string matches.
+ *
+ * @param {string} str - The string to process
+ * @param {string[]} searches - Search strings
+ * @param {Array<string|null>} replacements - Replacements by search index
+ * @returns {string} The processed string
+ */
+export function replaceStrings(str, searches, replacements) {
+  const replacementOf = (index) => replacements[index] ?? "";
+  let emptyIndex = searches.indexOf("");
+  if (emptyIndex !== -1 && replacementOf(emptyIndex) === "") emptyIndex = -1;
+
+  let result = "";
+  let start = 0;
+  let at = 0;
+  while (at < str.length) {
+    let match = -1;
+    searches.forEach((search, index) => {
+      const longer = match === -1 || search.length > searches[match].length;
+      if (search !== "" && longer && str.startsWith(search, at)) match = index;
+    });
+
+    if (match === -1) {
+      if (emptyIndex !== -1 && start < at) {
+        result += str.substring(start, at) + replacementOf(emptyIndex);
+        start = at;
+      }
+      at += str.codePointAt(at) > 0xffff ? 2 : 1;
+    } else {
+      result += str.substring(start, at) + replacementOf(match);
+      at += searches[match].length;
+      start = at;
+    }
+  }
+  return result + str.substring(start);
+}

package/src/xslt/exslt/strings.js

@@ -0,0 +1,147 @@
+/**
+ * EXSLT strings module (http://exslt.org/strings), following libexslt
+ * `strings.c`: tokenize, split, replace, padding, align, concat, encode-uri
+ * and decode-uri.
+ *
+ * `tokenize()` / `split()` return `token` elements (no namespace) and
+ * `replace()` returns one text node; like libexslt's result tree fragments,
+ * the nodes of one call are siblings in a new DocumentFragment.
+ */
+
+"use strict";
+
+import { expandedFunctionName } from "../../xpath/evaluator.js";
+import {
+  EXSLT_STRINGS,
+  checkArity,
+  createContainer,
+  isNodeSetValue,
+  toNodeSet,
+} from "./arguments.js";
+import {
+  DEFAULT_TOKENIZE_DELIMITERS,
+  alignString,
+  paddingString,
+  replaceStrings,
+  splitString,
+  tokenizeString,
+} from "./stringOps.js";
+import { decodeUri, encodeUri } from "./uri.js";
+
+/**
+ * Build the EXSLT strings functions.
+ *
+ * @param {import('../../xpath/evaluator.js').XPathEvaluator} evaluator - Evaluates the arguments
+ * @returns {Object<string, Function>} Functions keyed by expanded name
+ */
+export function createStringsFunctions(evaluator) {
+  const value = (arg, ctx) => evaluator.evaluate(arg, ctx);
+  const string = (arg, ctx) => evaluator.toString(value(arg, ctx));
+  const optionalString = (args, index, ctx, fallback) =>
+    args.length > index ? string(args[index], ctx) : fallback;
+
+  /**
+   * Turn tokens into `token` elements of a new fragment.
+   *
+   * @param {string[]} tokens - The tokens
+   * @param {object} ctx - Evaluation context, provides the owner document
+   * @returns {Element[]} The token elements
+   */
+  const tokenElements = (tokens, ctx) => {
+    const container = createContainer(ctx);
+    const doc = container.ownerDocument;
+    return tokens.map((token) => {
+      const element = doc.createElementNS(null, "token");
+      element.appendChild(doc.createTextNode(token));
+      return container.appendChild(element);
+    });
+  };
+
+  /**
+   * String values of a node-set argument, or the string of any other value.
+   *
+   * @param {*} argValue - An evaluated argument
+   * @returns {string[]} The strings
+   */
+  const stringList = (argValue) =>
+    isNodeSetValue(argValue)
+      ? toNodeSet("str:replace", argValue).map((node) =>
+          evaluator.getStringValue(node),
+        )
+      : [evaluator.toString(argValue)];
+
+  const key = (local) => expandedFunctionName(EXSLT_STRINGS, local);
+
+  return {
+    [key("tokenize")]: (args, ctx) => {
+      checkArity("str:tokenize", args, 1, 2);
+      const delimiters = optionalString(
+        args,
+        1,
+        ctx,
+        DEFAULT_TOKENIZE_DELIMITERS,
+      );
+      return tokenElements(
+        tokenizeString(string(args[0], ctx), delimiters),
+        ctx,
+      );
+    },
+
+    [key("split")]: (args, ctx) => {
+      checkArity("str:split", args, 1, 2);
+      const delimiter = optionalString(args, 1, ctx, " ");
+      return tokenElements(splitString(string(args[0], ctx), delimiter), ctx);
+    },
+
+    [key("replace")]: (args, ctx) => {
+      checkArity("str:replace", args, 3);
+      const str = string(args[0], ctx);
+      const searches = stringList(value(args[1], ctx));
+      const replacements = stringList(value(args[2], ctx));
+      const container = createContainer(ctx);
+      const text = container.ownerDocument.createTextNode(
+        replaceStrings(str, searches, replacements),
+      );
+      return [container.appendChild(text)];
+    },
+
+    [key("padding")]: (args, ctx) => {
+      checkArity("str:padding", args, 1, 2);
+      const length = evaluator.toNumber(value(args[0], ctx));
+      return paddingString(length, optionalString(args, 1, ctx, ""));
+    },
+
+    [key("align")]: (args, ctx) => {
+      checkArity("str:align", args, 2, 3);
+      return alignString(
+        string(args[0], ctx),
+        string(args[1], ctx),
+        optionalString(args, 2, ctx, null),
+      );
+    },
+
+    [key("concat")]: (args, ctx) => {
+      checkArity("str:concat", args, 1);
+      return toNodeSet("str:concat", value(args[0], ctx))
+        .map((node) => evaluator.getStringValue(node))
+        .join("");
+    },
+
+    [key("encode-uri")]: (args, ctx) => {
+      checkArity("str:encode-uri", args, 2, 3);
+      return encodeUri(
+        string(args[0], ctx),
+        evaluator.toBoolean(value(args[1], ctx)),
+        optionalString(args, 2, ctx, undefined),
+      );
+    },
+
+    [key("decode-uri")]: (args, ctx) => {
+      checkArity("str:decode-uri", args, 1, 2);
+      return decodeUri(
+        string(args[0], ctx),
+        optionalString(args, 1, ctx, undefined),
+      );
+    },
+  };
+}

package/src/xslt/exslt/uri.js

@@ -0,0 +1,92 @@
+/**
+ * `str:encode-uri()` / `str:decode-uri()` algorithms, following libexslt
+ * `strings.c` and libxml2 `xmlURIEscapeStr()` / `xmlURIUnescapeString()`.
+ *
+ * Only UTF-8 is supported: any other encoding argument (the name is compared
+ * case-sensitively, as libexslt does) yields the empty string, as does a
+ * string that is not well-formed Unicode or decodes to malformed UTF-8.
+ */
+
+"use strict";
+
+/** The only encoding name the functions accept. */
+export const URI_ENCODING = "UTF-8";
+
+/** Characters never escaped: RFC 2396 "mark" characters (letters and digits aside). */
+const MARKS = "-_.!~*'()";
+
+/** Reserved characters kept when `escape-reserved` is false. */
+const RESERVED = ";/?:@&=+$,[]";
+
+/**
+ * Whether a string contains an unpaired surrogate, which has no UTF-8 form.
+ *
+ * @param {string} str - Any string
+ * @returns {boolean} True when the string is not well-formed
+ */
+function hasLoneSurrogate(str) {
+  return /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(
+    str,
+  );
+}
+
+/**
+ * Percent-encode the UTF-8 bytes of one character, in upper case hex.
+ *
+ * @param {string} char - One character (code point)
+ * @returns {string} The escaped bytes
+ */
+function escapeBytes(char) {
+  const code = char.codePointAt(0);
+  if (code < 0x80) {
+    return `%${code.toString(16).toUpperCase().padStart(2, "0")}`;
+  }
+  return encodeURIComponent(char);
+}
+
+/**
+ * `str:encode-uri(string, escape-reserved, encoding?)`.
+ *
+ * @param {string} str - The string to escape
+ * @param {boolean} escapeReserved - Whether reserved characters are escaped too
+ * @param {string} [encoding] - Must be "UTF-8" when given
+ * @returns {string} The escaped string, "" on failure
+ */
+export function encodeUri(str, escapeReserved, encoding = URI_ENCODING) {
+  if (encoding !== URI_ENCODING || hasLoneSurrogate(str)) return "";
+
+  const kept = escapeReserved ? MARKS : MARKS + RESERVED;
+  let result = "";
+  for (const char of str) {
+    const unescaped = /^[A-Za-z0-9]$/.test(char) || kept.includes(char);
+    result += unescaped ? char : escapeBytes(char);
+  }
+  return result;
+}
+
+/**
+ * `str:decode-uri(string, encoding?)`: decode every `%XX` escape (a `%` not
+ * followed by two hex digits stays as is); the decoded bytes must be UTF-8.
+ * As the result is a C string in libexslt, it ends at a decoded NUL byte.
+ *
+ * @param {string} str - The string to unescape
+ * @param {string} [encoding] - Must be "UTF-8" when given
+ * @returns {string} The unescaped string, "" on failure
+ */
+export function decodeUri(str, encoding = URI_ENCODING) {
+  if (encoding !== URI_ENCODING || hasLoneSurrogate(str)) return "";
+
+  // Re-escape everything but valid escapes, then let the platform decode the
+  // bytes: decodeURIComponent throws on malformed UTF-8.
+  const escaped = str.replace(/%(?![0-9A-Fa-f]{2})|[^%]+/gu, (text) =>
+    text === "%" ? "%25" : encodeURIComponent(text),
+  );
+
+  try {
+    const decoded = decodeURIComponent(escaped);
+    const nul = decoded.indexOf("\0");
+    return nul === -1 ? decoded : decoded.substring(0, nul);
+  } catch {
+    return "";
+  }
+}

package/src/xslt/formatNumber.js

@@ -0,0 +1,233 @@
+/**
+ * XSLT 1.0 `format-number()` picture string formatting.
+ *
+ * Implements the subset of the JDK `DecimalFormat` picture syntax that XSLT 1.0
+ * requires: grouping separator, decimal separator, minimum/maximum fraction
+ * digits, minimum integer digits, percent and per-mille scaling and an optional
+ * negative subpattern. All symbols are taken from an `xsl:decimal-format`
+ * declaration so alternative digits and separators are honoured.
+ */
+
+"use strict";
+
+/** Symbols of the unnamed, default `xsl:decimal-format`. */
+export const DEFAULT_DECIMAL_FORMAT = Object.freeze({
+  decimalSeparator: ".",
+  groupingSeparator: ",",
+  percent: "%",
+  perMille: "‰",
+  zeroDigit: "0",
+  digit: "#",
+  patternSeparator: ";",
+  infinity: "Infinity",
+  nan: "NaN",
+  minusSign: "-",
+});
+
+/**
+ * Split a picture string into its positive and optional negative subpattern.
+ *
+ * @param {string} pattern - The picture string
+ * @param {Object} format - Decimal format symbols
+ * @returns {{positive: string, negative: (string|null)}} The subpatterns
+ */
+function splitSubPatterns(pattern, format) {
+  const index = pattern.indexOf(format.patternSeparator);
+  if (index === -1) return { positive: pattern, negative: null };
+  return {
+    positive: pattern.substring(0, index),
+    negative: pattern.substring(index + format.patternSeparator.length),
+  };
+}
+
+/**
+ * Parse a single subpattern into a formatting description.
+ *
+ * @param {string} subPattern - One subpattern of a picture string
+ * @param {Object} format - Decimal format symbols
+ * @returns {Object} Prefix, suffix, digit counts, grouping size and multiplier
+ */
+function parseSubPattern(subPattern, format) {
+  const special = new Set([
+    format.digit,
+    format.zeroDigit,
+    format.groupingSeparator,
+    format.decimalSeparator,
+  ]);
+
+  let start = 0;
+  while (start < subPattern.length && !special.has(subPattern[start])) start++;
+
+  let end = start;
+  while (end < subPattern.length && special.has(subPattern[end])) end++;
+
+  const prefix = subPattern.substring(0, start);
+  const numeric = subPattern.substring(start, end);
+  const suffix = subPattern.substring(end);
+
+  const decimalIndex = numeric.indexOf(format.decimalSeparator);
+  const integerPart =
+    decimalIndex === -1 ? numeric : numeric.substring(0, decimalIndex);
+  const fractionPart =
+    decimalIndex === -1 ? "" : numeric.substring(decimalIndex + 1);
+
+  const groupingIndex = integerPart.lastIndexOf(format.groupingSeparator);
+  const affixes = prefix + suffix;
+
+  let multiplier = 1;
+  if (affixes.includes(format.percent)) multiplier = 100;
+  else if (affixes.includes(format.perMille)) multiplier = 1000;
+
+  return {
+    prefix,
+    suffix,
+    multiplier,
+    minInteger: countOccurrences(integerPart, format.zeroDigit),
+    integerHash: countOccurrences(integerPart, format.digit),
+    hasDecimal: decimalIndex !== -1,
+    minFraction: countOccurrences(fractionPart, format.zeroDigit),
+    maxFraction: Math.min(fractionPart.length, 100),
+    groupingSize:
+      groupingIndex === -1 ? 0 : integerPart.length - groupingIndex - 1,
+  };
+}
+
+/**
+ * Count occurrences of a character inside a string.
+ *
+ * @param {string} text - The text to scan
+ * @param {string} char - The character to count
+ * @returns {number} Number of occurrences
+ */
+function countOccurrences(text, char) {
+  let total = 0;
+  for (const current of text) {
+    if (current === char) total++;
+  }
+  return total;
+}
+
+/**
+ * Insert grouping separators into a run of integer digits.
+ *
+ * @param {string} digits - Integer digits, most significant first
+ * @param {number} size - Grouping size, 0 disables grouping
+ * @param {string} separator - The grouping separator
+ * @returns {string} The grouped digits
+ */
+function applyGrouping(digits, size, separator) {
+  if (size <= 0 || digits.length <= size) return digits;
+
+  let result = "";
+  for (let i = 0; i < digits.length; i++) {
+    const fromEnd = digits.length - i;
+    if (i > 0 && fromEnd % size === 0) result += separator;
+    result += digits[i];
+  }
+  return result;
+}
+
+/**
+ * Translate ASCII digits to the digits of the decimal format.
+ *
+ * @param {string} text - Text containing ASCII digits
+ * @param {string} zeroDigit - The format's zero digit
+ * @returns {string} Text using the format's digit family
+ */
+function translateDigits(text, zeroDigit) {
+  const offset = zeroDigit.codePointAt(0) - 48;
+  if (offset === 0) return text;
+  return text.replaceAll(/\d/g, (digit) =>
+    String.fromCodePoint(digit.codePointAt(0) + offset),
+  );
+}
+
+/**
+ * Format the magnitude of a finite number according to a parsed subpattern.
+ *
+ * Follows libxslt (and so Chrome) where the JDK rules leave room: a pattern
+ * without integer digits and zero fraction digits (`.#`) shows one fraction
+ * digit, as the JDK does; an integer part of zero is written as `0` unless
+ * the pattern asks for fraction zeros (`#.#` gives `0.5`, `.#` gives `.5`);
+ * and a decimal separator with no fraction digits after it is kept (`#.`
+ * gives `1.`).
+ *
+ * @param {number} magnitude - Absolute, already scaled value
+ * @param {Object} spec - Parsed subpattern
+ * @param {Object} format - Decimal format symbols
+ * @returns {string} The formatted number without prefix or suffix
+ */
+function formatMagnitude(magnitude, spec, format) {
+  const noDigits = spec.minInteger + spec.integerHash + spec.minFraction === 0;
+  const minFraction = noDigits && spec.maxFraction > 0 ? 1 : spec.minFraction;
+  const fixed = magnitude.toFixed(spec.maxFraction);
+  const [rawInteger, rawFraction = ""] = fixed.split(".");
+
+  let fraction = rawFraction;
+  while (fraction.length > minFraction && fraction.endsWith("0")) {
+    fraction = fraction.slice(0, -1);
+  }
+
+  let integer = (rawInteger === "0" ? "" : rawInteger).padStart(
+    spec.minInteger,
+    "0",
+  );
+  if (integer === "" && spec.minInteger + minFraction === 0) integer = "0";
+
+  integer = applyGrouping(integer, spec.groupingSize, format.groupingSeparator);
+
+  let body = integer;
+  if (fraction.length > 0) body += format.decimalSeparator + fraction;
+  else if (spec.maxFraction === 0 && spec.hasDecimal) {
+    body += format.decimalSeparator;
+  }
+
+  return translateDigits(body, format.zeroDigit);
+}
+
+/**
+ * Format a number using an XSLT 1.0 picture string.
+ *
+ * @param {number} value - The number to format
+ * @param {string} pattern - The picture string, e.g. `#,##0.00`
+ * @param {Object} [decimalFormat] - `xsl:decimal-format` symbols
+ * @returns {string} The formatted number
+ *
+ * @example
+ * formatNumber(1234.5, '#,##0.00'); // '1,234.50'
+ * formatNumber(-1234, '#,##0;(#,##0)'); // '(1,234)'
+ */
+export function formatNumber(
+  value,
+  pattern,
+  decimalFormat = DEFAULT_DECIMAL_FORMAT,
+) {
+  const format = { ...DEFAULT_DECIMAL_FORMAT, ...decimalFormat };
+
+  if (typeof value !== "number" || Number.isNaN(value)) return format.nan;
+
+  const subPatterns = splitSubPatterns(pattern, format);
+  const positive = parseSubPattern(subPatterns.positive, format);
+  const isNegative = value < 0;
+
+  let spec = positive;
+  let prefix = positive.prefix;
+  let suffix = positive.suffix;
+
+  if (isNegative) {
+    if (subPatterns.negative !== null) {
+      spec = parseSubPattern(subPatterns.negative, format);
+      prefix = spec.prefix;
+      suffix = spec.suffix;
+    } else {
+      prefix = format.minusSign + positive.prefix;
+    }
+  }
+
+  const magnitude = Math.abs(value) * spec.multiplier;
+  const body = Number.isFinite(magnitude)
+    ? formatMagnitude(magnitude, spec, format)
+    : format.infinity;
+
+  return prefix + body + suffix;
+}