@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xdm/temporalArithmetic.js

@@ -0,0 +1,180 @@
+/**
+ * Arithmetic on durations, dates and times (F&O 3.1 sections 8.2 and
+ * 10.8): duration ± duration, duration × / div number, duration div
+ * duration, date/time ± duration and date/time − date/time.
+ *
+ * @module @tradik/xslt3/xdm/temporalArithmetic
+ */
+
+import { XPathError } from "../errors.js";
+import { AtomicValue } from "./atomic.js";
+import { daysInMonth } from "./calendar.js";
+import { checkYear, componentsOf, DateTimeValue } from "./datetime.js";
+import { fromLocalSeconds, localSeconds, timelineSeconds } from "./timeline.js";
+import { Decimal } from "./decimal.js";
+import { DurationValue } from "./duration.js";
+import { numberToDecimal } from "./numeric.js";
+import { derivesFrom, isNumericType, types } from "./types.js";
+
+const HALF = Decimal.parse("0.5");
+const ONE_DAY = Decimal.of(86400n);
+/** Local seconds of midnight of the reference date of xs:time values. */
+const REFERENCE_DAY = localSeconds(new DateTimeValue({}));
+
+/**
+ * Operand category for the operator mapping.
+ * @param {AtomicValue} item
+ * @returns {string|null} "yearMonth", "dayTime", "dateTime", "date",
+ *   "time", "numeric" or null
+ */
+function category(item) {
+  if (derivesFrom(item.type, types.yearMonthDuration)) return "yearMonth";
+  if (derivesFrom(item.type, types.dayTimeDuration)) return "dayTime";
+  if (isNumericType(item.type)) return "numeric";
+  const primitive = item.type.primitive.localName;
+  return ["dateTime", "date", "time"].includes(primitive) ? primitive : null;
+}
+
+/**
+ * @param {"yearMonth"|"dayTime"} kind
+ * @param {Decimal} amount - Months (integral) or seconds
+ * @returns {AtomicValue}
+ */
+function duration(kind, amount) {
+  return kind === "yearMonth"
+    ? new AtomicValue(
+        types.yearMonthDuration,
+        new DurationValue(amount.toNumber(), Decimal.ZERO),
+      )
+    : new AtomicValue(types.dayTimeDuration, new DurationValue(0, amount));
+}
+
+/** @param {AtomicValue} item @param {string} kind @returns {Decimal} */
+const amountOf = (item, kind) =>
+  kind === "yearMonth"
+    ? Decimal.of(BigInt(item.value.months))
+    : item.value.seconds;
+
+/**
+ * Numeric operand of duration × and div as an exact decimal.
+ * @param {AtomicValue} item
+ * @param {boolean} divide - Whether it is a divisor
+ * @returns {Decimal|null} null for an infinite divisor (result zero)
+ */
+function factor(item, divide) {
+  const { value } = item;
+  if (typeof value === "bigint") return Decimal.of(value);
+  if (value instanceof Decimal) return value;
+  if (Number.isNaN(value)) {
+    throw new XPathError("FOCA0005", "NaN in duration arithmetic");
+  }
+  if (!Number.isFinite(value)) {
+    if (divide) return null;
+    throw new XPathError("FODT0002", "Duration overflow");
+  }
+  return numberToDecimal(value);
+}
+
+/** Months rounded half toward positive infinity (F&O 8.2.3). */
+const roundMonths = (amount) => Decimal.of(amount.add(HALF).floor());
+
+/** duration × number and duration div number. */
+function scaleDuration(item, kind, op, number) {
+  const n = factor(number, op === "div");
+  if (n === null) return duration(kind, Decimal.ZERO);
+  if (op === "div" && n.sign() === 0) {
+    throw new XPathError("FODT0002", "Duration division by zero");
+  }
+  const amount =
+    op === "div" ? amountOf(item, kind).div(n) : amountOf(item, kind).mul(n);
+  return duration(kind, kind === "yearMonth" ? roundMonths(amount) : amount);
+}
+
+/**
+ * Adds a duration (signed) to a date, time or dateTime.
+ * @param {AtomicValue} item - xs:dateTime, xs:date or xs:time
+ * @param {string} kind - Its category
+ * @param {DurationValue} delta
+ * @returns {AtomicValue}
+ */
+function addToDateTime(item, kind, delta) {
+  let value = item.value;
+  if (delta.months !== 0) {
+    const total = value.year * 12 + (value.month - 1) + delta.months;
+    const year = checkYear(Math.floor(total / 12));
+    const month = total - year * 12 + 1;
+    const day = Math.min(value.day, daysInMonth(year, month));
+    value = new DateTimeValue({ ...value, year, month, day });
+  }
+  let seconds = localSeconds(value).add(delta.seconds);
+  if (kind === "time") {
+    // wrap around midnight: seconds of the day modulo 86400
+    seconds = seconds.sub(REFERENCE_DAY).mod(ONE_DAY);
+    if (seconds.sign() < 0) seconds = seconds.add(ONE_DAY);
+  }
+  const result = fromLocalSeconds(seconds, value.timezone);
+  const fields = { timezone: value.timezone };
+  for (const name of componentsOf(kind)) fields[name] = result[name];
+  return new AtomicValue(types[kind], new DateTimeValue(fields));
+}
+
+/**
+ * Applies a date/time or duration operator (appendix B.2 mapping).
+ * @param {AtomicValue} a - Already prepared (no xs:untypedAtomic)
+ * @param {string} op
+ * @param {AtomicValue} b
+ * @param {{implicitTimezone?: number}} options
+ * @returns {AtomicValue}
+ * @throws {XPathError} XPTY0004 when no operator matches the types
+ */
+export function temporalArithmetic(a, op, b, options) {
+  const ka = category(a);
+  const kb = category(b);
+  const durations = ["yearMonth", "dayTime"];
+  const times = ["dateTime", "date", "time"];
+  const sameDuration = ka === kb && durations.includes(ka);
+  if (sameDuration && (op === "+" || op === "-")) {
+    const delta = op === "+" ? amountOf(b, kb) : amountOf(b, kb).neg();
+    return duration(ka, amountOf(a, ka).add(delta));
+  }
+  if (sameDuration && op === "div") {
+    if (amountOf(b, kb).sign() === 0) {
+      throw new XPathError("FOAR0001", "Duration division by zero");
+    }
+    return new AtomicValue(types.decimal, amountOf(a, ka).div(amountOf(b, kb)));
+  }
+  if (
+    durations.includes(ka) &&
+    kb === "numeric" &&
+    (op === "*" || op === "div")
+  ) {
+    return scaleDuration(a, ka, op, b);
+  }
+  if (ka === "numeric" && durations.includes(kb) && op === "*") {
+    return scaleDuration(b, kb, op, a);
+  }
+  const timeOk = (t, d) =>
+    times.includes(t) &&
+    durations.includes(d) &&
+    !(t === "time" && d === "yearMonth");
+  if (timeOk(ka, kb) && (op === "+" || op === "-")) {
+    const { months, seconds } = b.value;
+    const delta =
+      op === "+" ? b.value : new DurationValue(-months, seconds.neg());
+    return addToDateTime(a, ka, delta);
+  }
+  if (timeOk(kb, ka) && op === "+") return addToDateTime(b, kb, a.value);
+  if (ka === kb && times.includes(ka) && op === "-") {
+    const timezone = options.implicitTimezone ?? 0;
+    return duration(
+      "dayTime",
+      timelineSeconds(a.value, timezone).sub(
+        timelineSeconds(b.value, timezone),
+      ),
+    );
+  }
+  throw new XPathError(
+    "XPTY0004",
+    `${op} is not defined for ${a.type.prefixedName} and ${b.type.prefixedName}`,
+  );
+}

package/src/xdm/timeline.js

@@ -0,0 +1,68 @@
+/**
+ * Positions of date/time values on the time line, in seconds, for
+ * comparison and arithmetic (F&O 3.1 sections 10.4 and 10.8).
+ *
+ * @module @tradik/xslt3/xdm/timeline
+ */
+
+import { civilFromDays, daysFromCivil } from "./calendar.js";
+import { checkYear, DateTimeValue } from "./datetime.js";
+import { Decimal } from "./decimal.js";
+
+/**
+ * Seconds of the local value (ignoring the timezone) since
+ * 1970-01-01T00:00:00, with the reference date 1972-01-01 for absent date
+ * components (F&O 3.1 section 10.4 uses 1972 as reference year; the
+ * reference month and day do not change comparisons within one type).
+ * @param {DateTimeValue} value
+ * @returns {Decimal}
+ */
+export function localSeconds(value) {
+  const days = daysFromCivil(
+    value.year ?? 1972,
+    value.month ?? 1,
+    value.day ?? 1,
+  );
+  const whole =
+    BigInt(days) * 86400n +
+    BigInt((value.hour ?? 0) * 3600 + (value.minute ?? 0) * 60);
+  return Decimal.of(whole).add(value.second ?? Decimal.ZERO);
+}
+
+/**
+ * Position on the time line in seconds (UTC), using the implicit timezone
+ * when the value has none.
+ * @param {DateTimeValue} value
+ * @param {number} implicitTimezone - Minutes
+ * @returns {Decimal}
+ */
+export function timelineSeconds(value, implicitTimezone) {
+  const offset = value.timezone ?? implicitTimezone;
+  return localSeconds(value).sub(Decimal.of(BigInt(offset * 60)));
+}
+
+/**
+ * Date and time components of a local-seconds value (inverse of
+ * {@link localSeconds} for full date-times).
+ * @param {Decimal} seconds
+ * @param {number|null} timezone - Kept as the timezone of the result
+ * @returns {DateTimeValue}
+ * @throws {XPathError} FODT0001 when the year is out of range
+ */
+export function fromLocalSeconds(seconds, timezone) {
+  const wholeSeconds = seconds.floor();
+  const days = wholeSeconds / 86400n - (wholeSeconds % 86400n < 0n ? 1n : 0n);
+  const inDay = Number(wholeSeconds - days * 86400n);
+  const [year, month, day] = civilFromDays(Number(days));
+  return new DateTimeValue({
+    year: checkYear(year),
+    month,
+    day,
+    hour: Math.floor(inDay / 3600),
+    minute: Math.floor(inDay / 60) % 60,
+    second: Decimal.of(BigInt(inDay % 60)).add(
+      seconds.sub(Decimal.of(wholeSeconds)),
+    ),
+    timezone,
+  });
+}

package/src/xdm/types.js

@@ -0,0 +1,178 @@
+/**
+ * Registry of the built-in atomic types of XDM 3.1 for a basic
+ * (non-schema-aware) processor, with the XSD 1.1 derivation hierarchy.
+ *
+ * A type descriptor has:
+ * - `name`: expanded QName in Clark notation, `{http://www.w3.org/2001/XMLSchema}integer`
+ * - `localName`, `prefixedName` ("xs:integer")
+ * - `base`: the descriptor it is derived from (null for xs:anyAtomicType and xs:error)
+ * - `primitive`: the XSD primitive ancestor-or-self (xs:integer → xs:decimal);
+ *   xs:untypedAtomic is its own primitive
+ * - `castPrimitive`: the "primitive type" of F&O 3.1 section 19, which also
+ *   counts xs:integer, xs:yearMonthDuration and xs:dayTimeDuration
+ * - `whiteSpace`: "preserve", "replace" or "collapse"
+ * - `abstract`: true for types with no direct instances
+ * - `facets`: `{ minInclusive?, maxInclusive? }` (BigInt) for integer types,
+ *   `{ pattern?: RegExp }` for string types, `{ timezoneRequired? }`
+ *
+ * @module @tradik/xslt3/xdm/types
+ */
+
+import { XPathError } from "../errors.js";
+
+/** The XML Schema namespace URI. */
+export const XS_NAMESPACE = "http://www.w3.org/2001/XMLSchema";
+
+const nameStart =
+  "A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF" +
+  "\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF" +
+  "\\uFDF0-\\uFFFD\\u{10000}-\\u{EFFFF}";
+const nameChar = `${nameStart}\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040`;
+
+/** Patterns of the XML name productions (XML 1.0 fifth edition). */
+/* eslint-disable no-misleading-character-class -- NameChar includes the
+   combining marks U+0300 to U+036F on their own, as the XML grammar says */
+export const namePatterns = Object.freeze({
+  ncName: new RegExp(`^[${nameStart}][${nameChar}]*$`, "u"),
+  name: new RegExp(`^[:${nameStart}][:${nameChar}]*$`, "u"),
+  nmToken: new RegExp(`^[:${nameChar}]+$`, "u"),
+});
+/* eslint-enable no-misleading-character-class */
+
+/** @type {Map<string, object>} descriptors by local name */
+const byLocalName = new Map();
+
+/**
+ * Registers a built-in type.
+ * @param {string} localName
+ * @param {string|null} baseName
+ * @param {object} [options] - whiteSpace, abstract, facets, castPrimitive
+ */
+function define(localName, baseName, options = {}) {
+  const base = baseName === null ? null : byLocalName.get(baseName);
+  const type = {
+    name: `{${XS_NAMESPACE}}${localName}`,
+    localName,
+    prefixedName: `xs:${localName}`,
+    base,
+    whiteSpace: options.whiteSpace ?? base?.whiteSpace ?? "collapse",
+    abstract: options.abstract ?? false,
+    facets: Object.freeze({ ...options.facets }),
+  };
+  const primitiveRoot = base === null || base.localName === "anyAtomicType";
+  type.primitive = primitiveRoot ? type : base.primitive;
+  type.castPrimitive =
+    options.castPrimitive || primitiveRoot ? type : base.castPrimitive;
+  byLocalName.set(localName, Object.freeze(type));
+}
+
+const range = (min, max) => ({
+  facets: { minInclusive: min ?? undefined, maxInclusive: max ?? undefined },
+});
+
+define("anyAtomicType", null, { abstract: true });
+define("error", null);
+define("untypedAtomic", "anyAtomicType", { whiteSpace: "preserve" });
+define("string", "anyAtomicType", { whiteSpace: "preserve" });
+define("normalizedString", "string", { whiteSpace: "replace" });
+define("token", "normalizedString", { whiteSpace: "collapse" });
+define("language", "token", {
+  facets: { pattern: /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/ },
+});
+define("NMTOKEN", "token", { facets: { pattern: namePatterns.nmToken } });
+define("Name", "token", { facets: { pattern: namePatterns.name } });
+define("NCName", "Name", { facets: { pattern: namePatterns.ncName } });
+for (const name of ["ID", "IDREF", "ENTITY"]) define(name, "NCName");
+define("boolean", "anyAtomicType");
+define("decimal", "anyAtomicType");
+define("integer", "decimal", { castPrimitive: true });
+define("nonPositiveInteger", "integer", range(null, 0n));
+define("negativeInteger", "nonPositiveInteger", range(null, -1n));
+define("long", "integer", range(-(2n ** 63n), 2n ** 63n - 1n));
+define("int", "long", range(-(2n ** 31n), 2n ** 31n - 1n));
+define("short", "int", range(-32768n, 32767n));
+define("byte", "short", range(-128n, 127n));
+define("nonNegativeInteger", "integer", range(0n, null));
+define("unsignedLong", "nonNegativeInteger", range(0n, 2n ** 64n - 1n));
+define("unsignedInt", "unsignedLong", range(0n, 2n ** 32n - 1n));
+define("unsignedShort", "unsignedInt", range(0n, 65535n));
+define("unsignedByte", "unsignedShort", range(0n, 255n));
+define("positiveInteger", "nonNegativeInteger", range(1n, null));
+define("float", "anyAtomicType");
+define("double", "anyAtomicType");
+define("duration", "anyAtomicType");
+define("yearMonthDuration", "duration", { castPrimitive: true });
+define("dayTimeDuration", "duration", { castPrimitive: true });
+define("dateTime", "anyAtomicType");
+define("dateTimeStamp", "dateTime", { facets: { timezoneRequired: true } });
+for (const name of [
+  "date",
+  "time",
+  "gYearMonth",
+  "gYear",
+  "gMonthDay",
+  "gDay",
+  "gMonth",
+]) {
+  define(name, "anyAtomicType");
+}
+define("hexBinary", "anyAtomicType");
+define("base64Binary", "anyAtomicType");
+define("anyURI", "anyAtomicType");
+define("QName", "anyAtomicType");
+define("NOTATION", "anyAtomicType", { abstract: true });
+
+const clarkPattern = new RegExp(
+  `^\\{${XS_NAMESPACE.replaceAll(".", "\\.")}\\}(.+)$`,
+);
+
+/**
+ * Looks up a built-in atomic type.
+ * @param {string|object} name - A descriptor, "xs:integer", "integer" or
+ *   "{http://www.w3.org/2001/XMLSchema}integer"
+ * @returns {object} the type descriptor
+ * @throws {XPathError} XPST0051 for an unknown type name
+ */
+export function getType(name) {
+  if (typeof name === "object" && name !== null) return name;
+  const localName = String(name)
+    .replace(/^xs:/, "")
+    .replace(clarkPattern, "$1");
+  const type = byLocalName.get(localName);
+  if (!type) throw new XPathError("XPST0051", `Unknown atomic type ${name}`);
+  return type;
+}
+
+/**
+ * Whether a type is the same as or derived (by restriction) from another.
+ * Every atomic type derives from xs:anyAtomicType; xs:error from nothing.
+ * @param {object|string} type
+ * @param {object|string} ancestor
+ * @returns {boolean}
+ */
+export function derivesFrom(type, ancestor) {
+  const target = getType(ancestor);
+  for (let t = getType(type); t !== null; t = t.base) {
+    if (t === target) return true;
+  }
+  return false;
+}
+
+/** @returns {object[]} all registered type descriptors */
+export function allTypes() {
+  return [...byLocalName.values()];
+}
+
+/** @type {Readonly<Record<string, object>>} descriptors by local name */
+export const types = Object.freeze(Object.fromEntries(byLocalName));
+
+const numericNames = new Set(["decimal", "float", "double"]);
+
+/**
+ * Whether a type is numeric (xs:decimal, xs:float, xs:double or derived).
+ * @param {object} type
+ * @returns {boolean}
+ */
+export function isNumericType(type) {
+  return numericNames.has(type.primitive.localName);
+}

package/src/xpath/eval/atomics.js

@@ -0,0 +1,45 @@
+/**
+ * Shorthands for building atomic values of the common types and for
+ * reading single values out of sequences.
+ *
+ * @module @tradik/xslt3/xpath/eval/atomics
+ */
+
+import { XPathError } from "../../errors.js";
+import { AtomicValue } from "../../xdm/atomic.js";
+import { atomize } from "../../xdm/nodes.js";
+import { types } from "../../xdm/types.js";
+
+const TRUE = new AtomicValue(types.boolean, true);
+const FALSE = new AtomicValue(types.boolean, false);
+
+/** @param {boolean} value @returns {AtomicValue} an xs:boolean */
+export const booleanItem = (value) => (value ? TRUE : FALSE);
+
+/** @param {bigint|number} value @returns {AtomicValue} an xs:integer */
+export const integerItem = (value) =>
+  new AtomicValue(types.integer, BigInt(value));
+
+/** @param {string} value @returns {AtomicValue} an xs:string */
+export const stringItem = (value) => new AtomicValue(types.string, value);
+
+/** @param {number} value @returns {AtomicValue} an xs:double */
+export const doubleItem = (value) => new AtomicValue(types.double, value);
+
+/**
+ * Atomizes a sequence that must hold at most one item.
+ * @param {Array} sequence
+ * @param {string} what - Operand description for the error message
+ * @returns {AtomicValue|undefined} the atomic value, undefined when empty
+ * @throws {XPathError} XPTY0004 for more than one item
+ */
+export function atomizeOptional(sequence, what) {
+  const values = atomize(sequence);
+  if (values.length > 1) {
+    throw new XPathError(
+      "XPTY0004",
+      `The ${what} must not be a sequence of more than one item`,
+    );
+  }
+  return values[0];
+}

package/src/xpath/eval/axes.js

@@ -0,0 +1,212 @@
+/**
+ * The thirteen axes of XPath 3.1 (section 3.3.2.1) over DOM nodes. An axis
+ * function collects the nodes that pass a node test, in axis order:
+ * document order for the forward axes, reverse document order for the
+ * reverse axes (parent, ancestor, ancestor-or-self, preceding,
+ * preceding-sibling). It stops after `limit` nodes, so that `[1]` or `[2]`
+ * after a step does not walk the whole axis.
+ *
+ * Siblings are reached through nextSibling/previousSibling, so walking an
+ * axis from each of n siblings stays linear when it stops early.
+ *
+ * @module @tradik/xslt3/xpath/eval/axes
+ */
+
+import {
+  attributesOf,
+  isContainer,
+  isXdmNode,
+  namedAttributeOf,
+  parentOf,
+} from "./domNodes.js";
+import { namespaceNodesOf } from "./namespaceNodes.js";
+
+/** Axes whose order is reverse document order. */
+export const REVERSE_AXES = new Set([
+  "parent",
+  "ancestor",
+  "ancestor-or-self",
+  "preceding",
+  "preceding-sibling",
+]);
+
+/**
+ * @callback Axis
+ * @param {Node} node - Context node
+ * @param {(node: Node) => boolean} test - Node test, false for the nodes
+ *   that are not XDM nodes (document types; see nodeTests.js)
+ * @param {number} limit - Most nodes to collect
+ * @returns {Node[]} the nodes in axis order
+ */
+
+/** @param {Node} node @returns {boolean} attribute or namespace node */
+const isAttached = (node) => node.nodeType === 2 || node.nodeType === 13;
+
+/**
+ * Collects the descendants of a node in document order, walking
+ * firstChild/nextSibling/parentNode: no child arrays, and each DOM property
+ * read once per node (in jsdom every read goes through a wrapper, and
+ * childNodes through a Proxy).
+ * @param {Node} node
+ * @param {Function} test - Rejects the nodes that are not XDM nodes
+ * @param {number} limit
+ * @param {Node[]} result - Appended to
+ * @returns {boolean} true when the limit is reached
+ */
+function descendants(node, test, limit, result) {
+  if (!isContainer(node)) return false;
+  let current = node.firstChild;
+  while (current) {
+    if (test(current) && result.push(current) >= limit) return true;
+    if (current.nodeType === 1) {
+      const first = current.firstChild;
+      if (first) {
+        current = first;
+        continue;
+      }
+    }
+    let next = current.nextSibling;
+    while (!next) {
+      current = current.parentNode;
+      if (current === node || !current) return false;
+      next = current.nextSibling;
+    }
+    current = next;
+  }
+  return false;
+}
+
+/**
+ * The next or previous XDM sibling of a node.
+ * @param {Node} node
+ * @param {"nextSibling"|"previousSibling"} direction
+ * @returns {Node|null}
+ */
+function sibling(node, direction) {
+  let current = node[direction];
+  while (current && !isXdmNode(current)) {
+    current = current[direction];
+  }
+  return current ?? null;
+}
+
+/**
+ * Collects the siblings of a node in one direction.
+ * @returns {Node[]}
+ */
+function siblings(node, test, limit, direction) {
+  const result = [];
+  if (isAttached(node)) return result;
+  for (let s = sibling(node, direction); s; s = sibling(s, direction)) {
+    if (test(s) && result.push(s) >= limit) break;
+  }
+  return result;
+}
+
+/**
+ * Collects a list of candidate nodes.
+ * @param {Iterable<Node>} nodes
+ * @returns {Node[]}
+ */
+function collect(nodes, test, limit) {
+  const result = [];
+  for (const node of nodes) {
+    if (test(node) && result.push(node) >= limit) break;
+  }
+  return result;
+}
+
+/**
+ * The ancestors of a node, nearest first, optionally with the node.
+ * @param {Node} node
+ * @param {boolean} self
+ * @returns {Node[]}
+ */
+function ancestry(node, self) {
+  const chain = self ? [node] : [];
+  for (let p = parentOf(node); p; p = parentOf(p)) chain.push(p);
+  return chain;
+}
+
+/** @type {Record<string, Axis>} Axis functions by axis name. */
+export const axes = {
+  self: (node, test) => (test(node) ? [node] : []),
+  child(node, test, limit) {
+    const result = [];
+    if (!isContainer(node)) return result;
+    for (let c = node.firstChild; c; c = c.nextSibling) {
+      if (test(c) && result.push(c) >= limit) break;
+    }
+    return result;
+  },
+  attribute(node, test, limit) {
+    if (test.qname) {
+      const found = namedAttributeOf(node, test.qname.uri, test.qname.local);
+      if (found !== undefined) {
+        return found && limit > 0 && test(found) ? [found] : [];
+      }
+    }
+    return collect(attributesOf(node), test, limit);
+  },
+  namespace: (node, test, limit) =>
+    node.nodeType === 1 ? collect(namespaceNodesOf(node), test, limit) : [],
+  parent(node, test) {
+    const parent = parentOf(node);
+    return parent && test(parent) ? [parent] : [];
+  },
+  descendant(node, test, limit) {
+    const result = [];
+    descendants(node, test, limit, result);
+    return result;
+  },
+  "descendant-or-self"(node, test, limit) {
+    const result = test(node) ? [node] : [];
+    if (result.length < limit) descendants(node, test, limit, result);
+    return result;
+  },
+  ancestor: (node, test, limit) => collect(ancestry(node, false), test, limit),
+  "ancestor-or-self": (node, test, limit) =>
+    collect(ancestry(node, true), test, limit),
+  "following-sibling": (node, test, limit) =>
+    siblings(node, test, limit, "nextSibling"),
+  "preceding-sibling": (node, test, limit) =>
+    siblings(node, test, limit, "previousSibling"),
+  following(node, test, limit) {
+    const result = [];
+    let start = node;
+    if (isAttached(node)) {
+      start = parentOf(node);
+      if (!start || descendants(start, test, limit, result)) return result;
+    }
+    for (let n = start; n; n = parentOf(n)) {
+      for (
+        let s = sibling(n, "nextSibling");
+        s;
+        s = sibling(s, "nextSibling")
+      ) {
+        if (test(s) && result.push(s) >= limit) return result;
+        if (descendants(s, test, limit, result)) return result;
+      }
+    }
+    return result;
+  },
+  preceding(node, test, limit) {
+    const result = [];
+    const start = isAttached(node) ? parentOf(node) : node;
+    for (let n = start; n; n = parentOf(n)) {
+      for (
+        let s = sibling(n, "previousSibling");
+        s;
+        s = sibling(s, "previousSibling")
+      ) {
+        const subtree = [];
+        descendants(s, test, Infinity, subtree);
+        for (let i = subtree.length - 1; i >= 0; i--) {
+          if (result.push(subtree[i]) >= limit) return result;
+        }
+        if (test(s) && result.push(s) >= limit) return result;
+      }
+    }
+    return result;
+  },
+};