@tradik/xslt-processor 1.1.1 → 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

@@ -83,6 +83,8 @@ function parseSubPattern(subPattern, format) {
     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:
@@ -143,31 +145,42 @@ function translateDigits(text, zeroDigit) {
 /**
  * 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 > spec.minFraction && fraction.endsWith("0")) {
+  while (fraction.length > minFraction && fraction.endsWith("0")) {
     fraction = fraction.slice(0, -1);
   }
 
-  let integer = rawInteger.padStart(spec.minInteger, "0");
-  if (spec.minInteger === 0 && integer === "0" && fraction.length > 0) {
-    integer = "";
-  }
+  let integer = (rawInteger === "0" ? "" : rawInteger).padStart(
+    spec.minInteger,
+    "0",
+  );
+  if (integer === "" && spec.minInteger + minFraction === 0) integer = "0";
 
   integer = applyGrouping(integer, spec.groupingSize, format.groupingSeparator);
 
-  const body =
-    fraction.length > 0
-      ? integer + format.decimalSeparator + fraction
-      : integer;
+  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);
 }

package/src/xslt/forwardsCompatible.js

@@ -0,0 +1,75 @@
+/**
+ * Forwards-compatible processing and xsl:fallback (XSLT 1.0 sections 2.5
+ * and 15).
+ *
+ * An element is processed in forwards-compatible mode when the nearest
+ * enclosing `version` declaration (the `version` attribute of
+ * `xsl:stylesheet`/`xsl:transform`, or the `xsl:version` attribute of a
+ * literal result element) is not "1.0". In that mode unknown top-level XSLT
+ * elements are ignored. An unknown XSLT instruction is replaced by its
+ * `xsl:fallback` children when it has some (in any mode); otherwise it is an
+ * error only if it is actually instantiated.
+ *
+ * @module xslt/forwardsCompatible
+ */
+
+"use strict";
+
+import { XSLT_NAMESPACE } from "./elements.js";
+import { xsltLocalName } from "./stylesheetChecks.js";
+
+const modes = new WeakMap();
+
+/**
+ * The version declared on one stylesheet element, if any.
+ *
+ * @param {Element} element - A stylesheet element
+ * @returns {string|null} The declared version, null when none
+ */
+export function declaredVersion(element) {
+  const localName = xsltLocalName(element);
+  if (localName === "stylesheet" || localName === "transform") {
+    return element.getAttribute("version");
+  }
+  if (localName !== null) return null;
+  return element.getAttributeNS?.(XSLT_NAMESPACE, "version") ?? null;
+}
+
+/**
+ * Whether a stylesheet element is processed in forwards-compatible mode.
+ * Cached per element.
+ *
+ * @param {Node|null} node - A stylesheet node
+ * @returns {boolean} True when the version in effect is not "1.0"
+ *
+ * @example
+ * isForwardsCompatible(instruction); // true under version="2.0"
+ */
+export function isForwardsCompatible(node) {
+  if (node?.nodeType !== 1) return false;
+
+  let forwards = modes.get(node);
+  if (forwards === undefined) {
+    const version = declaredVersion(node);
+    forwards =
+      version === null || version === ""
+        ? isForwardsCompatible(node.parentNode)
+        : version.trim() !== "1.0";
+    modes.set(node, forwards);
+  }
+  return forwards;
+}
+
+/**
+ * The `xsl:fallback` children of an instruction, in document order.
+ *
+ * @param {Element} instruction - An XSLT instruction
+ * @returns {Element[]} The fallback elements
+ */
+export function fallbackChildren(instruction) {
+  const fallbacks = [];
+  for (let child = instruction.firstChild; child; child = child.nextSibling) {
+    if (xsltLocalName(child) === "fallback") fallbacks.push(child);
+  }
+  return fallbacks;
+}