@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xdm/datetime.js

@@ -0,0 +1,206 @@
+/**
+ * The date and time types (xs:dateTime, xs:date, xs:time and the five
+ * Gregorian "g" types): lexical parsing per XSD 1.1 Part 2, canonical
+ * strings per F&O 3.1 19.1.2, and the position on the time line used for
+ * comparison and arithmetic.
+ *
+ * A value is a frozen {@link DateTimeValue} whose absent components are
+ * null; `second` is a {@link Decimal}; `timezone` is an offset in minutes
+ * or null. Years follow XSD 1.1: year 0000 exists, negative years are
+ * astronomical, and more than four digits are allowed up to
+ * {@link MAX_YEAR}.
+ *
+ * @module @tradik/xslt3/xdm/datetime
+ */
+
+import { XPathError } from "../errors.js";
+import { civilFromDays, daysFromCivil, daysInMonth } from "./calendar.js";
+import { Decimal } from "./decimal.js";
+
+/** Largest absolute year supported; beyond it FODT0001 is raised. */
+export const MAX_YEAR = 999999999;
+
+/** A date/time value; components that the type does not have are null. */
+export class DateTimeValue {
+  /**
+   * @param {object} fields
+   * @param {number|null} [fields.year]
+   * @param {number|null} [fields.month]
+   * @param {number|null} [fields.day]
+   * @param {number|null} [fields.hour]
+   * @param {number|null} [fields.minute]
+   * @param {Decimal|null} [fields.second]
+   * @param {number|null} [fields.timezone] - Offset in minutes
+   */
+  constructor({ year, month, day, hour, minute, second, timezone }) {
+    this.year = year ?? null;
+    this.month = month ?? null;
+    this.day = day ?? null;
+    this.hour = hour ?? null;
+    this.minute = minute ?? null;
+    this.second = second ?? null;
+    this.timezone = timezone ?? null;
+    Object.freeze(this);
+  }
+}
+
+const Y = "(-?(?:[1-9]\\d{3,}|0\\d{3}))";
+const T = "(\\d{2}):(\\d{2}):(\\d{2}(?:\\.\\d+)?)";
+const Z = "(Z|[+-]\\d{2}:\\d{2})?";
+const time = ["hour", "minute", "second"];
+/** Lexical pattern and captured component names per primitive type. */
+const formats = {
+  dateTime: [`${Y}-(\\d{2})-(\\d{2})T${T}`, ["year", "month", "day", ...time]],
+  date: [`${Y}-(\\d{2})-(\\d{2})`, ["year", "month", "day"]],
+  time: [T, time],
+  gYearMonth: [`${Y}-(\\d{2})`, ["year", "month"]],
+  gYear: [Y, ["year"]],
+  gMonthDay: ["--(\\d{2})-(\\d{2})", ["month", "day"]],
+  gDay: ["---(\\d{2})", ["day"]],
+  gMonth: ["--(\\d{2})", ["month"]],
+};
+const patterns = Object.fromEntries(
+  Object.entries(formats).map(([kind, [body]]) => [
+    kind,
+    new RegExp(`^${body}${Z}$`),
+  ]),
+);
+
+/**
+ * Names of the components a date/time type has, in lexical order.
+ * @param {string} kind - Primitive local name, e.g. "gYearMonth"
+ * @returns {string[]} e.g. ["year", "month"]
+ */
+export function componentsOf(kind) {
+  return formats[kind][1];
+}
+
+/**
+ * @param {number} year
+ * @returns {number} the year
+ * @throws {XPathError} FODT0001 when outside ±MAX_YEAR
+ */
+export function checkYear(year) {
+  if (Math.abs(year) > MAX_YEAR) {
+    throw new XPathError(
+      "FODT0001",
+      `Year ${year} is out of the supported range`,
+    );
+  }
+  return year;
+}
+
+/**
+ * Parses a timezone lexical form.
+ * @param {string|undefined} text - "Z", "+hh:mm", "-hh:mm" or undefined
+ * @returns {number|null|undefined} minutes, null when absent, undefined when invalid
+ */
+function parseTimezone(text) {
+  if (text === undefined) return null;
+  if (text === "Z") return 0;
+  const hours = Number(text.slice(1, 3));
+  const minutes = Number(text.slice(4));
+  if (minutes > 59 || hours > 14 || (hours === 14 && minutes > 0)) {
+    return undefined;
+  }
+  return (text[0] === "-" ? -1 : 1) * (hours * 60 + minutes);
+}
+
+/**
+ * Whether the parsed components are in range.
+ * @param {object} f - Components
+ * @returns {boolean}
+ */
+function isValid(f) {
+  if (f.month !== undefined && (f.month < 1 || f.month > 12)) return false;
+  if (f.day !== undefined) {
+    if (f.day < 1 || f.day > daysInMonth(f.year ?? 2000, f.month ?? 1)) {
+      return false;
+    }
+  }
+  if (f.hour === undefined) return true;
+  if (f.minute > 59 || f.second.compare(Decimal.of(60n)) >= 0) return false;
+  return (
+    f.hour < 24 || (f.hour === 24 && f.minute === 0 && f.second.sign() === 0)
+  );
+}
+
+/**
+ * Parses the lexical form of a date/time type (whitespace already collapsed).
+ * @param {string} kind - Primitive local name, e.g. "dateTime", "gMonthDay"
+ * @param {string} text
+ * @returns {DateTimeValue|null} null when the text is not valid
+ * @throws {XPathError} FODT0001 when the year is out of range
+ */
+export function parseDateTime(kind, text) {
+  const match = patterns[kind].exec(text);
+  if (!match) return null;
+  const names = componentsOf(kind);
+  const fields = {};
+  names.forEach((name, i) => {
+    const part = match[i + 1];
+    // "|| 0" turns the year "-0000" into 0
+    fields[name] = name === "second" ? Decimal.parse(part) : Number(part) || 0;
+  });
+  if (fields.year !== undefined) checkYear(fields.year);
+  fields.timezone = parseTimezone(match[names.length + 1]);
+  if (fields.timezone === undefined || !isValid(fields)) return null;
+  if (fields.hour === 24) {
+    fields.hour = 0;
+    if (kind === "dateTime") {
+      const [year, month, day] = civilFromDays(
+        daysFromCivil(fields.year, fields.month, fields.day) + 1,
+      );
+      Object.assign(fields, { year: checkYear(year), month, day });
+    }
+  }
+  return new DateTimeValue(fields);
+}
+
+const pad2 = (n) => String(n).padStart(2, "0");
+
+/**
+ * @param {number|null} timezone - Minutes
+ * @returns {string} "", "Z" or "±hh:mm"
+ */
+export function formatTimezone(timezone) {
+  if (timezone === null) return "";
+  if (timezone === 0) return "Z";
+  const abs = Math.abs(timezone);
+  return `${timezone < 0 ? "-" : "+"}${pad2(Math.floor(abs / 60))}:${pad2(abs % 60)}`;
+}
+
+/** Formatters of the components, by component name. */
+const componentFormats = {
+  year: (v) =>
+    (v.year < 0 ? "-" : "") + String(Math.abs(v.year)).padStart(4, "0"),
+  month: (v) => pad2(v.month),
+  day: (v) => pad2(v.day),
+  hour: (v) => pad2(v.hour),
+  minute: (v) => pad2(v.minute),
+  second: (v) => v.second.toString().replace(/^(\d)(?!\d)/, "0$1"),
+};
+const separators = {
+  dateTime: ["", "-", "-", "T", ":", ":"],
+  date: ["", "-", "-"],
+  time: ["", ":", ":"],
+  gYearMonth: ["", "-"],
+  gYear: [""],
+  gMonthDay: ["--", "-"],
+  gDay: ["---"],
+  gMonth: ["--"],
+};
+
+/**
+ * Canonical string of a date/time value (the local value with its own
+ * timezone, F&O 3.1 19.1.2).
+ * @param {string} kind - Primitive local name
+ * @param {DateTimeValue} value
+ * @returns {string}
+ */
+export function formatDateTime(kind, value) {
+  const parts = componentsOf(kind).map(
+    (name, i) => separators[kind][i] + componentFormats[name](value),
+  );
+  return parts.join("") + formatTimezone(value.timezone);
+}

package/src/xdm/decimal.js

@@ -0,0 +1,200 @@
+/**
+ * Exact arbitrary-precision decimal numbers for xs:decimal.
+ *
+ * A value is `unscaled × 10^-scale` with a BigInt `unscaled` and a
+ * non-negative integer `scale`. Values are kept normalized (no trailing
+ * zero digits in the fraction), so equal numbers have equal fields.
+ * No floating point is involved anywhere.
+ *
+ * @module @tradik/xslt3/xdm/decimal
+ */
+
+/**
+ * Number of fraction digits kept by {@link Decimal#div} when both operands
+ * have fewer: the precision of xs:decimal division (implementation-defined
+ * in F&O 3.1 section 4.2). Results are rounded half-down, like Saxon.
+ */
+export const DIVISION_SCALE = 18;
+
+const lexicalPattern = /^([+-]?)(\d*)(?:\.(\d*))?$/;
+
+/** @param {number} n @returns {bigint} 10^n */
+const pow10 = (n) => 10n ** BigInt(n);
+
+/** An immutable exact decimal number. */
+export class Decimal {
+  /**
+   * Use {@link Decimal.of} or {@link Decimal.parse}; the constructor does
+   * not normalize.
+   * @param {bigint} unscaled
+   * @param {number} scale
+   */
+  constructor(unscaled, scale) {
+    this.unscaled = unscaled;
+    this.scale = scale;
+    Object.freeze(this);
+  }
+
+  /**
+   * Builds a normalized decimal `unscaled × 10^-scale`.
+   * @param {bigint} unscaled
+   * @param {number} [scale=0] - May be negative (multiplies by 10^-scale)
+   * @returns {Decimal}
+   */
+  static of(unscaled, scale = 0) {
+    if (scale < 0) return new Decimal(unscaled * pow10(-scale), 0);
+    while (scale > 0 && unscaled % 10n === 0n) {
+      unscaled /= 10n;
+      scale--;
+    }
+    return new Decimal(
+      unscaled === 0n ? 0n : unscaled,
+      unscaled === 0n ? 0 : scale,
+    );
+  }
+
+  /**
+   * Parses the xs:decimal lexical form `[+-]?(\d+(\.\d*)?|\.\d+)` (no
+   * whitespace).
+   * @param {string} text
+   * @returns {Decimal|null} null when the text is not a decimal literal
+   */
+  static parse(text) {
+    const match = lexicalPattern.exec(text);
+    if (!match) return null;
+    const [, sign, whole, fraction = ""] = match;
+    if (whole === "" && fraction === "") return null;
+    const unscaled = BigInt(`${whole}${fraction}`);
+    return Decimal.of(sign === "-" ? -unscaled : unscaled, fraction.length);
+  }
+
+  /** @returns {number} -1, 0 or 1 */
+  sign() {
+    return this.unscaled < 0n ? -1 : this.unscaled > 0n ? 1 : 0;
+  }
+
+  /** @returns {boolean} true when the value has no fraction part */
+  isInteger() {
+    return this.scale === 0;
+  }
+
+  /** @returns {Decimal} the negated value */
+  neg() {
+    return new Decimal(-this.unscaled, this.scale);
+  }
+
+  /**
+   * Both operands as BigInts at a common scale.
+   * @param {Decimal} other
+   * @returns {[bigint, bigint, number]} [this, other, scale]
+   */
+  align(other) {
+    const scale = Math.max(this.scale, other.scale);
+    return [
+      this.unscaled * pow10(scale - this.scale),
+      other.unscaled * pow10(scale - other.scale),
+      scale,
+    ];
+  }
+
+  /** @param {Decimal} other @returns {Decimal} this + other */
+  add(other) {
+    const [a, b, scale] = this.align(other);
+    return Decimal.of(a + b, scale);
+  }
+
+  /** @param {Decimal} other @returns {Decimal} this - other */
+  sub(other) {
+    return this.add(other.neg());
+  }
+
+  /** @param {Decimal} other @returns {Decimal} this × other */
+  mul(other) {
+    return Decimal.of(this.unscaled * other.unscaled, this.scale + other.scale);
+  }
+
+  /**
+   * Division to `max(DIVISION_SCALE, this.scale, other.scale)` fraction
+   * digits, rounded half-down (ties toward zero). The divisor must not be
+   * zero.
+   * @param {Decimal} other
+   * @returns {Decimal}
+   */
+  div(other) {
+    const scale = Math.max(DIVISION_SCALE, this.scale, other.scale);
+    // this / other × 10^scale = (u1 × 10^(scale + s2 - s1)) / u2
+    let numerator = this.unscaled;
+    const shift = scale + other.scale - this.scale;
+    numerator *= pow10(shift);
+    let denominator = other.unscaled;
+    if (denominator < 0n) {
+      numerator = -numerator;
+      denominator = -denominator;
+    }
+    let quotient = numerator / denominator;
+    const remainder2 = 2n * (numerator % denominator);
+    if (remainder2 > denominator) quotient++;
+    else if (-remainder2 > denominator) quotient--;
+    return Decimal.of(quotient, scale);
+  }
+
+  /**
+   * Integer division truncating toward zero; the divisor must not be zero.
+   * @param {Decimal} other
+   * @returns {bigint}
+   */
+  idiv(other) {
+    const [a, b] = this.align(other);
+    return a / b;
+  }
+
+  /**
+   * Remainder with the sign of the dividend (`a - b × (a idiv b)`).
+   * @param {Decimal} other - Non-zero divisor
+   * @returns {Decimal}
+   */
+  mod(other) {
+    const [a, b, scale] = this.align(other);
+    return Decimal.of(a % b, scale);
+  }
+
+  /** @param {Decimal} other @returns {number} -1, 0 or 1 */
+  compare(other) {
+    const [a, b] = this.align(other);
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+
+  /** @returns {bigint} the value with the fraction discarded */
+  trunc() {
+    return this.unscaled / pow10(this.scale);
+  }
+
+  /** @returns {bigint} the largest integer not above the value */
+  floor() {
+    const t = this.trunc();
+    return this.unscaled < 0n && this.scale > 0 ? t - 1n : t;
+  }
+
+  /** @returns {number} the nearest double (correctly rounded) */
+  toNumber() {
+    return Number(this.toString());
+  }
+
+  /**
+   * Canonical lexical form: no "+" sign, no leading zeros, no trailing
+   * fraction zeros, no decimal point for integers ("1", "-0.5", "0").
+   * @returns {string}
+   */
+  toString() {
+    const negative = this.unscaled < 0n;
+    const digits = (negative ? -this.unscaled : this.unscaled).toString();
+    const sign = negative ? "-" : "";
+    if (this.scale === 0) return sign + digits;
+    const padded = digits.padStart(this.scale + 1, "0");
+    const point = padded.length - this.scale;
+    return `${sign}${padded.slice(0, point)}.${padded.slice(point)}`;
+  }
+}
+
+/** The decimal zero. */
+Decimal.ZERO = Decimal.of(0n);

package/src/xdm/duration.js

@@ -0,0 +1,128 @@
+/**
+ * The duration types (xs:duration, xs:yearMonthDuration,
+ * xs:dayTimeDuration): lexical parsing per XSD 1.1 Part 2 and canonical
+ * strings per F&O 3.1 19.1.2.
+ *
+ * A value is a frozen {@link DurationValue} `{ months, seconds }` with an
+ * integer number of months and a {@link Decimal} number of seconds of the
+ * same sign (XSD 1.1 value space).
+ *
+ * @module @tradik/xslt3/xdm/duration
+ */
+
+import { XPathError } from "../errors.js";
+import { Decimal } from "./decimal.js";
+
+/** A duration value. */
+export class DurationValue {
+  /**
+   * @param {number} months - Safe integer
+   * @param {Decimal} seconds
+   * @throws {XPathError} FODT0002 when the months exceed the safe range
+   */
+  constructor(months, seconds) {
+    if (!Number.isSafeInteger(months)) {
+      throw new XPathError(
+        "FODT0002",
+        "Duration is out of the supported range",
+      );
+    }
+    this.months = months + 0; // no negative zero
+    this.seconds = seconds;
+    Object.freeze(this);
+  }
+}
+
+/** The zero duration. */
+export const ZERO_DURATION = new DurationValue(0, Decimal.ZERO);
+
+// seconds need digits on both sides of a decimal point, as in XSD 1.0
+// ("PT.5S" and "PT1.S" are errors, qt3tests CastAs688-691)
+const pattern =
+  /^(-)?P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
+
+/** Components allowed per primitive type (indexes into the pattern groups). */
+const allowed = {
+  duration: [2, 3, 4, 5, 6, 7],
+  yearMonthDuration: [2, 3],
+  dayTimeDuration: [4, 5, 6, 7],
+};
+
+/**
+ * Parses a duration lexical form (whitespace already collapsed).
+ * @param {string} kind - "duration", "yearMonthDuration" or "dayTimeDuration"
+ * @param {string} text
+ * @returns {DurationValue|null} null when invalid
+ * @throws {XPathError} FODT0002 when out of the supported range
+ */
+export function parseDuration(kind, text) {
+  const match = pattern.exec(text);
+  if (!match || text.endsWith("T")) return null;
+  const present = [2, 3, 4, 5, 6, 7].filter((i) => match[i] !== undefined);
+  if (present.length === 0 || present.some((i) => !allowed[kind].includes(i))) {
+    return null;
+  }
+  const [
+    ,
+    sign,
+    years = "0",
+    months = "0",
+    days = "0",
+    hours = "0",
+    minutes = "0",
+  ] = match;
+  const totalMonths = BigInt(years) * 12n + BigInt(months);
+  const whole =
+    (BigInt(days) * 24n + BigInt(hours)) * 60n * 60n + BigInt(minutes) * 60n;
+  let seconds = Decimal.of(whole).add(Decimal.parse(match[7] ?? "0"));
+  let monthCount = Number(totalMonths);
+  if (totalMonths > BigInt(Number.MAX_SAFE_INTEGER)) monthCount = Infinity;
+  if (sign) {
+    seconds = seconds.neg();
+    monthCount = -monthCount;
+  }
+  return new DurationValue(monthCount, seconds);
+}
+
+/**
+ * @param {number} months
+ * @returns {string} "nYnM" part without sign, "" for zero
+ */
+function yearMonthPart(months) {
+  const abs = Math.abs(months);
+  const years = Math.floor(abs / 12);
+  return (years ? `${years}Y` : "") + (abs % 12 ? `${abs % 12}M` : "");
+}
+
+/**
+ * @param {Decimal} seconds
+ * @returns {string} "nDTnHnMnS" part without sign, "" for zero
+ */
+function dayTimePart(seconds) {
+  const abs = seconds.sign() < 0 ? seconds.neg() : seconds;
+  const whole = abs.trunc();
+  const days = whole / 86400n;
+  const hours = (whole / 3600n) % 24n;
+  const minutes = (whole / 60n) % 60n;
+  const secs = abs.sub(Decimal.of(whole - (whole % 60n)));
+  const time =
+    (hours ? `${hours}H` : "") +
+    (minutes ? `${minutes}M` : "") +
+    (secs.sign() ? `${secs}S` : "");
+  return (days ? `${days}D` : "") + (time ? `T${time}` : "");
+}
+
+/**
+ * Canonical string of a duration: "P2Y", "P1DT12H", "-PT1.5S"; the zero
+ * duration is "P0M" for xs:yearMonthDuration and "PT0S" otherwise.
+ * @param {string} kind - "duration", "yearMonthDuration" or "dayTimeDuration"
+ * @param {DurationValue} value
+ * @returns {string}
+ */
+export function formatDuration(kind, value) {
+  const months = kind === "dayTimeDuration" ? 0 : value.months;
+  const seconds = kind === "yearMonthDuration" ? Decimal.ZERO : value.seconds;
+  const body = yearMonthPart(months) + dayTimePart(seconds);
+  if (body === "") return kind === "yearMonthDuration" ? "P0M" : "PT0S";
+  return `${months < 0 || seconds.sign() < 0 ? "-" : ""}P${body}`;
+}

package/src/xdm/generalCompare.js

@@ -0,0 +1,152 @@
+/**
+ * General comparisons (=, !=, <, <=, >, >=) of XPath 3.1 section 3.7.2,
+ * with the XPath 1.0 compatibility mode rules.
+ *
+ * @module @tradik/xslt3/xdm/generalCompare
+ */
+
+import { XPathError } from "../errors.js";
+import { AtomicValue } from "./atomic.js";
+import { cast } from "./cast.js";
+import { orderTests, valueCompare } from "./compare.js";
+import { atomize, effectiveBooleanValue } from "./nodes.js";
+import { compareCodepoints } from "./strings.js";
+import { derivesFrom, isNumericType, types } from "./types.js";
+
+const valueOperators = {
+  "=": "eq",
+  "!=": "ne",
+  "<": "lt",
+  "<=": "le",
+  ">": "gt",
+  ">=": "ge",
+};
+
+const isUntyped = (item) => item.type === types.untypedAtomic;
+/** xs:untypedAtomic or xs:string itself (not a subtype). */
+const isPlainString = (item) =>
+  item.type === types.untypedAtomic || item.type === types.string;
+
+const isString = (item) => derivesFrom(item.type, types.string);
+
+/**
+ * fn:number of an atomic value: its xs:double value, or NaN when it cannot
+ * be cast.
+ * @param {AtomicValue} item
+ * @returns {AtomicValue} an xs:double
+ */
+export function toNumber(item) {
+  try {
+    return cast(item, types.double);
+  } catch (error) {
+    if (!(error instanceof XPathError)) throw error;
+    return new AtomicValue(types.double, NaN);
+  }
+}
+
+/**
+ * Converts an untyped operand for comparison with a typed one (XPath 3.1).
+ * @param {AtomicValue} untyped
+ * @param {AtomicValue} other
+ * @returns {AtomicValue}
+ */
+function castUntyped(untyped, other) {
+  if (isNumericType(other.type)) return cast(untyped, types.double);
+  for (const duration of [types.dayTimeDuration, types.yearMonthDuration]) {
+    if (derivesFrom(other.type, duration)) return cast(untyped, duration);
+  }
+  return cast(untyped, other.type.primitive);
+}
+
+/**
+ * Prepares a pair of atomic values (XPath 3.1 mode). Two untyped values
+ * compare as strings, which generalCompare does without converting them.
+ * @returns {[AtomicValue, AtomicValue]}
+ */
+function convertPair(a, b) {
+  if (isUntyped(a)) return [castUntyped(a, b), b];
+  if (isUntyped(b)) return [a, castUntyped(b, a)];
+  return [a, b];
+}
+
+/**
+ * Prepares a pair of atomic values (XPath 1.0 compatibility mode).
+ * @returns {[AtomicValue, AtomicValue]}
+ */
+function convertPairCompatible(a, b) {
+  if (isNumericType(a.type) || isNumericType(b.type)) {
+    return [toNumber(a), toNumber(b)];
+  }
+  if (isString(a) || isString(b) || (isUntyped(a) && isUntyped(b))) {
+    return [cast(a, types.string), cast(b, types.string)];
+  }
+  if (isUntyped(a)) return [cast(a, b.type), b];
+  if (isUntyped(b)) return [a, cast(b, a.type)];
+  return [a, b];
+}
+
+/**
+ * Whether an operand is a single xs:boolean atomic value.
+ * @param {Array} sequence
+ * @returns {boolean}
+ */
+function isSingleBoolean(sequence) {
+  return (
+    sequence.length === 1 &&
+    sequence[0] instanceof AtomicValue &&
+    sequence[0].type.primitive === types.boolean
+  );
+}
+
+/**
+ * Evaluates a general comparison of two sequences: true when some pair of
+ * atomized items has the relationship.
+ * @param {Array} left - Sequence of items (atomized here)
+ * @param {"="|"!="|"<"|"<="|">"|">="} op
+ * @param {Array} right
+ * @param {import("./compare.js").CompareOptions & {backwardsCompatible?: boolean}} [options]
+ *   - `backwardsCompatible` enables the XPath 1.0 compatibility mode
+ * @returns {boolean}
+ * @throws {XPathError} XPTY0004 for incomparable types, FORG0001 when an
+ *   untyped value cannot be cast
+ */
+export function generalCompare(left, op, right, options = {}) {
+  const valueOp = valueOperators[op];
+  if (!valueOp) {
+    throw new TypeError(`Unknown general comparison operator ${op}`);
+  }
+  let a = left;
+  let b = right;
+  let convert = convertPair;
+  if (options.backwardsCompatible) {
+    convert = convertPairCompatible;
+    if (isSingleBoolean(a) || isSingleBoolean(b)) {
+      const toBoolean = (s) => [
+        new AtomicValue(types.boolean, effectiveBooleanValue(s)),
+      ];
+      a = isSingleBoolean(a) ? a : toBoolean(a);
+      b = isSingleBoolean(b) ? b : toBoolean(b);
+    }
+  }
+  a = atomize(a);
+  b = atomize(b);
+  if (options.backwardsCompatible && valueOp !== "eq" && valueOp !== "ne") {
+    a = a.map(toNumber);
+    b = b.map(toNumber);
+  }
+  const collation = options.collation ?? compareCodepoints;
+  const holds = orderTests[valueOp];
+  for (const x of a) {
+    for (const y of b) {
+      // Strings and untyped values compare as strings in both modes:
+      // skip the casts and the result objects of valueCompare
+      if (isPlainString(x) && isPlainString(y)) {
+        if (holds(collation(x.value, y.value))) return true;
+        continue;
+      }
+      const [p, q] = convert(x, y);
+      if (valueCompare(p, valueOp, q, options)) return true;
+    }
+  }
+  return false;
+}