@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/patterns/compile.js

@@ -0,0 +1,151 @@
+/**
+ * Patterns (XSLT 3.0 section 5.5): parsed as XPath expressions and
+ * compiled to matchers. A union is split into alternatives, each with its
+ * default priority (section 6.5); intersect and except combine patterns,
+ * and predicate patterns `.[P]` match any item.
+ *
+ * @module @tradik/xslt3/xslt/patterns/compile
+ */
+
+import { parseXPath } from "../../xpath/syntax/index.js";
+import { xsltError } from "../names.js";
+import { parentOf } from "../../xpath/eval/domNodes.js";
+import { derive } from "../runtime/context.js";
+import { compileGeneralPath } from "./general.js";
+import { checkPattern, isPredicatePattern } from "./grammar.js";
+import { checkGroupingCalls } from "./patternChecks.js";
+import { compilePathPattern } from "./paths.js";
+
+/**
+ * @typedef {object} PatternAlternative
+ * @property {(item: *, xc: object) => boolean} matches
+ * @property {number} priority - Default priority
+ * @property {string} key - Index key: "e{uri}local", "a{uri}local", "k"
+ *   followed by a nodeType, or "*" for any item
+ */
+
+/**
+ * Splits a pattern into its union alternatives.
+ * @param {object} ast
+ * @returns {object[]}
+ */
+function alternativesOf(ast) {
+  if (ast.type === "SetExpr" && ast.operator === "union") {
+    return [...alternativesOf(ast.left), ...alternativesOf(ast.right)];
+  }
+  return [ast];
+}
+
+/**
+ * Compiles a predicate pattern `.` or `.[P]` (XSLT 3.0), which matches
+ * any item.
+ * @param {object} ast
+ * @param {object} env
+ * @returns {PatternAlternative}
+ */
+function compilePredicatePattern(ast, env) {
+  const run = env.cx.exprs.compileAst(ast, env.sc, env.vars);
+  return {
+    matches: (item, xc) =>
+      run(env.cx.patternContext(item, xc, env.local)).length > 0,
+    priority: ast.type === "ContextItemExpr" ? -1 : 1,
+    key: "*",
+  };
+}
+
+/**
+ * Compiles `A intersect B` or `A except B` (XSLT 3.0).
+ * @param {object} ast
+ * @param {object} env
+ * @returns {PatternAlternative}
+ */
+function compileSetPattern(ast, env) {
+  const side = (part) =>
+    alternativesOf(part).map((alternative) =>
+      compileAlternative(alternative, env),
+    );
+  const left = side(ast.left);
+  const right = side(ast.right);
+  const any = (list, item, xc) => list.some((a) => a.matches(item, xc));
+  const intersect = ast.operator === "intersect";
+  // a node with a parent: both sides are evaluated from the same context
+  const formal = compileGeneralPath(ast, env);
+  return {
+    matches: (item, xc) =>
+      parentOf(item)
+        ? formal(item, xc)
+        : any(left, item, xc) && any(right, item, xc) === intersect,
+    priority: 0.5,
+    key: left.length === 1 ? left[0].key : "*",
+  };
+}
+
+/**
+ * Compiles one alternative; while it is tested, current() is the item
+ * being matched, and a dynamic error is a non-match (XSLT 3.0 5.5.4).
+ * @param {object} ast
+ * @param {object} env - `{cx, sc, vars, local, text}`
+ * @returns {PatternAlternative}
+ */
+function compileAlternative(ast, env) {
+  let alternative;
+  if (ast.type === "SetExpr") alternative = compileSetPattern(ast, env);
+  else if (isPredicatePattern(ast)) {
+    alternative = compilePredicatePattern(ast, env);
+  } else alternative = compilePathPattern(ast, env);
+  const { matches } = alternative;
+  alternative.matches = (item, xc) => {
+    try {
+      return matches(item, xc.item === item ? xc : derive(xc, { item }));
+    } catch (error) {
+      if (!error.code || error.code === "XTDE0640") throw error;
+      return false;
+    }
+  };
+  return alternative;
+}
+
+/**
+ * Compiles a pattern written on a stylesheet element.
+ * @param {string} text
+ * @param {Element} element
+ * @param {object} cx - Stylesheet compiler
+ * @param {object|null} [vars] - Local variables in scope (patterns of
+ *   instructions); template and key patterns see the global ones only
+ * @returns {{text: string, alternatives: PatternAlternative[]}}
+ * @throws {import("../../errors.js").XPathError} XTSE0340 for an
+ *   expression that is not a pattern
+ */
+export function compilePattern(text, element, cx, vars) {
+  let ast;
+  try {
+    ast = parseXPath(text);
+  } catch (error) {
+    throw error.code === "XPST0003"
+      ? xsltError("XTSE0340", `Invalid pattern "${text}": ${error.message}`)
+      : error;
+  }
+  checkPattern(ast, text);
+  checkGroupingCalls(ast);
+  const env = {
+    cx,
+    sc: cx.exprs.staticContext(element),
+    vars: vars === undefined ? cx.globalScope().vars : vars,
+    local: vars !== undefined,
+    text,
+  };
+  const alternatives = alternativesOf(ast).map((alternative) =>
+    compileAlternative(alternative, env),
+  );
+  return { text, alternatives };
+}
+
+/**
+ * Whether an item matches any alternative of a pattern.
+ * @param {{alternatives: PatternAlternative[]}} pattern
+ * @param {*} item
+ * @param {object} xc
+ * @returns {boolean}
+ */
+export const patternMatches = (pattern, item, xc) =>
+  pattern.alternatives.some((alternative) => alternative.matches(item, xc));

package/src/xslt/patterns/general.js

@@ -0,0 +1,132 @@
+/**
+ * Path patterns of any form (XSLT 3.0 section 5.5.3), matched by their
+ * formal meaning: a node N matches when it is selected by the equivalent
+ * expression evaluated from some node of its tree. The steps are read
+ * from the last one: for each step, the context nodes from which the
+ * step can select N (the parent for child::, the ancestors for
+ * descendant::...) are evaluated, and those that do select N carry on
+ * to the step before. Used for the patterns the fast matcher of paths.js
+ * does not handle: descendant axes, parenthesized steps, filtered rooted
+ * steps, positional predicates over whole paths.
+ *
+ * @module @tradik/xslt3/xslt/patterns/general
+ */
+
+import { parentOf } from "../../xpath/eval/domNodes.js";
+import { compileAxisOrigins, filterAlone } from "./axisOrigins.js";
+import { isRootedStep, unfiltered } from "./grammar.js";
+
+/** @param {*} node @returns {boolean} whether a node is a document node */
+const isDocument = (node) => node?.nodeType === 9 || node?.nodeType === 11;
+
+/** @param {*} item @returns {boolean} */
+const isNode = (item) => typeof item?.nodeType === "number";
+
+/**
+ * Compiles one step: `origins(node, xc)` returns the context nodes from
+ * which the step selects the node.
+ * @param {object} step
+ * @param {object} env - See compile.js
+ * @param {boolean} first - First step of a relative pattern
+ * @returns {{origins: (node: Node, xc: object) => Node[]}}
+ */
+function compileStep(step, env, first) {
+  const run = env.cx.exprs.compileAst(step, env.sc, env.vars);
+  const selects = (context, node, xc) =>
+    run(env.cx.patternContext(context, xc, env.local)).includes(node);
+  if (step.type === "AxisStep") {
+    return compileAxisOrigins(step, env, first, run);
+  }
+  if (step.type === "FilterExpr") {
+    const inner = compileStep(unfiltered(step), env, first);
+    const predicates = [];
+    for (let s = step; s.type === "FilterExpr"; s = s.base) {
+      predicates.unshift(s.predicate);
+    }
+    const alone = filterAlone(predicates, env);
+    return {
+      origins: (node, xc) =>
+        inner.origins(node, xc).flatMap((c) => {
+          // a parentless node selected by itself (child-or-top)
+          if (c === node && !parentOf(node)) return alone(node, xc);
+          return selects(c, node, xc) ? [c] : [];
+        }),
+    };
+  }
+  if (step.type === "SetExpr") {
+    // each side is a path of its own (its first step adjusted)
+    const sides = [step.left, step.right].map((s) => compileStep(s, env, true));
+    const union = step.operator === "union";
+    return {
+      origins: (node, xc) => {
+        const candidates = new Set(sides[0].origins(node, xc));
+        if (union) {
+          for (const c of sides[1].origins(node, xc)) candidates.add(c);
+        }
+        return [...candidates].filter((c) => selects(c, node, xc));
+      },
+    };
+  }
+  if (step.type === "PathExpr" && !step.absolute) {
+    return compilePath(step, env, true);
+  }
+  // an absolute path or a rooted step: any node of the tree is a context
+  return { origins: (node, xc) => (selects(node, node, xc) ? [node] : []) };
+}
+
+/**
+ * Compiles the steps of a relative path.
+ * @param {{steps: object[]}} path
+ * @param {object} env
+ * @param {boolean} first - The path starts a relative pattern
+ * @returns {{origins: (node: Node, xc: object) => Node[]}}
+ */
+function compilePath(path, env, first) {
+  const steps = path.steps.map((step, i) =>
+    compileStep(step, env, first && i === 0),
+  );
+  return {
+    origins(node, xc) {
+      let current = [node];
+      for (let k = steps.length - 1; k >= 0 && current.length > 0; k--) {
+        const next = new Set();
+        for (const n of current) {
+          for (const c of steps[k].origins(n, xc)) next.add(c);
+        }
+        current = [...next];
+      }
+      return current;
+    },
+  };
+}
+
+/**
+ * Compiles a path pattern of any form.
+ * @param {object} ast - PathExpr or a single step
+ * @param {object} env - See compile.js
+ * @returns {(item: *, xc: object) => boolean}
+ */
+export function compileGeneralPath(ast, env) {
+  const steps = ast.type === "PathExpr" ? ast.steps : [ast];
+  const absolute = ast.type === "PathExpr" && ast.absolute;
+  const rootStep = !absolute && isRootedStep(steps[0]) ? steps[0] : null;
+  const rest = compilePath(
+    { steps: rootStep ? steps.slice(1) : steps },
+    env,
+    !absolute && !rootStep,
+  );
+  const root = rootStep
+    ? env.cx.exprs.compileAst(rootStep, env.sc, env.vars)
+    : null;
+  return (item, xc) => {
+    if (!isNode(item)) return false;
+    const origins = rest.origins(item, xc);
+    if (absolute) {
+      return origins.some((c) => isDocument(c) && !parentOf(c));
+    }
+    if (!root) return origins.length > 0;
+    if (origins.length === 0) return false;
+    const roots = root(env.cx.patternContext(item, xc, env.local));
+    return origins.some((c) => roots.includes(c));
+  };
+}

package/src/xslt/patterns/grammar.js

@@ -0,0 +1,190 @@
+/**
+ * The grammar of patterns (XSLT 3.0 section 5.5.2): a pattern is parsed
+ * as an XPath expression, then checked against the production Pattern30:
+ * a predicate pattern `.[P]...`, or unions, intersections and
+ * differences of path patterns whose steps are forward axis steps,
+ * parenthesized patterns with predicates, and rooted first steps
+ * (`$var`, doc(), id(), element-with-id(), key(), root()) whose arguments
+ * are variable references or literals.
+ *
+ * @module @tradik/xslt3/xslt/patterns/grammar
+ */
+
+import { NS } from "../../functions/signatures.js";
+import { withoutComments } from "../compiler/avt.js";
+import { xsltError } from "../names.js";
+
+/** Axes allowed in patterns. */
+const FORWARD_AXES = new Set([
+  "child",
+  "descendant",
+  "attribute",
+  "self",
+  "descendant-or-self",
+  "namespace",
+]);
+
+/** Functions allowed as the root of a path pattern, by local name. */
+const ROOT_FUNCTIONS = new Set(["doc", "id", "element-with-id", "key", "root"]);
+
+/** Argument kinds allowed in those calls. */
+const ARGUMENTS = new Set(["VarRef", "StringLiteral", "NumericLiteral"]);
+
+/**
+ * @param {string} message
+ * @returns {Error} XTSE0340
+ */
+const invalid = (message) => xsltError("XTSE0340", message);
+
+/**
+ * Removes the predicates of a filter expression.
+ * @param {object} ast
+ * @returns {object} the filtered expression
+ */
+export function unfiltered(ast) {
+  let base = ast;
+  while (base.type === "FilterExpr") base = base.base;
+  return base;
+}
+
+/**
+ * Whether an expression is a predicate pattern `.[P]...`.
+ * @param {object} ast
+ * @returns {boolean}
+ */
+export const isPredicatePattern = (ast) =>
+  unfiltered(ast).type === "ContextItemExpr";
+
+/**
+ * Whether a call is a rooted step: one of the allowed functions in the
+ * standard function namespace.
+ * @param {object} ast - A FunctionCall
+ * @returns {boolean}
+ */
+function isRootFunction(ast) {
+  const { prefix, uri, local } = ast.name;
+  const standard =
+    uri === NS.fn || (uri === null && (prefix === null || prefix === "fn"));
+  return standard && ROOT_FUNCTIONS.has(local);
+}
+
+/**
+ * Checks a rooted step `$v[...]` or `f(...)[...]`.
+ * @param {object} ast
+ */
+function checkRooted(ast) {
+  const base = unfiltered(ast);
+  if (base.type === "VarRef") return;
+  if (!isRootFunction(base)) {
+    throw invalid(`${base.name.local}() cannot start a pattern`);
+  }
+  if (base.name.local === "root" && base.arguments.length > 0) {
+    throw invalid("root() in a pattern takes no argument");
+  }
+  for (const argument of base.arguments) {
+    if (!ARGUMENTS.has(argument.type)) {
+      throw invalid("Arguments in a pattern must be variables or literals");
+    }
+  }
+}
+
+/**
+ * Whether a step is rooted (a variable or a function call, filtered).
+ * @param {object} ast
+ * @returns {boolean}
+ */
+export const isRootedStep = (ast) => {
+  const type = unfiltered(ast).type;
+  return type === "VarRef" || type === "FunctionCall";
+};
+
+/**
+ * Checks one step of a path pattern.
+ * @param {object} ast
+ * @param {boolean} first - The first step of a relative path
+ */
+function checkStep(ast, first) {
+  if (ast.type === "AxisStep") {
+    if (!FORWARD_AXES.has(ast.axis)) {
+      throw invalid(`The ${ast.axis} axis is not allowed in a pattern`);
+    }
+    return;
+  }
+  if (isRootedStep(ast)) {
+    if (!first) throw invalid("A rooted step must come first in a pattern");
+    checkRooted(ast);
+    return;
+  }
+  const base = unfiltered(ast);
+  if (
+    base.type === "SetExpr" ||
+    base.type === "PathExpr" ||
+    (base.type === "AxisStep" && base !== ast)
+  ) {
+    checkUnion(base);
+    return;
+  }
+  throw invalid("Invalid step in a pattern");
+}
+
+/**
+ * Checks a UnionExprP (no predicate pattern inside).
+ * @param {object} ast
+ */
+function checkUnion(ast) {
+  if (ast.type === "SetExpr") {
+    checkUnion(ast.left);
+    checkUnion(ast.right);
+    return;
+  }
+  if (ast.type === "PathExpr") {
+    ast.steps.forEach((step, i) => checkStep(step, i === 0 && !ast.absolute));
+    return;
+  }
+  checkStep(ast, true);
+}
+
+/** Functions a pattern cannot call, with their error codes. */
+const FORBIDDEN = {
+  "current-merge-group": "XTSE3470",
+  "current-merge-key": "XTSE3500",
+};
+
+/**
+ * Checks that a pattern calls none of the forbidden functions.
+ * @param {*} node - A node of the syntax tree (or any value in it)
+ */
+function checkFunctions(node) {
+  if (Array.isArray(node)) {
+    node.forEach(checkFunctions);
+    return;
+  }
+  if (typeof node !== "object" || node === null) return;
+  if (node.type === "FunctionCall" || node.type === "NamedFunctionRef") {
+    const code = FORBIDDEN[node.name.local];
+    const { uri, prefix } = node.name;
+    const standard =
+      uri === NS.fn || (uri === null && (prefix ?? "fn") === "fn");
+    if (code && standard) {
+      throw xsltError(code, `${node.name.local}() cannot be used in a pattern`);
+    }
+  }
+  for (const value of Object.values(node)) checkFunctions(value);
+}
+
+/**
+ * Checks a pattern.
+ * @param {object} ast - The parsed pattern
+ * @param {string} text - Its source text
+ * @throws {import("../../errors.js").XPathError} XTSE0340
+ */
+export function checkPattern(ast, text) {
+  checkFunctions(ast);
+  if (isPredicatePattern(ast)) {
+    if (/\S/.test(withoutComments(text.slice(0, unfiltered(ast).start)))) {
+      throw invalid("A predicate pattern cannot be parenthesized");
+    }
+    return;
+  }
+  checkUnion(ast);
+}

package/src/xslt/patterns/modes.js

@@ -0,0 +1,153 @@
+/**
+ * Modes and their template rules (XSLT 3.0 sections 6.4 to 6.6): rules
+ * ranked by import precedence, priority and declaration order, indexed by
+ * the node kind and name their patterns can match, so finding the rule
+ * for a node tests only the candidates for that node.
+ *
+ * @module @tradik/xslt3/xslt/patterns/modes
+ */
+
+import { xsltError } from "../names.js";
+
+/**
+ * A template rule: one alternative of the pattern of a template.
+ * @typedef {object} Rule
+ * @property {object} template - The compiled template
+ * @property {import("./compile.js").PatternAlternative} alternative
+ * @property {number} priority
+ * @property {number} precedence - Import precedence
+ * @property {number} position - Declaration order
+ * @property {number} [rank] - Position in the ranking (0 is best)
+ */
+
+/**
+ * The index keys of an item: specific (by name) and by kind.
+ * @param {*} item
+ * @returns {string[]}
+ */
+function itemKeys(item) {
+  switch (item?.nodeType) {
+    case 1:
+      return [`e{${item.namespaceURI ?? ""}}${item.localName}`, "k1"];
+    case 2:
+      return [`a{${item.namespaceURI ?? ""}}${item.localName}`, "k2"];
+    case 3:
+    case 4:
+      return ["k3"];
+    case 11:
+      return ["k9"];
+    case undefined:
+      return [];
+    default:
+      return [`k${item.nodeType}`];
+  }
+}
+
+/** A mode: its rules and how unmatched items are processed. */
+export class Mode {
+  /** @param {string} name - Clark name, "#default" for the unnamed mode */
+  constructor(name) {
+    this.name = name;
+    /** @type {Rule[]} */
+    this.rules = [];
+    this.onNoMatch = "text-only-copy";
+    this.onMultipleMatch = "use-last";
+    this.index = null;
+  }
+
+  /** @param {Rule} rule */
+  add(rule) {
+    this.rules.push(rule);
+    this.index = null;
+  }
+
+  /** Ranks the rules and builds the index. */
+  build() {
+    this.rules.sort(
+      (a, b) =>
+        b.precedence - a.precedence ||
+        b.priority - a.priority ||
+        b.position - a.position,
+    );
+    const index = new Map([["*", []]]);
+    this.rules.forEach((rule, rank) => {
+      rule.rank = rank;
+      const key = rule.alternative.key;
+      if (!index.has(key)) index.set(key, []);
+      index.get(key).push(rule);
+    });
+    this.index = index;
+  }
+
+  /**
+   * The candidate rules of an item, best first.
+   * @param {*} item
+   * @returns {Rule[]}
+   */
+  candidates(item) {
+    if (!this.index) {
+      this.build();
+      this.memo = new Map();
+    }
+    const keys = itemKeys(item);
+    const memoKey = keys[0] ?? "";
+    let result = this.memo.get(memoKey);
+    if (!result) {
+      const lists = [this.index.get("*")];
+      for (const key of keys) {
+        const list = this.index.get(key);
+        if (list) lists.push(list);
+      }
+      result = lists.flat().sort((a, b) => a.rank - b.rank);
+      this.memo.set(memoKey, result);
+    }
+    return result;
+  }
+
+  /**
+   * Finds the best matching rule.
+   * @param {*} item
+   * @param {object} xc - Context whose item is `item`
+   * @param {(rule: Rule) => boolean} [accept] - Restricts the rules
+   *   (xsl:apply-imports, xsl:next-match)
+   * @returns {Rule|null}
+   */
+  find(item, xc, accept) {
+    const candidates = this.candidates(item);
+    for (let i = 0; i < candidates.length; i++) {
+      const rule = candidates[i];
+      if (accept && !accept(rule)) continue;
+      if (!rule.alternative.matches(item, xc)) continue;
+      if (this.onMultipleMatch === "fail") {
+        this.checkAmbiguity(candidates, i, item, xc, accept);
+      }
+      return rule;
+    }
+    return null;
+  }
+
+  /**
+   * Raises XTDE0540 when another rule of the same rank matches.
+   * @param {Rule[]} candidates
+   * @param {number} i - Index of the chosen rule
+   * @param {*} item
+   * @param {object} xc
+   * @param {Function} [accept]
+   */
+  checkAmbiguity(candidates, i, item, xc, accept) {
+    const chosen = candidates[i];
+    for (let j = i + 1; j < candidates.length; j++) {
+      const other = candidates[j];
+      if (
+        other.precedence !== chosen.precedence ||
+        other.priority !== chosen.priority
+      ) {
+        break;
+      }
+      if (other.template === chosen.template) continue;
+      if ((!accept || accept(other)) && other.alternative.matches(item, xc)) {
+        throw xsltError("XTDE0540", "Several template rules match the item");
+      }
+    }
+  }
+}