@tradik/xslt-processor 1.0.3 → 1.3.0

package/src/xslt/exslt/arguments.js

@@ -0,0 +1,99 @@
+/**
+ * Argument helpers shared by the EXSLT modules.
+ *
+ * EXSLT functions follow libexslt (the implementation bundled with libxslt,
+ * which Chrome uses): a wrong number of arguments or a non node-set where a
+ * node-set is required is an XPath error, so both throw here.
+ */
+
+"use strict";
+
+// A namespace name is an identifier, not a URL that is fetched; EXSLT defines them with http.
+/** Namespace of the EXSLT common module. */
+export const EXSLT_COMMON = "http://exslt.org/common"; // NOSONAR
+/** Namespace of the EXSLT math module. */
+export const EXSLT_MATH = "http://exslt.org/math"; // NOSONAR
+/** Namespace of the EXSLT sets module. */
+export const EXSLT_SETS = "http://exslt.org/sets"; // NOSONAR
+/** Namespace of the EXSLT strings module. */
+export const EXSLT_STRINGS = "http://exslt.org/strings"; // NOSONAR
+/** Namespace of the EXSLT dates-and-times module. */
+export const EXSLT_DATES = "http://exslt.org/dates-and-times"; // NOSONAR
+/** Namespace of the EXSLT dynamic module. */
+export const EXSLT_DYNAMIC = "http://exslt.org/dynamic"; // NOSONAR
+
+/**
+ * Throw unless a call has an allowed number of arguments.
+ *
+ * @param {string} name - Function name, for the error message
+ * @param {Array} args - Argument expressions
+ * @param {number} min - Minimum number of arguments
+ * @param {number} [max] - Maximum number of arguments, `min` by default
+ * @throws {Error} When the number of arguments is outside `min..max`
+ */
+export function checkArity(name, args, min, max = min) {
+  if (args.length < min || args.length > max) {
+    const expected = min === max ? `${min}` : `${min} to ${max}`;
+    throw new Error(
+      `${name}() expects ${expected} argument(s), got ${args.length}`,
+    );
+  }
+}
+
+/**
+ * Whether an evaluated value is a node-set: an array of nodes, or a single
+ * node such as a result tree fragment (libxslt accepts both).
+ *
+ * @param {*} value - An evaluated XPath value
+ * @returns {boolean} True for a node-set or a node
+ */
+export function isNodeSetValue(value) {
+  return Array.isArray(value) || Boolean(value?.nodeType);
+}
+
+/**
+ * Convert an evaluated argument that must be a node-set to an array.
+ *
+ * @param {string} name - Function name, for the error message
+ * @param {*} value - An evaluated XPath value
+ * @returns {Node[]} The nodes
+ * @throws {TypeError} When the value is not a node-set
+ */
+export function toNodeSet(name, value) {
+  if (Array.isArray(value)) return value;
+  if (value?.nodeType) return [value];
+  throw new TypeError(`${name}() expects a node-set`);
+}
+
+/**
+ * Nodes without duplicates, in document order.
+ *
+ * @param {import('../../xpath/evaluator.js').XPathEvaluator} evaluator - Sorts the nodes
+ * @param {Node[]} nodes - Any nodes
+ * @returns {Node[]} A new, sorted array
+ */
+export function inDocumentOrder(evaluator, nodes) {
+  return evaluator.sortByDocumentOrder([...new Set(nodes)]);
+}
+
+/**
+ * Create the container of the nodes an extension function returns, the
+ * counterpart of the result tree fragment libexslt creates for them.
+ *
+ * @param {import('../../xpath/evaluator.js').XPathContext} ctx - Evaluation context
+ * @returns {DocumentFragment} An empty fragment
+ */
+export function createContainer(ctx) {
+  const doc = ctx.node.ownerDocument || ctx.node;
+  return doc.createDocumentFragment();
+}
+
+/**
+ * Split a string into its characters (Unicode code points).
+ *
+ * @param {string} str - Any string
+ * @returns {string[]} The characters
+ */
+export function characters(str) {
+  return Array.from(str);
+}

package/src/xslt/exslt/calendar.js

@@ -0,0 +1,120 @@
+/**
+ * Calendar primitives of the EXSLT dates-and-times module, ported from
+ * libexslt `date.c`: date types, leap years, month lengths and validity.
+ *
+ * A date value is `{type, year, mon, day, hour, min, sec, tzFlag, tzo}`:
+ * years are continuous (year 0 is 1 BCE), `tzo` is the offset in minutes and
+ * `tzFlag` is set only by an explicit "Z" (as in libexslt).
+ */
+
+"use strict";
+
+/** Date types, bit sets of the fields they carry (libexslt `exsltDateType`). */
+export const DateType = Object.freeze({
+  TIME: 1,
+  GDAY: 2,
+  GMONTH: 4,
+  GMONTHDAY: 6,
+  GYEAR: 8,
+  GYEARMONTH: 12,
+  DATE: 14,
+  DATETIME: 15,
+});
+
+/** Seconds in a day. */
+export const SECS_PER_DAY = 86400;
+
+const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
+/**
+ * Non-negative remainder, the result of C `&` masks on two's complement.
+ *
+ * @param {number} value - An integer
+ * @param {number} divisor - A power of two
+ * @returns {number} `value mod divisor` in `0..divisor-1`
+ */
+function mask(value, divisor) {
+  return ((value % divisor) + divisor) % divisor;
+}
+
+/**
+ * Whether a (continuous) year is a leap year, as libexslt `IS_LEAP`.
+ *
+ * @param {number} year - The year
+ * @returns {boolean} True for a leap year
+ */
+export function isLeapYear(year) {
+  return mask(year, 4) === 0 && (year % 25 !== 0 || mask(year, 16) === 0);
+}
+
+/**
+ * Number of days of a month.
+ *
+ * @param {number} year - The year
+ * @param {number} mon - The month, 1-12
+ * @returns {number} Days in the month
+ */
+export function daysInMonth(year, mon) {
+  return mon === 2 && isLeapYear(year) ? 29 : DAYS_IN_MONTH[mon - 1];
+}
+
+/**
+ * Day of the year of a date, 1-366 (libexslt `DAY_IN_YEAR`).
+ *
+ * @param {number} day - Day of the month
+ * @param {number} mon - Month, 1-12
+ * @param {number} year - Year
+ * @returns {number} The day in the year
+ */
+export function dayInYear(day, mon, year) {
+  let days = day;
+  for (let m = 1; m < mon; m++) days += daysInMonth(year, m);
+  return days;
+}
+
+/**
+ * Whether a date value has a valid time part (libexslt `VALID_TIME`).
+ *
+ * @param {object} dt - Date value
+ * @returns {boolean} True when valid
+ */
+export function isValidTime(dt) {
+  return (
+    dt.hour <= 23 &&
+    dt.min <= 59 &&
+    dt.sec >= 0 &&
+    dt.sec < 60 &&
+    dt.tzo > -1440 &&
+    dt.tzo < 1440
+  );
+}
+
+/**
+ * Whether a date value has a valid date part (libexslt `VALID_DATE`).
+ *
+ * @param {object} dt - Date value
+ * @returns {boolean} True when valid
+ */
+export function isValidDate(dt) {
+  return dt.mon >= 1 && dt.mon <= 12 && dt.day <= daysInMonth(dt.year, dt.mon);
+}
+
+/**
+ * Create a date value with libexslt defaults (January 1st, midnight).
+ *
+ * @param {number} type - A {@link DateType}, 0 when unknown yet
+ * @returns {object} The date value
+ */
+export function createDate(type) {
+  return {
+    type,
+    year: 0,
+    mon: 1,
+    day: 1,
+    hour: 0,
+    min: 0,
+    sec: 0,
+    tzFlag: false,
+    tzo: 0,
+  };
+}

package/src/xslt/exslt/common.js

@@ -0,0 +1,44 @@
+/**
+ * EXSLT common module (http://exslt.org/common), following libexslt
+ * `common.c`. `exsl:node-set()` lives in `../functions.js` next to its
+ * `msxsl:node-set()` alias; this module adds `exsl:object-type()`.
+ */
+
+"use strict";
+
+import { expandedFunctionName } from "../../xpath/evaluator.js";
+import { EXSLT_COMMON, checkArity } from "./arguments.js";
+
+/** Node type of a DocumentFragment, how this engine holds a result tree fragment. */
+const DOCUMENT_FRAGMENT_NODE = 11;
+
+/**
+ * The EXSLT type name of an evaluated value.
+ *
+ * @param {*} value - An evaluated XPath value
+ * @returns {string} "string", "number", "boolean", "node-set" or "RTF"
+ * @throws {TypeError} For a value that is not an XPath object
+ */
+export function objectType(value) {
+  if (typeof value === "string") return "string";
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (value?.nodeType === DOCUMENT_FRAGMENT_NODE) return "RTF";
+  if (Array.isArray(value) || value?.nodeType) return "node-set";
+  throw new TypeError("exsl:object-type() invalid argument");
+}
+
+/**
+ * Build the EXSLT common functions implemented here.
+ *
+ * @param {import('../../xpath/evaluator.js').XPathEvaluator} evaluator - Evaluates the arguments
+ * @returns {Object<string, Function>} Functions keyed by expanded name
+ */
+export function createCommonFunctions(evaluator) {
+  return {
+    [expandedFunctionName(EXSLT_COMMON, "object-type")]: (args, ctx) => {
+      checkArity("exsl:object-type", args, 1);
+      return objectType(evaluator.evaluate(args[0], ctx));
+    },
+  };
+}

package/src/xslt/exslt/dateCalc.js

@@ -0,0 +1,261 @@
+/**
+ * Date arithmetic of the EXSLT dates-and-times module, ported from libexslt
+ * `date.c`: calendar positions, `date:add()`, `date:difference()` and
+ * `date:seconds()`. C integer division truncates, hence `Math.trunc`.
+ */
+
+"use strict";
+
+import {
+  DateType,
+  SECS_PER_DAY,
+  createDate,
+  dayInYear,
+  daysInMonth,
+} from "./calendar.js";
+import { parseDate } from "./dateParse.js";
+import { createDuration, parseDuration } from "./duration.js";
+
+/** Days in a 400-year Gregorian cycle. */
+const DAYS_PER_EPOCH = 146097;
+
+/** Years in a Gregorian cycle. */
+const YEARS_PER_EPOCH = 400;
+
+const trunc = Math.trunc;
+
+/**
+ * Leap days before a year's start term of `_exsltDateCastYMToDays`.
+ *
+ * @param {number} year - Year
+ * @returns {number} `year/4 - year/100 + year/400` with C division
+ */
+function leapDays(year) {
+  return trunc(year / 4) - trunc(year / 100) + trunc(year / 400);
+}
+
+/**
+ * Days from the calendar origin to the start of a value's month
+ * (libexslt `_exsltDateCastYMToDays`).
+ *
+ * @param {object} dt - Date value
+ * @returns {number} The day count
+ */
+function monthStartDays(dt) {
+  const beforeMonth = dayInYear(0, dt.mon, dt.year);
+  if (dt.year <= 0) {
+    return (dt.year - 1) * 365 + leapDays(dt.year) + beforeMonth - 1;
+  }
+  return (dt.year - 1) * 365 + leapDays(dt.year - 1) + beforeMonth;
+}
+
+/**
+ * Seconds since midnight of a value.
+ *
+ * @param {object} dt - Date value
+ * @returns {number} The seconds
+ */
+function timeToNumber(dt) {
+  return dt.hour * 3600 + dt.min * 60 + dt.sec;
+}
+
+/**
+ * Day of the week, 0 for Sunday (libexslt `_exsltDateDayInWeek`).
+ *
+ * @param {number} yday - Day in the year
+ * @param {number} year - Year
+ * @returns {number} 0-6
+ */
+export function dayOfWeek(yday, year) {
+  if (year <= 0) {
+    const day = ((year % 7) - 2 + leapDays(year) + yday) % 7;
+    return day < 0 ? day + 7 : day;
+  }
+  return ((year % 7) - 1 + leapDays(year - 1) + yday) % 7;
+}
+
+/**
+ * ISO 8601 week of the year (libexslt `exsltDateWeekInYear`).
+ *
+ * @param {object} dt - Date value
+ * @returns {number} The week number
+ */
+export function weekInYear(dt) {
+  let diy = dayInYear(dt.day, dt.mon, dt.year);
+  // Monday is day 0 of the ISO week, Thursday decides the year
+  const diw = (dayOfWeek(diy, dt.year) + 6) % 7;
+  diy += 3 - diw;
+  if (diy < 1) {
+    let year = dt.year - 1;
+    if (year === 0) year--;
+    diy += dayInYear(31, 12, year);
+  } else if (diy > dayInYear(31, 12, dt.year)) {
+    diy -= dayInYear(31, 12, dt.year);
+  }
+  return trunc((diy - 1) / 7) + 1;
+}
+
+/**
+ * Week of the month, weeks starting on Monday (libexslt `exsltDateWeekInMonth`).
+ *
+ * @param {object} dt - Date value
+ * @returns {number} The week number
+ */
+export function weekInMonth(dt) {
+  const firstDay = (dayOfWeek(dayInYear(1, dt.mon, dt.year), dt.year) + 6) % 7;
+  return trunc((dt.day + firstDay - 1) / 7) + 1;
+}
+
+/**
+ * Keep only the fields of a less specific type (`_exsltDateTruncateDate`).
+ *
+ * @param {object} dt - Date value, modified
+ * @param {number} type - The target {@link DateType}
+ */
+function truncateDate(dt, type) {
+  if ((type & DateType.TIME) !== DateType.TIME) {
+    dt.hour = 0;
+    dt.min = 0;
+    dt.sec = 0;
+  }
+  if ((type & DateType.GDAY) !== DateType.GDAY) dt.day = 1;
+  if ((type & DateType.GMONTH) !== DateType.GMONTH) dt.mon = 1;
+  if ((type & DateType.GYEAR) !== DateType.GYEAR) dt.year = 0;
+  dt.type = type;
+}
+
+/**
+ * Whether a value is a gYear, gYearMonth, date or dateTime.
+ *
+ * @param {object} dt - Date value
+ * @returns {boolean} True for the types with a year
+ */
+export function hasYear(dt) {
+  return dt.type >= DateType.GYEAR && dt.type <= DateType.DATETIME;
+}
+
+/**
+ * Duration from x to y (libexslt `_exsltDateDifference`); the more specific
+ * operand is truncated to the type of the other. Without `inSeconds`, gYear
+ * and gYearMonth differences are counted in months.
+ *
+ * @param {object} x - Start date value, may be truncated
+ * @param {object} y - End date value, may be truncated
+ * @param {boolean} inSeconds - Always compute days and seconds
+ * @returns {object|null} The duration, null for unsupported types
+ */
+export function dateDifference(x, y, inSeconds) {
+  if (!hasYear(x) || !hasYear(y)) return null;
+  if (x.type < y.type) truncateDate(y, x.type);
+  else if (x.type > y.type) truncateDate(x, y.type);
+
+  const dur = createDuration();
+  if (x.type <= DateType.GYEARMONTH && !inSeconds) {
+    dur.mon = (y.year - x.year) * 12 + (y.mon - x.mon);
+    return dur;
+  }
+  const sec = timeToNumber(y) - timeToNumber(x) + (x.tzo - y.tzo) * 60;
+  const carry = Math.floor(sec / SECS_PER_DAY);
+  dur.sec = sec - carry * SECS_PER_DAY;
+  dur.day = monthStartDays(y) - monthStartDays(x) + y.day - x.day + carry;
+  return dur;
+}
+
+/**
+ * Add a duration to a date value (libexslt `_exsltDateAdd`). A day past
+ * the end of the resulting month is clamped first; the type grows to show
+ * the fields the addition made significant.
+ *
+ * @param {object} dt - Date value
+ * @param {{mon: number, day: number, sec: number}} dur - Duration
+ * @returns {object} The new date value
+ */
+export function addDuration(dt, dur) {
+  const ret = createDate(dt.type);
+  let mon = dt.mon + (dur.mon % 12);
+  let carry = trunc(dur.mon / 12);
+  if (mon < 1) {
+    mon += 12;
+    carry -= 1;
+  } else if (mon > 12) {
+    mon -= 12;
+    carry += 1;
+  }
+  ret.mon = mon;
+  carry += trunc(dur.day / DAYS_PER_EPOCH) * YEARS_PER_EPOCH;
+  ret.year = dt.year + carry;
+  ret.tzo = dt.tzo;
+  ret.tzFlag = dt.tzFlag;
+
+  const sum = dt.sec + dur.sec;
+  ret.sec = sum % 60;
+  carry = trunc(sum / 60);
+  ret.min = dt.min + (carry % 60);
+  carry = trunc(carry / 60);
+  if (ret.min >= 60) {
+    ret.min -= 60;
+    carry += 1;
+  }
+  ret.hour = dt.hour + (carry % 24);
+  carry = trunc(carry / 24);
+  if (ret.hour >= 24) {
+    ret.hour -= 24;
+    carry += 1;
+  }
+
+  let day = Math.min(Math.max(dt.day, 1), daysInMonth(ret.year, ret.mon));
+  day += (dur.day % DAYS_PER_EPOCH) + carry;
+  while (day < 1 || day > daysInMonth(ret.year, ret.mon)) {
+    if (day < 1) {
+      ret.mon -= 1;
+      if (ret.mon < 1) {
+        ret.mon = 12;
+        ret.year -= 1;
+      }
+      day += daysInMonth(ret.year, ret.mon);
+    } else {
+      day -= daysInMonth(ret.year, ret.mon);
+      ret.mon += 1;
+      if (ret.mon > 12) {
+        ret.mon = 1;
+        ret.year += 1;
+      }
+    }
+  }
+  ret.day = day;
+
+  if (ret.type !== DateType.DATETIME) {
+    if (ret.hour || ret.min || ret.sec) ret.type = DateType.DATETIME;
+    else if (ret.type !== DateType.DATE) {
+      if (ret.day !== 1) ret.type = DateType.DATE;
+      else if (ret.type !== DateType.GYEARMONTH && ret.mon !== 1) {
+        ret.type = DateType.GYEARMONTH;
+      }
+    }
+  }
+  return ret;
+}
+
+/**
+ * `date:seconds()`: seconds from 1970-01-01T00:00:00Z to a date value (a
+ * gYear, gYearMonth, date or dateTime), or the length of a duration without
+ * months.
+ *
+ * @param {object|string} value - A date value, or the text to parse
+ * @returns {number} The seconds, NaN when not applicable
+ */
+export function secondsOf(value) {
+  const dt = typeof value === "string" ? parseDate(value) : value;
+  if (dt !== null) {
+    if (dt.type < DateType.GYEAR) return Number.NaN;
+    const epoch = createDate(DateType.DATETIME);
+    epoch.year = 1970;
+    epoch.tzFlag = true;
+    const diff = dateDifference(epoch, dt, true);
+    return diff.day * SECS_PER_DAY + diff.sec;
+  }
+  const dur = parseDuration(value);
+  return dur !== null && dur.mon === 0
+    ? dur.day * SECS_PER_DAY + dur.sec
+    : Number.NaN;
+}

package/src/xslt/exslt/dateFormat.js

@@ -0,0 +1,150 @@
+/**
+ * Formatting of date values for the EXSLT dates-and-times module, ported
+ * from libexslt `date.c` (`exsltDateFormat*`).
+ *
+ * Quirks kept from libexslt: an xs:dateTime always ends with a time zone
+ * ("Z" for a zero offset), while the other types show one only for an
+ * explicit "Z" or a non-zero offset.
+ */
+
+"use strict";
+
+import { DateType, isValidDate, isValidTime } from "./calendar.js";
+import { formatNanoseconds } from "./duration.js";
+
+/**
+ * Two-digit form of a number.
+ *
+ * @param {number} num - 0-99
+ * @returns {string} The digits
+ */
+function twoDigits(num) {
+  return String(num).padStart(2, "0");
+}
+
+/**
+ * Format a continuous year: at least four digits, "-" before BCE years.
+ *
+ * @param {number} year - The year (0 is 1 BCE)
+ * @returns {string} The year
+ */
+export function formatYear(year) {
+  const sign = year <= 0 ? "-" : "";
+  return sign + String(year <= 0 ? 1 - year : year).padStart(4, "0");
+}
+
+/**
+ * Format a time zone offset.
+ *
+ * @param {number} tzo - Offset in minutes
+ * @returns {string} "Z" or "±hh:mm"
+ */
+export function formatTimeZone(tzo) {
+  if (tzo === 0) return "Z";
+  const offset = Math.abs(tzo);
+  const sign = tzo < 0 ? "-" : "+";
+  return `${sign}${twoDigits(Math.floor(offset / 60))}:${twoDigits(offset % 60)}`;
+}
+
+/**
+ * Format "hh:mm:ss" with the fraction of a second, rounded to nanoseconds
+ * without carrying into the minute.
+ *
+ * @param {object} dt - Date value
+ * @returns {string} The time
+ */
+function formatClock(dt) {
+  const intSecs = Math.floor(dt.sec);
+  const nanoseconds = Math.min(
+    Math.floor((dt.sec - intSecs) * 1e9 + 0.5),
+    999999999,
+  );
+  return `${twoDigits(dt.hour)}:${twoDigits(dt.min)}:${twoDigits(intSecs)}${formatNanoseconds(nanoseconds)}`;
+}
+
+/**
+ * The time zone suffix of the types other than xs:dateTime.
+ *
+ * @param {object} dt - Date value
+ * @returns {string} The suffix, possibly empty
+ */
+function optionalTimeZone(dt) {
+  return dt.tzFlag || dt.tzo !== 0 ? formatTimeZone(dt.tzo) : "";
+}
+
+/**
+ * "CCYY-MM-DD" of a date value.
+ *
+ * @param {object} dt - Date value
+ * @returns {string} The date
+ */
+function formatYearMonthDay(dt) {
+  return `${formatYear(dt.year)}-${twoDigits(dt.mon)}-${twoDigits(dt.day)}`;
+}
+
+/**
+ * Whether both the date and time parts of a value are valid.
+ *
+ * @param {object} dt - Date value
+ * @returns {boolean} True when valid
+ */
+function isValidDateTime(dt) {
+  return isValidDate(dt) && isValidTime(dt);
+}
+
+/**
+ * Format as xs:dateTime, always with a time zone.
+ *
+ * @param {object} dt - Date value
+ * @returns {string|null} The dateTime, null when invalid
+ */
+export function formatDateTime(dt) {
+  if (!isValidDateTime(dt)) return null;
+  return `${formatYearMonthDay(dt)}T${formatClock(dt)}${formatTimeZone(dt.tzo)}`;
+}
+
+/**
+ * Format as xs:date.
+ *
+ * @param {object} dt - Date value
+ * @returns {string|null} The date, null when invalid
+ */
+export function formatDateOnly(dt) {
+  if (!isValidDateTime(dt)) return null;
+  return formatYearMonthDay(dt) + optionalTimeZone(dt);
+}
+
+/**
+ * Format as xs:time.
+ *
+ * @param {object} dt - Date value
+ * @returns {string|null} The time, null when invalid
+ */
+export function formatTimeOnly(dt) {
+  if (!isValidTime(dt)) return null;
+  return formatClock(dt) + optionalTimeZone(dt);
+}
+
+/**
+ * Format a value in the lexical form of its own type
+ * (xs:dateTime, xs:date, xs:time, xs:gYearMonth or xs:gYear).
+ *
+ * @param {object} dt - Date value
+ * @returns {string|null} The lexical form, null for other types
+ */
+export function formatByType(dt) {
+  switch (dt.type) {
+    case DateType.DATETIME:
+      return formatDateTime(dt);
+    case DateType.DATE:
+      return formatDateOnly(dt);
+    case DateType.TIME:
+      return formatTimeOnly(dt);
+    case DateType.GYEAR:
+      return formatYear(dt.year) + optionalTimeZone(dt);
+    case DateType.GYEARMONTH:
+      return `${formatYear(dt.year)}-${twoDigits(dt.mon)}${optionalTimeZone(dt)}`;
+    default:
+      return null;
+  }
+}