@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xpath/eval/resources.js

@@ -0,0 +1,149 @@
+/**
+ * Hooks of the dynamic context that reach outside the expression: text
+ * resources (fn:unparsed-text, fn:json-doc), XML parsing (fn:parse-xml)
+ * and collections (fn:collection, fn:uri-collection). Each is built from
+ * a dynamic option, with a default:
+ *
+ * - `textLoader(uri)`: returns the resource as a string, bytes, or
+ *   `{content, encoding, mediaType}`; default: no resources, so an
+ *   expression cannot read files unless the host allows it (pass
+ *   `readFileUri` to read `file:` URIs in Node.js);
+ * - `xmlParser(text, baseUri)`: returns a Document, throws when the text
+ *   is not well-formed; default: `globalThis.DOMParser` when present;
+ * - `collections(uri)`: returns the items of a collection (JavaScript
+ *   values are converted as variables are), `uri` null for the default
+ *   collection; default: no collections.
+ *
+ * @module @tradik/xslt3/xpath/eval/resources
+ */
+
+import { XPathError } from "../../errors.js";
+import { decodeText } from "../../functions/textDecoding.js";
+import { toSequence } from "./values.js";
+
+/**
+ * Reads `file:` URIs with node:fs (Node.js 22.3 and later). Not used by
+ * default: pass it as the `textLoader` option to let expressions read
+ * local files, only when the expressions are trusted.
+ * @param {string} uri - Absolute URI
+ * @returns {Uint8Array|null} the bytes, null for other schemes or
+ *   without node:fs
+ */
+export function readFileUri(uri) {
+  const fs = globalThis.process?.getBuiltinModule?.("node:fs");
+  if (!fs || !uri.startsWith("file:")) return null;
+  return fs.readFileSync(new globalThis.URL(uri));
+}
+
+/**
+ * The default text loader: no resource is available.
+ * @returns {null}
+ */
+function noResources() {
+  return null;
+}
+
+/**
+ * The absolute URI of a resource reference.
+ * @param {string} href
+ * @param {string|undefined} baseUri - Static base URI
+ * @returns {string}
+ * @throws {XPathError} FOUT1170 for a fragment identifier, an invalid URI
+ *   or a relative URI without base
+ */
+export function resourceUri(href, baseUri) {
+  if (href.includes("#") || /%(?![0-9A-Fa-f]{2})/.test(href)) {
+    throw new XPathError("FOUT1170", `Invalid resource URI ${href}`);
+  }
+  try {
+    return new globalThis.URL(href, baseUri).href;
+  } catch (error) {
+    throw new XPathError("FOUT1170", `Cannot resolve the URI ${href}`, {
+      cause: error,
+    });
+  }
+}
+
+/**
+ * The text loading hook: resolves, loads (once per URI and encoding
+ * during an evaluation) and decodes.
+ * @param {((uri: string) => import("../../functions/textDecoding.js").TextResource)|undefined} loader
+ * @param {string|undefined} baseUri
+ * @returns {(href: string, encoding?: string, base?: string) => string}
+ *   the hook; `base` replaces the base URI of relative references
+ */
+export function createTextLoader(loader = noResources, baseUri) {
+  const texts = new Map();
+  return (href, encoding, base = baseUri) => {
+    const uri = resourceUri(href, base);
+    const key = `${encoding ?? ""} ${uri}`;
+    if (texts.has(key)) return texts.get(key);
+    let resource;
+    try {
+      resource = loader(uri);
+    } catch (error) {
+      throw new XPathError("FOUT1170", `Cannot read ${uri}`, { cause: error });
+    }
+    if (resource === null || resource === undefined) {
+      throw new XPathError("FOUT1170", `No resource at ${uri}`);
+    }
+    const text = decodeText(resource, encoding);
+    texts.set(key, text);
+    return text;
+  };
+}
+
+/**
+ * The XML parsing hook.
+ * @param {((text: string, baseUri?: string) => Document)|undefined} parser
+ * @returns {(text: string, baseUri?: string) => Document}
+ */
+export function createXmlParser(parser) {
+  if (parser) return parser;
+  return (text) => {
+    const DOMParser = globalThis.DOMParser;
+    if (!DOMParser) {
+      throw new XPathError(
+        "FODC0006",
+        "No XML parser: pass the xmlParser option",
+      );
+    }
+    const document = new DOMParser().parseFromString(text, "application/xml");
+    if (document.getElementsByTagName("parsererror").length) {
+      throw new XPathError("FODC0006", "The string is not well-formed XML");
+    }
+    return document;
+  };
+}
+
+/**
+ * The collection hook.
+ * @param {((uri: string|null) => Array|null|undefined)|undefined} collections
+ * @param {string|undefined} baseUri
+ * @returns {(href: string|null, base?: string) => Array} the hook; `base`
+ *   replaces the base URI of relative references
+ * @throws {XPathError} FODC0002 for an unknown collection, FODC0004 for an
+ *   invalid URI
+ */
+export function createCollections(collections, baseUri) {
+  return (href, base = baseUri) => {
+    let uri = null;
+    if (href !== null) {
+      try {
+        uri = new globalThis.URL(href, base).href;
+      } catch (error) {
+        throw new XPathError("FODC0004", `Invalid collection URI ${href}`, {
+          cause: error,
+        });
+      }
+    }
+    const items = collections?.(uri);
+    if (!items) {
+      throw new XPathError(
+        "FODC0002",
+        uri === null ? "No default collection" : `No collection ${uri}`,
+      );
+    }
+    return toSequence(items);
+  };
+}

package/src/xpath/eval/scope.js

@@ -0,0 +1,108 @@
+/**
+ * Variables and focus at compile time and at run time.
+ *
+ * Compile time: a scope is the static context plus the in-scope variables,
+ * a linked list from the innermost binding outwards. A variable reference
+ * is resolved once, to its depth in that list.
+ *
+ * Run time: an evaluator receives a context `{item, position, size, env,
+ * dyn}`: the focus (item undefined when absent), the environment (a linked
+ * list of values matching the compile-time scope, so a reference walks
+ * `depth` links) and the dynamic context shared by the whole evaluation.
+ *
+ * @module @tradik/xslt3/xpath/eval/scope
+ */
+
+import { XPathError } from "../../errors.js";
+
+/**
+ * @typedef {object} Scope
+ * @property {import("./staticContext.js").StaticContext} sc
+ * @property {{key: string, next: object}|null} vars - Innermost binding first
+ */
+
+/**
+ * @typedef {object} Context
+ * @property {*} item - Context item, undefined when the focus is absent
+ * @property {number} position - Context position
+ * @property {number} size - Context size
+ * @property {{value: Array, next: object}|null} env - Variable values
+ * @property {object} dyn - Dynamic context (see dynamicContext.js)
+ */
+
+/**
+ * @typedef {(ctx: Context) => Array} Evaluator - A compiled expression
+ */
+
+/**
+ * @param {import("./staticContext.js").StaticContext} sc
+ * @param {string[]} keys - Clark names of the external variables, the
+ *   first one outermost
+ * @returns {Scope}
+ */
+export function rootScope(sc, keys) {
+  let scope = { sc, vars: null };
+  for (const key of keys) scope = bindVariable(scope, key);
+  return scope;
+}
+
+/**
+ * @param {Scope} scope
+ * @param {string} key - Clark name of the new variable
+ * @returns {Scope} the scope with the variable added innermost
+ */
+export function bindVariable(scope, key) {
+  return { sc: scope.sc, vars: { key, next: scope.vars } };
+}
+
+/**
+ * @param {Scope} scope
+ * @param {string} key - Clark name
+ * @returns {number} depth of the innermost binding of the name, -1 when
+ *   the variable is not in scope
+ */
+export function variableDepth(scope, key) {
+  let depth = 0;
+  for (let v = scope.vars; v !== null; v = v.next, depth++) {
+    if (v.key === key) return depth;
+  }
+  return -1;
+}
+
+/**
+ * @param {Context} ctx
+ * @param {Array} value
+ * @returns {Context} the context with a value bound innermost
+ */
+export function withVariable(ctx, value) {
+  return {
+    item: ctx.item,
+    position: ctx.position,
+    size: ctx.size,
+    env: { value, next: ctx.env },
+    dyn: ctx.dyn,
+  };
+}
+
+/**
+ * @param {Context} ctx
+ * @param {*} item
+ * @param {number} position
+ * @param {number} size
+ * @returns {Context} the context with a new focus
+ */
+export function withFocus(ctx, item, position, size) {
+  return { item, position, size, env: ctx.env, dyn: ctx.dyn };
+}
+
+/**
+ * @param {Context} ctx
+ * @returns {*} the context item
+ * @throws {XPathError} XPDY0002 when the focus is absent
+ */
+export function contextItem(ctx) {
+  if (ctx.item === undefined) {
+    throw new XPathError("XPDY0002", "The context item is absent");
+  }
+  return ctx.item;
+}

package/src/xpath/eval/sequenceType.js

@@ -0,0 +1,193 @@
+/**
+ * Sequence types (XPath 3.1 section 2.5) compiled from the AST, and
+ * sequence type matching (section 2.5.5): `instance of`, `treat as`,
+ * typed variables and function signatures.
+ *
+ * A compiled sequence type is `{itemType, occurrence}` with `itemType`
+ * null for empty-sequence(). A compiled item type has a `kind` ("item",
+ * "atomic", "node", "anyFunction", "function", "anyMap", "map",
+ * "anyArray", "array"), the fields of that kind and `matches(item)`.
+ *
+ * @module @tradik/xslt3/xpath/eval/sequenceType
+ */
+
+import {
+  isArray,
+  isAtomic,
+  isFunctionItem,
+  isMap,
+  isNode,
+} from "../../xdm/atomic.js";
+import { derivesFrom, types } from "../../xdm/types.js";
+import { compileKindTest } from "./nodeTests.js";
+import { isSubtype } from "./subtype.js";
+import { resolveAtomicType } from "./typeNames.js";
+
+/** @typedef {{itemType: object|null, occurrence: string}} SequenceType */
+
+/** item()* */
+export const ANY_SEQUENCE = Object.freeze({
+  itemType: Object.freeze({ kind: "item", matches: () => true }),
+  occurrence: "*",
+});
+
+/**
+ * Atomic item type of a list of member types.
+ * @param {object[]} members - Atomic type descriptors
+ * @returns {object} the item type
+ */
+export function atomicItemType(members) {
+  const matches =
+    members.length === 1
+      ? (item) => isAtomic(item) && derivesFrom(item.type, members[0])
+      : (item) =>
+          isAtomic(item) && members.some((t) => derivesFrom(item.type, t));
+  return { kind: "atomic", types: members, matches };
+}
+
+/** Signature of every map as a function: function(xs:anyAtomicType) as item()* */
+export const MAP_SIGNATURE = Object.freeze({
+  params: [{ itemType: atomicItemType([types.anyAtomicType]), occurrence: "" }],
+  returns: ANY_SEQUENCE,
+});
+
+/** Signature of every array as a function: function(xs:integer) as item()* */
+export const ARRAY_SIGNATURE = Object.freeze({
+  params: [{ itemType: atomicItemType([types.integer]), occurrence: "" }],
+  returns: ANY_SEQUENCE,
+});
+
+/**
+ * @param {number} length - Number of items
+ * @param {string} occurrence - "", "?", "*" or "+"
+ * @returns {boolean} whether the number of items is allowed
+ */
+export function occurrenceAllows(length, occurrence) {
+  if (length === 1) return true;
+  if (length === 0) return occurrence === "?" || occurrence === "*";
+  return occurrence === "*" || occurrence === "+";
+}
+
+/**
+ * @param {Array} sequence
+ * @param {SequenceType} type
+ * @returns {boolean} whether the sequence matches the type
+ */
+export function matchesSequenceType(sequence, type) {
+  if (type.itemType === null) return sequence.length === 0;
+  if (!occurrenceAllows(sequence.length, type.occurrence)) return false;
+  const { matches } = type.itemType;
+  for (const item of sequence) if (!matches(item)) return false;
+  return true;
+}
+
+/**
+ * @param {*} item - A function item, map or array
+ * @returns {{params: SequenceType[], returns: SequenceType}} its signature
+ */
+export function signatureOf(item) {
+  if (isMap(item)) return MAP_SIGNATURE;
+  if (isArray(item)) return ARRAY_SIGNATURE;
+  return item.signature;
+}
+
+/**
+ * Whether a map or an array matches a typed function test (XPath 3.1
+ * 2.5.5.7): by its actual entries, as a function of one key or position.
+ * @param {*} item - Map or array
+ * @param {object} test - Compiled TypedFunctionTest
+ * @returns {boolean}
+ */
+function lookupMatches(item, test) {
+  if (test.params.length !== 1) return false;
+  const [param] = test.params;
+  const { returns } = test;
+  if (isMap(item)) {
+    return (
+      isSubtype(param, MAP_SIGNATURE.params[0]) &&
+      matchesSequenceType([], returns) &&
+      [...item.entries.values()].every(({ value }) =>
+        matchesSequenceType(value, returns),
+      )
+    );
+  }
+  return (
+    isSubtype(param, ARRAY_SIGNATURE.params[0]) &&
+    item.members.every((member) => matchesSequenceType(member, returns))
+  );
+}
+
+/** Item type compilers by AST node type. */
+const itemTypes = {
+  AnyItemTest: () => ANY_SEQUENCE.itemType,
+  AtomicType: (node, sc) => atomicItemType(resolveAtomicType(node.name, sc)),
+  AnyFunctionTest: () => ({ kind: "anyFunction", matches: isFunctionItem }),
+  AnyMapTest: () => ({ kind: "anyMap", matches: isMap }),
+  AnyArrayTest: () => ({ kind: "anyArray", matches: isArray }),
+  TypedFunctionTest(node, sc) {
+    const type = {
+      kind: "function",
+      params: node.paramTypes.map((p) => compileSequenceType(p, sc)),
+      returns: compileSequenceType(node.returnType, sc),
+    };
+    type.matches = (item) => {
+      if (!isFunctionItem(item)) return false;
+      if (isMap(item) || isArray(item)) return lookupMatches(item, type);
+      const signature = signatureOf(item);
+      if (signature.params.length !== type.params.length) return false;
+      return isSubtype(
+        { itemType: { kind: "function", ...signature }, occurrence: "" },
+        { itemType: type, occurrence: "" },
+      );
+    };
+    return type;
+  },
+  TypedMapTest(node, sc) {
+    const keyType = compileItemType(node.keyType, sc);
+    const valueType = compileSequenceType(node.valueType, sc);
+    const matches = (item) =>
+      isMap(item) &&
+      [...item.entries.values()].every(
+        ({ key, value }) =>
+          keyType.matches(key) && matchesSequenceType(value, valueType),
+      );
+    return { kind: "map", keyType, valueType, matches };
+  },
+  TypedArrayTest(node, sc) {
+    const memberType = compileSequenceType(node.memberType, sc);
+    const matches = (item) =>
+      isArray(item) &&
+      item.members.every((member) => matchesSequenceType(member, memberType));
+    return { kind: "array", memberType, matches };
+  },
+};
+
+/**
+ * @param {import("../syntax/typeAst.js").ItemType} node
+ * @param {import("./staticContext.js").StaticContext} sc
+ * @returns {object} the compiled item type
+ * @throws {XPathError} XPST0051 (unknown atomic type), XPST0008, XPST0081
+ */
+export function compileItemType(node, sc) {
+  const compiler = itemTypes[node.type];
+  if (compiler) return compiler(node, sc);
+  const test = compileKindTest(node, sc);
+  return {
+    kind: "node",
+    test,
+    matches: (item) => isNode(item) && test.matches(item),
+  };
+}
+
+/**
+ * @param {import("../syntax/typeAst.js").SequenceType} node
+ * @param {import("./staticContext.js").StaticContext} sc
+ * @returns {SequenceType}
+ */
+export function compileSequenceType(node, sc) {
+  return {
+    itemType:
+      node.itemType === null ? null : compileItemType(node.itemType, sc),
+    occurrence: node.occurrence,
+  };
+}

package/src/xpath/eval/staticContext.js

@@ -0,0 +1,142 @@
+/**
+ * The static context of an XPath expression (XPath 3.1 section 2.1.1) built
+ * from the options of compileXPath, and the resolution of the names written
+ * in an expression to expanded names.
+ *
+ * @module @tradik/xslt3/xpath/eval/staticContext
+ */
+
+import { XPathError } from "../../errors.js";
+import { NS } from "../../functions/signatures.js";
+import { XS_NAMESPACE } from "../../xdm/types.js";
+import { createDecimalFormats } from "./decimalFormats.js";
+
+/** URI of the Unicode codepoint collation, the only one supported. */
+export const CODEPOINT_COLLATION =
+  "http://www.w3.org/2005/xpath-functions/collation/codepoint";
+
+/** Namespace of the error codes. */
+export const ERR_NAMESPACE = "http://www.w3.org/2005/xqt-errors";
+
+/** Namespaces predeclared in every static context. */
+export const PREDECLARED_NAMESPACES = Object.freeze({
+  xml: "http://www.w3.org/XML/1998/namespace",
+  xs: XS_NAMESPACE,
+  xsi: "http://www.w3.org/2001/XMLSchema-instance",
+  fn: NS.fn,
+  math: NS.math,
+  map: NS.map,
+  array: NS.array,
+  err: ERR_NAMESPACE,
+});
+
+/**
+ * @typedef {object} StaticContext
+ * @property {Map<string, string>} namespaces - Prefix to URI
+ * @property {string} defaultElementNamespace - "" for none
+ * @property {string} defaultFunctionNamespace
+ * @property {object} functions - Function library (functions/registry.js)
+ * @property {string|undefined} baseUri - Static base URI
+ * @property {string} defaultCollation - Collation URI
+ * @property {boolean} backwardsCompatible - XPath 1.0 compatibility mode
+ * @property {{get: (name: string) => object|undefined}} decimalFormats -
+ *   Decimal formats by name (see decimalFormats.js)
+ */
+
+/**
+ * Normalizes namespace bindings given as an object, a Map or an array of
+ * `{prefix, uri}`.
+ * @param {object|Map|Array|undefined} namespaces
+ * @returns {Array<[string, string]>}
+ */
+function namespacePairs(namespaces) {
+  if (!namespaces) return [];
+  if (Array.isArray(namespaces)) {
+    return namespaces.map(({ prefix, uri }) => [prefix ?? "", uri]);
+  }
+  if (namespaces instanceof Map) return [...namespaces];
+  return Object.entries(namespaces);
+}
+
+/**
+ * Builds a static context.
+ * @param {object} options - See compileXPath in xpath/index.js
+ * @param {object} functions - Function library
+ * @returns {StaticContext}
+ * @throws {XPathError} FOCH0002 for a default collation other than the
+ *   codepoint collation
+ */
+export function createStaticContext(options, functions) {
+  const namespaces = new Map(Object.entries(PREDECLARED_NAMESPACES));
+  let defaultElementNamespace = options.defaultElementNamespace ?? "";
+  for (const [prefix, uri] of namespacePairs(options.namespaces)) {
+    if (prefix === "") defaultElementNamespace = uri;
+    else namespaces.set(prefix, uri);
+  }
+  const defaultCollation = options.defaultCollation ?? CODEPOINT_COLLATION;
+  if (defaultCollation !== CODEPOINT_COLLATION) {
+    throw new XPathError(
+      "FOCH0002",
+      `Unsupported collation ${defaultCollation}`,
+    );
+  }
+  const sc = {
+    namespaces,
+    defaultElementNamespace,
+    defaultFunctionNamespace: options.defaultFunctionNamespace ?? NS.fn,
+    functions,
+    baseUri: options.baseUri,
+    defaultCollation,
+    backwardsCompatible: Boolean(options.backwardsCompatible),
+  };
+  sc.decimalFormats = createDecimalFormats(options.decimalFormats, (name) =>
+    variableKey(name, sc),
+  );
+  return sc;
+}
+
+/**
+ * Resolves a name as written to its namespace URI.
+ * @param {import("../syntax/ast.js").QName} name
+ * @param {StaticContext} sc
+ * @param {string} defaultNamespace - URI for an unprefixed name
+ * @returns {string} the namespace URI ("" for none)
+ * @throws {XPathError} XPST0081 for an undeclared prefix
+ */
+export function namespaceOf(name, sc, defaultNamespace) {
+  if (name.uri !== null) return name.uri;
+  if (name.prefix === null) return defaultNamespace;
+  const uri = sc.namespaces.get(name.prefix);
+  if (uri === undefined) {
+    throw new XPathError(
+      "XPST0081",
+      `The prefix ${name.prefix} is not declared`,
+    );
+  }
+  return uri;
+}
+
+/**
+ * Expanded name in Clark notation, `{uri}local`.
+ * @param {string} uri
+ * @param {string} local
+ * @returns {string}
+ */
+export const clark = (uri, local) => `{${uri}}${local}`;
+
+/**
+ * Parses a variable name given in the options: `Q{uri}local`,
+ * `prefix:local` (resolved with the static namespaces) or `local`.
+ * @param {string} text
+ * @param {StaticContext} sc
+ * @returns {string} Clark name
+ * @throws {XPathError} XPST0081 for an undeclared prefix
+ */
+export function variableKey(text, sc) {
+  const eqName = /^Q\{([^}]*)\}(.+)$/.exec(text);
+  if (eqName) return clark(eqName[1], eqName[2]);
+  const colon = text.indexOf(":");
+  if (colon < 0) return clark("", text);
+  const name = { prefix: text.slice(0, colon), local: text.slice(colon + 1) };
+  return clark(namespaceOf({ ...name, uri: null }, sc, ""), name.local);
+}

package/src/xpath/eval/steps.js

@@ -0,0 +1,98 @@
+/**
+ * The `/` operator: a step applied to each node of the left operand, and
+ * the results combined (XPath 3.1 section 3.3.1.1): nodes in document
+ * order without duplicates, or atomic values and functions in order.
+ *
+ * Sorting is skipped where the order is known: a single input node and an
+ * axis step, or sorted sibling inputs and an axis that stays inside each
+ * input's subtree (child, attribute, namespace, self, descendant,
+ * descendant-or-self), whose results are then disjoint and in order.
+ *
+ * @module @tradik/xslt3/xpath/eval/steps
+ */
+
+import { XPathError } from "../../errors.js";
+import { isNode } from "../../xdm/atomic.js";
+import { isContainer, parentOf } from "./domNodes.js";
+import { withFocus } from "./scope.js";
+
+const EMPTY = Object.freeze([]);
+
+/** Axes that select inside the subtree of the context node. */
+const SUBTREE_AXES = new Set([
+  "child",
+  "attribute",
+  "namespace",
+  "self",
+  "descendant",
+  "descendant-or-self",
+]);
+
+/** Axes that select only children or descendants of the context node. */
+const CHILD_AXES = new Set(["child", "descendant"]);
+
+/**
+ * Combines the results of a step applied to each input item.
+ * @param {Array[]} results - One sequence per input item
+ * @param {import("./scope.js").Context} ctx
+ * @returns {Array} nodes in document order, or the concatenated values
+ * @throws {XPathError} XPTY0018 when nodes and other items are mixed
+ */
+function combine(results, ctx) {
+  const all = results.flat();
+  let nodes = 0;
+  for (const item of all) if (isNode(item)) nodes++;
+  if (nodes === 0) return all;
+  if (nodes !== all.length) {
+    throw new XPathError(
+      "XPTY0018",
+      "A path step returned both nodes and other items",
+    );
+  }
+  return ctx.dyn.order.sort(all);
+}
+
+/**
+ * @param {Node[]} nodes - At least two nodes
+ * @returns {boolean} whether all the nodes have the same parent
+ */
+function areSiblings(nodes) {
+  const parent = parentOf(nodes[0]);
+  if (parent === null) return false;
+  for (let i = 1; i < nodes.length; i++) {
+    if (parentOf(nodes[i]) !== parent) return false;
+  }
+  return true;
+}
+
+/**
+ * Evaluator of `E1/E2` for an evaluated E1.
+ * @param {import("./scope.js").Evaluator} step - E2
+ * @param {string|null} axis - Axis of E2 when it is an axis step
+ * @returns {(input: Array, ctx: object, sorted: boolean) => Array} the
+ *   combined result; `sorted` tells that the input is in document order
+ */
+export function stepper(step, axis) {
+  const subtree = SUBTREE_AXES.has(axis);
+  const childless = CHILD_AXES.has(axis);
+  return (input, ctx, sorted) => {
+    const size = input.length;
+    if (size === 0) return EMPTY;
+    const results = [];
+    for (let i = 0; i < size; i++) {
+      if (!isNode(input[i])) {
+        throw new XPathError(
+          "XPTY0019",
+          "The left operand of / must contain only nodes",
+        );
+      }
+      // An axis step finds no children nor descendants of a leaf node (a
+      // shortcut for the text nodes reached by `//`)
+      if (childless && !isContainer(input[i])) continue;
+      results.push(step(withFocus(ctx, input[i], i + 1, size)));
+    }
+    if (size === 1 && axis !== null) return results[0] ?? EMPTY;
+    if (sorted && subtree && areSiblings(input)) return results.flat();
+    return combine(results, ctx);
+  };
+}