@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xpath/eval/operators.js

@@ -0,0 +1,190 @@
+/**
+ * Compilers of the operator expressions: and/or, comparisons, `||`, `to`,
+ * arithmetic and unary plus/minus (XPath 3.1 sections 3.4 to 3.8), with
+ * the XPath 1.0 compatibility mode rules for arithmetic.
+ *
+ * @module @tradik/xslt3/xpath/eval/operators
+ */
+
+import { XPathError } from "../../errors.js";
+import { arithmetic, unaryArithmetic } from "../../xdm/arithmetic.js";
+import { AtomicValue, isNode } from "../../xdm/atomic.js";
+import { cast } from "../../xdm/cast.js";
+import { valueCompare } from "../../xdm/compare.js";
+import { generalCompare, toNumber } from "../../xdm/generalCompare.js";
+import { canonicalString } from "../../xdm/lexical.js";
+import { atomize, effectiveBooleanValue } from "../../xdm/nodes.js";
+import { derivesFrom, isNumericType, types } from "../../xdm/types.js";
+import { atomizeOptional, booleanItem, stringItem } from "./atomics.js";
+
+/** Largest sequence a range expression may build. */
+export const MAX_RANGE = 2 ** 25;
+
+const EMPTY = Object.freeze([]);
+const NAN = new AtomicValue(types.double, NaN);
+
+/**
+ * Operand of an arithmetic operator in XPath 1.0 compatibility mode: the
+ * first atomized item, as xs:double unless it is a duration or date/time.
+ * @param {Array} sequence
+ * @returns {AtomicValue}
+ */
+function compatibleOperand(sequence) {
+  const first = atomize(sequence.slice(0, 1))[0];
+  if (first === undefined) return NAN;
+  const primitive = first.type.primitive.localName;
+  const toDouble =
+    isNumericType(first.type) ||
+    ["boolean", "string", "untypedAtomic", "anyURI"].includes(primitive);
+  return toDouble ? toNumber(first) : first;
+}
+
+/**
+ * @param {Array} sequence
+ * @returns {*} the single node of a node comparison operand, undefined
+ *   when empty
+ * @throws {XPathError} XPTY0004 when the operand is not one node
+ */
+function nodeOperand(sequence) {
+  if (sequence.length === 0) return undefined;
+  if (sequence.length > 1 || !isNode(sequence[0])) {
+    throw new XPathError(
+      "XPTY0004",
+      "A node comparison operand must be a single node",
+    );
+  }
+  return sequence[0];
+}
+
+/**
+ * Operand of a value comparison, xs:untypedAtomic cast to xs:string.
+ * @param {Array} sequence
+ * @returns {AtomicValue|undefined}
+ */
+function valueOperand(sequence) {
+  const value = atomizeOptional(sequence, "operand of a value comparison");
+  return value?.type === types.untypedAtomic
+    ? cast(value, types.string)
+    : value;
+}
+
+/**
+ * Operand of a range expression.
+ * @param {Array} sequence
+ * @returns {bigint|undefined}
+ */
+function rangeOperand(sequence) {
+  let value = atomizeOptional(sequence, "operand of to");
+  if (value === undefined) return undefined;
+  if (value.type === types.untypedAtomic) value = cast(value, types.integer);
+  if (!derivesFrom(value.type, types.integer)) {
+    throw new XPathError("XPTY0004", "The operands of to must be integers");
+  }
+  return value.value;
+}
+
+/** Comparison compilers by kind. */
+const comparisons = {
+  general: (op, left, right, compatible) => (ctx) => {
+    const options = compatible
+      ? ctx.dyn.compatibleCompareOptions
+      : ctx.dyn.compareOptions;
+    return [booleanItem(generalCompare(left(ctx), op, right(ctx), options))];
+  },
+  value: (op, left, right) => (ctx) => {
+    const a = valueOperand(left(ctx));
+    const b = valueOperand(right(ctx));
+    if (a === undefined || b === undefined) return EMPTY;
+    return [booleanItem(valueCompare(a, op, b, ctx.dyn.compareOptions))];
+  },
+  node: (op, left, right) => (ctx) => {
+    const a = nodeOperand(left(ctx));
+    const b = nodeOperand(right(ctx));
+    if (a === undefined || b === undefined) return EMPTY;
+    if (op === "is") return [booleanItem(a === b)];
+    const order = ctx.dyn.order.compare(a, b);
+    return [booleanItem(op === "<<" ? order < 0 : order > 0)];
+  },
+};
+
+/** Compilers by node type. */
+export const operatorCompilers = {
+  LogicalExpr(node, scope, compile) {
+    const left = compile(node.left, scope);
+    const right = compile(node.right, scope);
+    const isOr = node.operator === "or";
+    return (ctx) => {
+      const first = effectiveBooleanValue(left(ctx));
+      if (first === isOr) return [booleanItem(isOr)];
+      return [booleanItem(effectiveBooleanValue(right(ctx)))];
+    };
+  },
+
+  ComparisonExpr(node, scope, compile) {
+    return comparisons[node.kind](
+      node.operator,
+      compile(node.left, scope),
+      compile(node.right, scope),
+      scope.sc.backwardsCompatible,
+    );
+  },
+
+  StringConcatExpr(node, scope, compile) {
+    const left = compile(node.left, scope);
+    const right = compile(node.right, scope);
+    const text = (sequence) => {
+      const value = atomizeOptional(sequence, "operand of ||");
+      return value === undefined ? "" : canonicalString(value);
+    };
+    return (ctx) => [stringItem(text(left(ctx)) + text(right(ctx)))];
+  },
+
+  RangeExpr(node, scope, compile) {
+    const left = compile(node.left, scope);
+    const right = compile(node.right, scope);
+    return (ctx) => {
+      const low = rangeOperand(left(ctx));
+      const high = rangeOperand(right(ctx));
+      if (low === undefined || high === undefined || low > high) return EMPTY;
+      if (high - low >= BigInt(MAX_RANGE)) {
+        throw new XPathError("XPDY0130", "The range is too large");
+      }
+      const result = [];
+      for (let i = low; i <= high; i++) {
+        result.push(new AtomicValue(types.integer, i));
+      }
+      return result;
+    };
+  },
+
+  ArithmeticExpr(node, scope, compile) {
+    const left = compile(node.left, scope);
+    const right = compile(node.right, scope);
+    const op = node.operator;
+    if (scope.sc.backwardsCompatible) {
+      return (ctx) => {
+        const a = compatibleOperand(left(ctx));
+        const b = compatibleOperand(right(ctx));
+        return [arithmetic(a, op, b, ctx.dyn.compareOptions)];
+      };
+    }
+    return (ctx) => {
+      const a = atomizeOptional(left(ctx), `operand of ${op}`);
+      const b = atomizeOptional(right(ctx), `operand of ${op}`);
+      if (a === undefined || b === undefined) return EMPTY;
+      return [arithmetic(a, op, b, ctx.dyn.compareOptions)];
+    };
+  },
+
+  UnaryExpr(node, scope, compile) {
+    const operand = compile(node.operand, scope);
+    const op = node.operator;
+    if (scope.sc.backwardsCompatible) {
+      return (ctx) => [unaryArithmetic(op, compatibleOperand(operand(ctx)))];
+    }
+    return (ctx) => {
+      const a = atomizeOptional(operand(ctx), `operand of unary ${op}`);
+      return a === undefined ? EMPTY : [unaryArithmetic(op, a)];
+    };
+  },
+};

package/src/xpath/eval/paths.js

@@ -0,0 +1,163 @@
+/**
+ * Compilers of path expressions, axis steps, predicates, filter
+ * expressions and the node set operators (XPath 3.1 sections 3.3, 3.4).
+ *
+ * `//T` is compiled as `descendant::T` when the predicates of T do not
+ * depend on the context position (see positional.js), instead of
+ * `descendant-or-self::node()/child::T`, which gives the same nodes.
+ *
+ * @module @tradik/xslt3/xpath/eval/paths
+ */
+
+import { XPathError } from "../../errors.js";
+import { isNode } from "../../xdm/atomic.js";
+import { REVERSE_AXES } from "./axes.js";
+import { axisNodes } from "./descendantMemo.js";
+import { rootOf } from "./domNodes.js";
+import {
+  compileGroupedChildren,
+  isGroupedChildren,
+} from "./groupedChildren.js";
+import { compileNodeTest } from "./nodeTests.js";
+import { isPositionIndependent } from "./positional.js";
+import { compilePredicate } from "./predicates.js";
+import { contextItem } from "./scope.js";
+import { stepper } from "./steps.js";
+
+/**
+ * @param {import("./scope.js").Context} ctx
+ * @param {string} code - Error code when the context item is not a node
+ * @returns {Node} the context node
+ */
+function contextNode(ctx, code) {
+  const item = contextItem(ctx);
+  if (!isNode(item)) {
+    throw new XPathError(code, "The context item is not a node");
+  }
+  return item;
+}
+
+/**
+ * Whether a step is `descendant-or-self::node()` and the next one a child
+ * step whose predicates do not depend on the position, which together are
+ * a descendant step.
+ */
+const isDescendantShortcut = (step, next, sc) =>
+  step.type === "AxisStep" &&
+  step.axis === "descendant-or-self" &&
+  step.nodeTest.type === "AnyKindTest" &&
+  step.predicates.length === 0 &&
+  next?.type === "AxisStep" &&
+  next.axis === "child" &&
+  next.predicates.every((p) => isPositionIndependent(p, sc));
+
+/**
+ * How many nodes of an axis a step needs: N for a first predicate that is
+ * the integer literal N, all of them otherwise.
+ * @param {import("../syntax/ast.js").Expr|undefined} predicate
+ * @returns {number}
+ */
+const positionalLimit = (predicate) =>
+  predicate?.type === "NumericLiteral" && predicate.kind === "integer"
+    ? Math.max(Number(predicate.value), 0)
+    : Infinity;
+
+/** Marks a `descendant-or-self::node()/child::T[P]` pair in a path. */
+const GROUPED = "GroupedChildren";
+
+/** Compilers by node type. */
+export const pathCompilers = {
+  AxisStep(node, scope, compile) {
+    const axis = node.axis;
+    const test = compileNodeTest(node.nodeTest, node.axis, scope.sc);
+    const predicates = node.predicates.map((p) =>
+      compilePredicate(p, scope, compile),
+    );
+    const limit = positionalLimit(node.predicates[0]);
+    const reverse = REVERSE_AXES.has(node.axis);
+    return (ctx) => {
+      const item = contextNode(ctx, "XPTY0020");
+      let nodes = axisNodes(axis, item, test, limit, ctx.dyn);
+      for (const predicate of predicates) nodes = predicate(nodes, ctx);
+      return reverse ? nodes.reverse() : nodes;
+    };
+  },
+
+  PathExpr(node, scope, compile) {
+    const steps = [...node.steps];
+    for (let i = 0; i < steps.length - 1; i++) {
+      if (isDescendantShortcut(steps[i], steps[i + 1], scope.sc)) {
+        steps.splice(i, 2, { ...steps[i + 1], axis: "descendant" });
+      }
+    }
+    for (let i = 0; i < steps.length - 1; i++) {
+      if (isGroupedChildren(steps[i], steps[i + 1])) {
+        steps.splice(i, 2, { type: GROUPED, step: steps[i + 1] });
+      }
+    }
+    const compiled = steps.map((step) => {
+      if (step.type === GROUPED) {
+        const run = compileGroupedChildren(step.step, scope, compile);
+        const evaluate = (ctx) => run([contextNode(ctx, "XPTY0020")], ctx);
+        return { evaluate, run };
+      }
+      const evaluate = compile(step, scope);
+      const axis = step.type === "AxisStep" ? step.axis : null;
+      return { evaluate, run: stepper(evaluate, axis) };
+    });
+    const sortedStart =
+      node.absolute ||
+      steps[0].type === "AxisStep" ||
+      steps[0].type === GROUPED;
+    const start = node.absolute
+      ? (ctx) => {
+          const root = rootOf(contextNode(ctx, "XPTY0020"));
+          if (root.nodeType !== 9 && root.nodeType !== 11) {
+            throw new XPathError(
+              "XPDY0050",
+              "The root of the context node is not a document node",
+            );
+          }
+          return [root];
+        }
+      : compiled.shift().evaluate;
+    return (ctx) => {
+      let current = start(ctx);
+      let sorted = sortedStart;
+      for (const { run } of compiled) {
+        current = run(current, ctx, sorted);
+        sorted = true;
+      }
+      return current;
+    };
+  },
+
+  FilterExpr(node, scope, compile) {
+    const base = compile(node.base, scope);
+    const predicate = compilePredicate(node.predicate, scope, compile);
+    return (ctx) => predicate(base(ctx), ctx);
+  },
+
+  SetExpr(node, scope, compile) {
+    const left = compile(node.left, scope);
+    const right = compile(node.right, scope);
+    const operator = node.operator;
+    const nodesOf = (sequence) => {
+      if (!sequence.every(isNode)) {
+        throw new XPathError(
+          "XPTY0004",
+          `The operands of ${operator} must be nodes`,
+        );
+      }
+      return sequence;
+    };
+    return (ctx) => {
+      const a = nodesOf(left(ctx));
+      const b = nodesOf(right(ctx));
+      if (operator === "union") return ctx.dyn.order.sort(a.concat(b));
+      const inRight = new Set(b);
+      const keep = operator === "intersect";
+      return ctx.dyn.order.sort(a.filter((n) => inRight.has(n) === keep));
+    };
+  },
+};

package/src/xpath/eval/positional.js

@@ -0,0 +1,81 @@
+/**
+ * Static test of whether a predicate depends on the context position or
+ * size: when it does not, `//T[P]` (`descendant-or-self::node()/child::T[P]`)
+ * selects the same nodes as `descendant::T[P]`, which needs no sorting.
+ *
+ * The test is syntactic and conservative: the predicate must evaluate to a
+ * boolean or to nodes (never to a number, which would select by position)
+ * and must not call position() or last() anywhere.
+ *
+ * @module @tradik/xslt3/xpath/eval/positional
+ */
+
+import { NS } from "../../functions/signatures.js";
+
+/** Expressions that always return a boolean or nodes. */
+const NON_NUMERIC = new Set([
+  "ComparisonExpr",
+  "LogicalExpr",
+  "QuantifiedExpr",
+  "InstanceOfExpr",
+  "CastableExpr",
+  "AxisStep",
+]);
+
+/** Built-in functions returning xs:boolean. */
+const BOOLEAN_FUNCTIONS = new Set([
+  "not",
+  "boolean",
+  "exists",
+  "empty",
+  "true",
+  "false",
+  "contains",
+  "starts-with",
+  "ends-with",
+  "matches",
+  "deep-equal",
+]);
+
+/**
+ * @param {import("../syntax/ast.js").QName} name
+ * @param {import("./staticContext.js").StaticContext} sc
+ * @returns {boolean} whether the name is a built-in function name
+ */
+const isBuiltIn = (name, sc) =>
+  name.uri === null &&
+  (name.prefix === null
+    ? sc.defaultFunctionNamespace === NS.fn
+    : sc.namespaces.get(name.prefix) === NS.fn);
+
+/**
+ * Whether an AST contains a call or reference to position() or last().
+ * @param {*} node
+ * @returns {boolean}
+ */
+function usesFocusSize(node) {
+  if (Array.isArray(node)) return node.some(usesFocusSize);
+  if (node === null || typeof node !== "object") return false;
+  const named =
+    node.type === "FunctionCall" || node.type === "NamedFunctionRef";
+  if (named && ["position", "last"].includes(node.name.local)) return true;
+  return Object.values(node).some(usesFocusSize);
+}
+
+/**
+ * Whether a predicate selects the same items whatever the context
+ * position and size.
+ * @param {import("../syntax/ast.js").Expr} predicate
+ * @param {import("./staticContext.js").StaticContext} sc
+ * @returns {boolean}
+ */
+export function isPositionIndependent(predicate, sc) {
+  const { type } = predicate;
+  const nonNumeric =
+    NON_NUMERIC.has(type) ||
+    (type === "PathExpr" && predicate.steps.at(-1)?.type === "AxisStep") ||
+    (type === "FunctionCall" &&
+      BOOLEAN_FUNCTIONS.has(predicate.name.local) &&
+      isBuiltIn(predicate.name, sc));
+  return nonNumeric && !usesFocusSize(predicate);
+}

package/src/xpath/eval/predicates.js

@@ -0,0 +1,56 @@
+/**
+ * Predicates (XPath 3.1 section 3.3.3): a numeric predicate value selects
+ * the item at that position, any other value is taken as an effective
+ * boolean value. A literal integer predicate is compiled to an index.
+ *
+ * @module @tradik/xslt3/xpath/eval/predicates
+ */
+
+import { isAtomic } from "../../xdm/atomic.js";
+import { effectiveBooleanValue } from "../../xdm/nodes.js";
+import { isNumericType } from "../../xdm/types.js";
+import { withFocus } from "./scope.js";
+
+/**
+ * A compiled predicate: filters a sequence (in its order, which gives the
+ * context positions).
+ * @typedef {(items: Array, ctx: import("./scope.js").Context) => Array} Predicate
+ */
+
+/**
+ * Whether a predicate value keeps the item at a position.
+ * @param {Array} value
+ * @param {number} position
+ * @returns {boolean}
+ */
+export function predicateTruth(value, position) {
+  if (value.length === 1 && isAtomic(value[0])) {
+    const { type, value: number } = value[0];
+    if (isNumericType(type)) return Number(number) === position;
+  }
+  return effectiveBooleanValue(value);
+}
+
+/**
+ * @param {import("../syntax/ast.js").Expr} node - Predicate expression
+ * @param {import("./scope.js").Scope} scope
+ * @param {Function} compile
+ * @returns {Predicate}
+ */
+export function compilePredicate(node, scope, compile) {
+  if (node.type === "NumericLiteral" && node.kind === "integer") {
+    const index = Number(node.value) - 1;
+    return (items) =>
+      index >= 0 && index < items.length ? [items[index]] : [];
+  }
+  const predicate = compile(node, scope);
+  return (items, ctx) => {
+    const size = items.length;
+    const result = [];
+    for (let i = 0; i < size; i++) {
+      const value = predicate(withFocus(ctx, items[i], i + 1, size));
+      if (predicateTruth(value, i + 1)) result.push(items[i]);
+    }
+    return result;
+  };
+}

package/src/xpath/eval/primary.js

@@ -0,0 +1,99 @@
+/**
+ * Compilers of primary expressions: literals, variable references, the
+ * context item, the comma operator and the empty sequence.
+ *
+ * Evaluators return arrays that callers must not modify: a literal returns
+ * the same array every time.
+ *
+ * @module @tradik/xslt3/xpath/eval/primary
+ */
+
+import { XPathError } from "../../errors.js";
+import { AtomicValue } from "../../xdm/atomic.js";
+import { Decimal } from "../../xdm/decimal.js";
+import { types } from "../../xdm/types.js";
+import { contextItem, variableDepth } from "./scope.js";
+import { clark, namespaceOf } from "./staticContext.js";
+
+const EMPTY = Object.freeze([]);
+
+/**
+ * @param {import("../syntax/ast.js").NumericLiteral} node
+ * @returns {AtomicValue}
+ */
+function numericValue(node) {
+  if (node.kind === "integer") {
+    return new AtomicValue(types.integer, BigInt(node.value));
+  }
+  if (node.kind === "decimal") {
+    return new AtomicValue(types.decimal, Decimal.parse(node.value));
+  }
+  return new AtomicValue(types.double, Number(node.value));
+}
+
+/**
+ * Evaluator of a variable reference resolved to a depth.
+ * @param {number} depth
+ * @param {string} name - For the error message
+ * @returns {import("./scope.js").Evaluator}
+ */
+function variableReader(depth, name) {
+  const check = (value) => {
+    if (value === undefined) {
+      throw new XPathError("XPDY0002", `No value is bound to $${name}`);
+    }
+    return value;
+  };
+  if (depth === 0) return (ctx) => check(ctx.env.value);
+  return (ctx) => {
+    let env = ctx.env;
+    for (let i = 0; i < depth; i++) env = env.next;
+    return check(env.value);
+  };
+}
+
+/** Compilers by node type. */
+export const primaryCompilers = {
+  NumericLiteral(node) {
+    const result = Object.freeze([numericValue(node)]);
+    return () => result;
+  },
+
+  StringLiteral(node) {
+    const result = Object.freeze([new AtomicValue(types.string, node.value)]);
+    return () => result;
+  },
+
+  EmptySequence() {
+    return () => EMPTY;
+  },
+
+  ContextItemExpr() {
+    return (ctx) => [contextItem(ctx)];
+  },
+
+  VarRef(node, scope) {
+    const key = clark(namespaceOf(node.name, scope.sc, ""), node.name.local);
+    const depth = variableDepth(scope, key);
+    if (depth < 0) {
+      throw new XPathError(
+        "XPST0008",
+        `The variable $${node.name.local} is not declared`,
+      );
+    }
+    return variableReader(depth, node.name.local);
+  },
+
+  SequenceExpr(node, scope, compile) {
+    const parts = node.items.map((item) => compile(item, scope));
+    return (ctx) => {
+      const result = [];
+      for (const part of parts) {
+        for (const item of part(ctx)) result.push(item);
+      }
+      return result;
+    };
+  },
+};
+
+export { EMPTY };