@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/runtime/conditional.js

@@ -0,0 +1,110 @@
+/**
+ * Conditional content construction at run time (XSLT 3.0 section 8.4):
+ * vacuous and deemed-empty items, the sequence constructors that contain
+ * xsl:on-empty or xsl:on-non-empty, and the filter of
+ * xsl:where-populated.
+ *
+ * @module @tradik/xslt3/xslt/runtime/conditional
+ */
+
+import { isArray, isAtomic, isMap } from "../../xdm/atomic.js";
+import { canonicalString } from "../../xdm/lexical.js";
+import { SequenceReceiver } from "./sequenceReceiver.js";
+
+/**
+ * The members of an array, flattened.
+ * @param {object} array
+ * @returns {Array}
+ */
+const flatten = (array) =>
+  array.members
+    .flat()
+    .flatMap((item) => (isArray(item) ? flatten(item) : [item]));
+
+/**
+ * Whether an item is vacuous: a zero-length text node, a document node
+ * without children, an atomic value whose string is empty, an array of
+ * vacuous items.
+ * @param {*} item
+ * @returns {boolean}
+ */
+export function isVacuous(item) {
+  if (isAtomic(item)) return canonicalString(item) === "";
+  if (isArray(item)) return flatten(item).every(isVacuous);
+  const type = item?.nodeType;
+  if (type === 3 || type === 4) return item.nodeValue === "";
+  return (type === 9 || type === 11) && !item.firstChild;
+}
+
+/**
+ * Whether xsl:where-populated drops an item: a document or element node
+ * without children, another node whose string value is empty, an atomic
+ * value whose string is empty, an empty map, an array of such items.
+ * @param {*} item
+ * @returns {boolean}
+ */
+export function isDeemedEmpty(item) {
+  if (isAtomic(item)) return canonicalString(item) === "";
+  if (isMap(item)) return item.size === 0;
+  if (isArray(item)) return flatten(item).every(isDeemedEmpty);
+  const type = item?.nodeType;
+  if (type === 1 || type === 9 || type === 11) return !item.firstChild;
+  if (type === undefined) return false;
+  const value = type === 2 ? item.value : item.nodeValue;
+  return (value ?? "") === "";
+}
+
+/**
+ * Runs a step and collects the items it produces.
+ * @param {Function} step
+ * @param {object} xc
+ * @param {import("./machine.js").Machine} machine
+ * @returns {Array}
+ */
+export function stepItems(step, xc, machine) {
+  const out = new SequenceReceiver(xc.tx.scratch);
+  machine.runBody([step], xc, out);
+  return out.items;
+}
+
+/**
+ * Wraps a body that contains xsl:on-empty or xsl:on-non-empty (steps
+ * whose `conditional` is "empty" or "non-empty"): the other steps run
+ * first, collected; the xsl:on-non-empty steps run when one of them
+ * gave a non-vacuous item, the xsl:on-empty step when none did.
+ * @param {import("./machine.js").Body} body
+ * @returns {Function} a step running the whole body
+ */
+export function conditionalBody(body) {
+  return (xc, out, machine) => {
+    const results = [];
+    let context = xc;
+    let populated = false;
+    let onEmpty = null;
+    for (const step of body) {
+      if (step.binding) {
+        context = step.binding(context, machine);
+      } else if (step.conditional === "empty") {
+        onEmpty = { step, xc: context };
+      } else if (step.conditional === "non-empty") {
+        results.push({ step, xc: context });
+      } else {
+        const items = stepItems(step, context, machine);
+        populated ||= !items.every(isVacuous);
+        results.push(items);
+      }
+    }
+    const items = [];
+    if (!populated && onEmpty) {
+      items.push(...stepItems(onEmpty.step, onEmpty.xc, machine));
+    } else {
+      for (const result of results) {
+        if (Array.isArray(result)) items.push(...result);
+        else if (populated) {
+          items.push(...stepItems(result.step, result.xc, machine));
+        }
+      }
+    }
+    for (const item of items) out.item(item);
+  };
+}

package/src/xslt/runtime/context.js

@@ -0,0 +1,106 @@
+/**
+ * The XSLT context of an instruction (XSLT 3.0 section 5.4.3): the focus,
+ * the variables in scope, the current mode and template rule, the current
+ * group and grouping key, the captured groups of xsl:analyze-string, the
+ * tunnel parameters, and the transformation it belongs to. Contexts are
+ * immutable: instructions derive new ones.
+ *
+ * @module @tradik/xslt3/xslt/runtime/context
+ */
+
+/**
+ * @typedef {object} XsltContext
+ * @property {object} tx - The transformation (see transformation.js)
+ * @property {*} item - Context item, undefined when absent
+ * @property {number} position
+ * @property {number} size
+ * @property {{value: Array, next: object}|null} env - Variable values
+ * @property {object|null} mode - Current mode
+ * @property {object|null} rule - Current template rule
+ * @property {Array|undefined} group - Current group
+ * @property {Array|undefined} groupKey - Current grouping key
+ * @property {string[]|undefined} regex - Captured groups
+ * @property {Map<string, Array>|null} tunnel - Tunnel parameters
+ * @property {boolean} temporary - Temporary output state
+ * @property {object|null} dyn - Dynamic context of XPath, made on demand
+ */
+
+/**
+ * A context with some fields changed.
+ * @param {XsltContext} xc
+ * @param {Partial<XsltContext>} changes
+ * @returns {XsltContext}
+ */
+export function derive(xc, changes) {
+  const next = { ...xc, ...changes };
+  next.dyn = null;
+  return next;
+}
+
+/**
+ * A context with a new focus.
+ * @param {XsltContext} xc
+ * @param {*} item
+ * @param {number} position
+ * @param {number} size
+ * @returns {XsltContext}
+ */
+export const withFocus = (xc, item, position, size) =>
+  derive(xc, { item, position, size });
+
+/**
+ * A context with a variable bound innermost.
+ * @param {XsltContext} xc
+ * @param {Array} value
+ * @returns {XsltContext}
+ */
+export const withVariable = (xc, value) =>
+  derive(xc, { env: { value, next: xc.env } });
+
+/**
+ * The XPath dynamic context of an XSLT context: the dynamic context of
+ * the transformation with the XSLT context attached (read by current(),
+ * current-group(), regex-group()...).
+ * @param {XsltContext} xc
+ * @returns {object}
+ */
+export function dynamicContextOf(xc) {
+  let dyn = xc.dyn;
+  if (!dyn) {
+    dyn = Object.create(xc.tx.dyn);
+    dyn.xc = xc;
+    xc.dyn = dyn;
+  }
+  return dyn;
+}
+
+/**
+ * Evaluates a compiled expression in an XSLT context.
+ * @param {{run: Function}} expr
+ * @param {XsltContext} xc
+ * @returns {Array} the result sequence
+ */
+export function evaluate(expr, xc) {
+  const dyn = dynamicContextOf(xc);
+  useStaticContext(dyn, expr.sc);
+  return expr.run({
+    item: xc.item,
+    position: xc.position,
+    size: xc.size,
+    env: xc.env,
+    dyn,
+  });
+}
+
+/**
+ * Makes the static context of the expression about to run visible to
+ * the functions that need it (key(), system-property(), format-number(),
+ * doc() with a relative URI...).
+ * @param {object} dyn - XPath dynamic context
+ * @param {object} sc - Static context of the expression
+ */
+export function useStaticContext(dyn, sc) {
+  dyn.sc = sc;
+  dyn.staticBaseUri = sc.baseUri;
+  dyn.decimalFormats = sc.decimalFormats;
+}

package/src/xslt/runtime/copy.js

@@ -0,0 +1,123 @@
+/**
+ * Deep copies of nodes into a receiver (xsl:copy-of, nodes added to
+ * element content), with or without their namespace nodes. Iterative, so
+ * deep trees do not exhaust the call stack.
+ *
+ * @module @tradik/xslt3/xslt/runtime/copy
+ */
+
+import {
+  attributesOf,
+  isNamespaceDeclaration,
+} from "../../xpath/eval/domNodes.js";
+import { inScopeNamespaces } from "../../xpath/eval/namespaceNodes.js";
+import { markCopied, markDocumentCopied } from "./baseUri.js";
+
+/**
+ * Copies the namespace nodes of an element into a receiver.
+ * @param {Element} element
+ * @param {object} receiver
+ */
+export function copyNamespaceNodes(element, receiver) {
+  for (const [prefix, uri] of inScopeNamespaces(element)) {
+    if (prefix !== "xml" && uri !== "") receiver.namespace(prefix, uri);
+  }
+}
+
+/**
+ * Starts the copy of an element: its name, namespaces and attributes.
+ * @param {Element} element
+ * @param {object} receiver
+ * @param {boolean} copyNamespaces
+ * @param {boolean} [top] - The element is the root of the copy (its
+ *   inherited namespaces are copied too)
+ * @returns {object} the receiver of the element's content
+ */
+export function startElementCopy(
+  element,
+  receiver,
+  copyNamespaces,
+  top = true,
+) {
+  const content = receiver.element(
+    element.namespaceURI ?? "",
+    element.nodeName,
+  );
+  if (top) markCopied(element, content.parent);
+  if (copyNamespaces && top) copyNamespaceNodes(element, content);
+  else if (copyNamespaces) {
+    for (const attribute of element.attributes) {
+      if (!isNamespaceDeclaration(attribute)) continue;
+      const name = attribute.name;
+      content.namespace(name === "xmlns" ? "" : name.slice(6), attribute.value);
+    }
+  }
+  for (const attribute of attributesOf(element)) {
+    content.attribute(
+      attribute.namespaceURI ?? "",
+      attribute.nodeName,
+      attribute.value,
+    );
+  }
+  return content;
+}
+
+/**
+ * Copies a node that is not an element or document.
+ * @param {Node} node
+ * @param {object} receiver
+ */
+export function copyLeaf(node, receiver) {
+  switch (node.nodeType) {
+    case 2:
+      receiver.attribute(node.namespaceURI ?? "", node.nodeName, node.value);
+      break;
+    case 3:
+    case 4:
+      receiver.text(node.nodeValue);
+      break;
+    case 7:
+      receiver.pi(node.target ?? node.nodeName, node.nodeValue);
+      break;
+    case 8:
+      receiver.comment(node.nodeValue);
+      break;
+    default:
+      // a namespace node
+      receiver.namespace(node.localName, node.nodeValue);
+  }
+}
+
+/**
+ * Copies a node with its descendants into a receiver; a document node
+ * contributes its children.
+ * @param {Node} node
+ * @param {object} receiver - Tree or sequence receiver
+ * @param {boolean} copyNamespaces - Copy the namespace nodes of elements
+ */
+export function copyNode(node, receiver, copyNamespaces) {
+  const stack = [[node, receiver]];
+  while (stack.length > 0) {
+    const [current, target] = stack.pop();
+    const type = current.nodeType;
+    let content;
+    if (type === 1) {
+      content = startElementCopy(
+        current,
+        target,
+        copyNamespaces,
+        current === node,
+      );
+    } else if (type === 9 || type === 11) {
+      content = target.document();
+      markDocumentCopied(current, content);
+    } else {
+      copyLeaf(current, target);
+      continue;
+    }
+    const children = current.childNodes;
+    for (let i = children.length - 1; i >= 0; i--) {
+      if (children[i].nodeType !== 10) stack.push([children[i], content]);
+    }
+  }
+}

package/src/xslt/runtime/copyFunctions.js

@@ -0,0 +1,71 @@
+/**
+ * fn:copy-of and fn:snapshot (XSLT 3.0 sections 20.6 and 20.7): deep
+ * copies of nodes; a snapshot also copies the ancestors of each node.
+ *
+ * @module @tradik/xslt3/xslt/runtime/copyFunctions
+ */
+
+import { isNode } from "../../xdm/atomic.js";
+import { xsltError } from "../names.js";
+import { setOrigin } from "./accumulators.js";
+import { SequenceReceiver } from "./sequenceReceiver.js";
+import { snapshotNode } from "./snapshot.js";
+
+/**
+ * Copies the nodes of a sequence; other items are kept.
+ * @param {Array} items
+ * @param {object} context - XPath dynamic context
+ * @param {boolean} snapshot - fn:snapshot: copy the ancestors too
+ * @returns {Array}
+ */
+function copyItems(items, context, snapshot) {
+  const result = [];
+  for (const item of items) {
+    if (!isNode(item)) {
+      result.push(item);
+      continue;
+    }
+    const out = new SequenceReceiver(context.xc.tx.scratch);
+    let copy;
+    if (snapshot) {
+      copy = snapshotNode(item, out, (c, o) => setOrigin(context.xc.tx, c, o));
+    } else {
+      out.copy(item, true);
+      copy = out.items.at(-1);
+    }
+    setOrigin(context.xc.tx, copy, item);
+    result.push(copy);
+  }
+  return result;
+}
+
+/**
+ * The context item of a focus function.
+ * @param {object} context
+ * @returns {Array}
+ * @throws {import("../../errors.js").XPathError} XPDY0002 when absent
+ */
+function contextItemOf(context) {
+  if (context.contextItem === undefined) {
+    throw xsltError("XPDY0002", "The context item is absent");
+  }
+  return [context.contextItem];
+}
+
+/** Function definitions. */
+export const copyFunctions = ["copy-of", "snapshot"].flatMap((local) => [
+  {
+    local,
+    params: [],
+    returns: "item()*",
+    focus: true,
+    impl: (_, context) =>
+      copyItems(contextItemOf(context), context, local === "snapshot"),
+  },
+  {
+    local,
+    params: ["item()*"],
+    returns: "item()*",
+    impl: ([items], context) => copyItems(items, context, local === "snapshot"),
+  },
+]);

package/src/xslt/runtime/copyOrigins.js

@@ -0,0 +1,60 @@
+/**
+ * The original node a node of a copy stands for, for the accumulator
+ * values of copies (fn:copy-of, fn:snapshot, xsl:copy-of with
+ * copy-accumulators): copied nodes are recorded with their original, and
+ * a node inside a recorded copy is found by its child positions.
+ *
+ * Every accumulator-before()/accumulator-after() call asks, so the common
+ * case (a node of a source tree, in no copy) must stay cheap: the
+ * ancestors are first searched for a recorded copy, and child positions
+ * are only computed for nodes that are inside one. Positions are counted
+ * along previousSibling rather than with an indexOf over childNodes,
+ * which on jsdom goes through a live NodeList proxy per index.
+ *
+ * @module @tradik/xslt3/xslt/runtime/copyOrigins
+ */
+
+/**
+ * Position of a node among the children of its parent.
+ * @param {Node} node
+ * @returns {number}
+ */
+function positionOf(node) {
+  let position = 0;
+  for (let s = node.previousSibling; s; s = s.previousSibling) position++;
+  return position;
+}
+
+/**
+ * The nearest recorded copy containing a node (the node itself included).
+ * @param {WeakMap<Node, Node>} origins
+ * @param {Node} node
+ * @returns {Node|null}
+ */
+function recordedAncestor(origins, node) {
+  for (let current = node; current; current = current.parentNode) {
+    if (origins.has(current)) return current;
+  }
+  return null;
+}
+
+/**
+ * The node of the original tree a node of a copy stands for.
+ * @param {WeakMap<Node, Node>} origins - Copied nodes to original nodes
+ * @param {Node} node - Not an attribute (accumulators have no values
+ *   for attributes)
+ * @returns {Node|null} the original, null when the node is not in a copy
+ */
+export function originalNode(origins, node) {
+  const copy = recordedAncestor(origins, node);
+  if (!copy) return null;
+  const path = [];
+  for (let current = node; current !== copy; current = current.parentNode) {
+    path.push(positionOf(current));
+  }
+  let original = origins.get(copy);
+  for (let i = path.length - 1; i >= 0; i--) {
+    original = original.childNodes[path[i]];
+  }
+  return original;
+}

package/src/xslt/runtime/defaultMethod.js

@@ -0,0 +1,42 @@
+/**
+ * The default output method of a result tree (XSLT 3.0 section 26.1): html
+ * for an `html` document element in no namespace (any case), xhtml for
+ * `html` in the XHTML namespace (xml when the principal stylesheet module
+ * is version 1.0 and the tree is the implicit principal result), else xml.
+ *
+ * @module @tradik/xslt3/xslt/runtime/defaultMethod
+ */
+
+const XHTML_NS = "http://www.w3.org/1999/xhtml";
+
+/**
+ * The method a tree implies.
+ * @param {*} tree - Document or document fragment (other values: xml)
+ * @param {boolean} versionOne - XSLT 1.0 rules for an XHTML tree
+ * @returns {string}
+ */
+function impliedMethod(tree, versionOne) {
+  for (let child = tree?.firstChild; child; child = child.nextSibling) {
+    if (child.nodeType === 3 && /\S/.test(child.nodeValue)) return "xml";
+    if (child.nodeType !== 1) continue;
+    const local = child.localName;
+    const uri = child.namespaceURI ?? "";
+    if (local.toLowerCase() === "html" && uri === "") return "html";
+    if (local === "html" && uri === XHTML_NS && !versionOne) return "xhtml";
+    return "xml";
+  }
+  return "xml";
+}
+
+/**
+ * Serialization parameters with the default method when they have none.
+ * @param {object} output - Parameters of the output definition
+ * @param {*} tree - The result
+ * @param {boolean} [versionOne] - The implicit principal result of a
+ *   version 1.0 stylesheet
+ * @returns {object}
+ */
+export function withDefaultMethod(output, tree, versionOne = false) {
+  if (output.method !== undefined) return output;
+  return { ...output, method: impliedMethod(tree, versionOne) };
+}

package/src/xslt/runtime/documentContent.js

@@ -0,0 +1,93 @@
+/**
+ * The content of a document node added to a tree (XSLT 3.0 section
+ * 5.7.1): its children go to the enclosing node, but attributes and
+ * namespaces are errors (XTDE0420).
+ *
+ * @module @tradik/xslt3/xslt/runtime/documentContent
+ */
+
+import { isAtomic } from "../../xdm/atomic.js";
+import { canonicalString } from "../../xdm/lexical.js";
+import { xsltError } from "../names.js";
+import { copyNode } from "./copy.js";
+
+/** Receives the content of a document node inside a tree. */
+export class DocumentContent {
+  /** @param {object} target - Receiver of the enclosing node's content */
+  constructor(target) {
+    this.target = target;
+    this.lastAtomic = false;
+  }
+
+  /**
+   * @param {string} uri
+   * @param {string} qname
+   * @returns {object} the receiver of the new element's content
+   */
+  element(uri, qname) {
+    this.lastAtomic = false;
+    return this.target.element(uri, qname);
+  }
+
+  /** Raises XTDE0420. */
+  attribute() {
+    throw xsltError("XTDE0420", "A document node cannot have attributes");
+  }
+
+  /** Raises XTDE0420. */
+  namespace() {
+    throw xsltError("XTDE0420", "A document node cannot have namespaces");
+  }
+
+  /** @param {string} text */
+  text(text) {
+    this.lastAtomic = false;
+    this.target.text(text);
+  }
+
+  /** @param {string} text */
+  comment(text) {
+    this.lastAtomic = false;
+    this.target.comment(text);
+  }
+
+  /**
+   * @param {string} target
+   * @param {string} data
+   */
+  pi(target, data) {
+    this.lastAtomic = false;
+    this.target.pi(target, data);
+  }
+
+  /** @param {*} value - An atomic value */
+  atomic(value) {
+    const text = canonicalString(value);
+    this.target.text(this.lastAtomic ? ` ${text}` : text);
+    this.lastAtomic = true;
+  }
+
+  /** @param {*} item */
+  item(item) {
+    if (isAtomic(item)) this.atomic(item);
+    else if (typeof item?.nodeType === "number") this.copy(item, true);
+    else {
+      this.lastAtomic = false;
+      this.target.item(item);
+    }
+  }
+
+  /**
+   * @param {Node} node
+   * @param {boolean} copyNamespaces
+   */
+  copy(node, copyNamespaces) {
+    copyNode(node, this, copyNamespaces);
+  }
+
+  /** @returns {DocumentContent} itself */
+  document() {
+    this.lastAtomic = false;
+    return this;
+  }
+}

package/src/xslt/runtime/dynamicXPath.js

@@ -0,0 +1,90 @@
+/**
+ * The target expressions of xsl:evaluate (XSLT 3.0 sections 10.4.1 and
+ * 10.4.2): compiled at run time against a static context built from the
+ * instruction (or from the namespace-context node), without the
+ * XSLT-defined functions and the stylesheet variables, and cached per
+ * instruction.
+ *
+ * @module @tradik/xslt3/xslt/runtime/dynamicXPath
+ */
+
+import { FunctionLibrary } from "../../functions/registry.js";
+import { compileNode, withinLimits } from "../../xpath/eval/compiler.js";
+import { inScopeNamespaces } from "../../xpath/eval/namespaceNodes.js";
+import { createStaticContext } from "../../xpath/eval/staticContext.js";
+import { parseXPath } from "../../xpath/syntax/index.js";
+import { xsltError } from "../names.js";
+import { xsltFunctions } from "./functions.js";
+
+/** @type {WeakMap<FunctionLibrary, FunctionLibrary>} */
+const libraries = new WeakMap();
+
+/**
+ * The functions of a target expression: those of the stylesheet less
+ * the XSLT-defined ones (key(), current-group(), system-property()...).
+ * @param {FunctionLibrary} library - The library of the stylesheet
+ * @returns {FunctionLibrary}
+ */
+function targetLibrary(library) {
+  let result = libraries.get(library);
+  if (!result) {
+    const xslt = new Set(xsltFunctions);
+    const hidden = (d) =>
+      d.visibility === "private" || d.visibility === "hidden";
+    result = new FunctionLibrary(
+      library.definitions.filter((d) => !xslt.has(d) && !hidden(d)),
+    );
+    libraries.set(library, result);
+  }
+  return result;
+}
+
+/**
+ * The namespaces of a namespace-context node: its in-scope namespaces,
+ * the default one as the default element namespace.
+ * @param {Node} node
+ * @returns {{namespaces: Map<string, string>, defaultElementNamespace: string}}
+ */
+export function nodeNamespaces(node) {
+  const bindings = node.nodeType === 1 ? inScopeNamespaces(node) : new Map();
+  const defaultElementNamespace = bindings.get("") ?? "";
+  bindings.delete("");
+  return { namespaces: bindings, defaultElementNamespace };
+}
+
+/**
+ * Compiles a target expression.
+ * @param {string} text
+ * @param {object} context - `{namespaces, defaultElementNamespace,
+ *   baseUri, library, decimalFormats}`
+ * @param {string[]} keys - Clark names of the variables, outermost first
+ * @returns {(ctx: object) => Array} the evaluator
+ * @throws {import("../../errors.js").XPathError} XTDE3160 for a static
+ *   error in the expression
+ */
+export function compileTarget(text, context, keys) {
+  try {
+    const sc = createStaticContext(
+      {
+        namespaces: context.namespaces,
+        defaultElementNamespace: context.defaultElementNamespace,
+        baseUri: context.baseUri,
+        decimalFormats: context.decimalFormats,
+      },
+      targetLibrary(context.library),
+    );
+    let vars = null;
+    for (const key of keys) vars = { key, next: vars };
+    const run = withinLimits(() => compileNode(parseXPath(text), { sc, vars }));
+    return Object.assign(run, { sc });
+  } catch (error) {
+    // an undeclared variable keeps its code: the parameters vary per call
+    if (typeof error?.code !== "string" || error.code === "XPST0008") {
+      throw error;
+    }
+    throw xsltError(
+      "XTDE3160",
+      `Invalid expression "${text}" in xsl:evaluate: ${error.message}`,
+    );
+  }
+}