@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xpath/eval/documentOrder.js

@@ -0,0 +1,142 @@
+/**
+ * Document order of nodes (XDM 3.1 section 2.4), for any DOM.
+ *
+ * The nodes of a tree are numbered once, in one firstChild/nextSibling
+ * walk, the first time a node of that tree is compared. Sorting then
+ * compares numbers, which is fast whatever the DOM; walking ancestors per
+ * comparison (compareDocumentPosition in jsdom or xmldom) is not. Numbers
+ * grow across trees, so trees are ordered among themselves by when they
+ * were (last) numbered.
+ *
+ * Attributes and namespace nodes are not numbered: they sort after their
+ * element and before its first child (element p, its namespace nodes in
+ * (p, p + 0.5), its attributes at p + 0.75). Two attributes of the same
+ * element are ordered by their index in its attribute list, looked up only
+ * for such a tie: walking every attribute list up front would dominate
+ * sorting `//item/@price` (and NamedNodeMap is slow in jsdom).
+ *
+ * The numbering assumes the trees do not change while an instance is in
+ * use. One instance serves one evaluation (so a tree changed between two
+ * evaluations is numbered again) unless the caller shares one (dynamic
+ * option `documentOrder`) over trees it does not change. A node missing
+ * from its tree's numbering (added later) makes the tree be numbered
+ * again; a node moved within a numbered tree keeps its stale number.
+ *
+ * @module @tradik/xslt3/xpath/eval/documentOrder
+ */
+
+import { NODE_TYPES, parentOf, rootOf } from "./domNodes.js";
+import { namespaceNodesOf } from "./namespaceNodes.js";
+
+/** Offset of the attributes of an element from the element's number. */
+const ATTRIBUTE_OFFSET = 0.75;
+
+/** Positions of the nodes of trees, built lazily. */
+export class DocumentOrder {
+  constructor() {
+    /** @type {Map<Node, number>} */
+    this.positions = new Map();
+    /** @type {Map<Attr, number>} index in the attribute list */
+    this.attributeIndexes = new Map();
+    this.next = 0;
+  }
+
+  /**
+   * Numbers the nodes of the tree containing a node, attributes aside.
+   * @param {Node} node
+   */
+  index(node) {
+    const root = rootOf(node);
+    const positions = this.positions;
+    positions.set(root, this.next++);
+    let current = root.firstChild;
+    while (current) {
+      positions.set(current, this.next++);
+      const first = current.firstChild;
+      if (first) {
+        current = first;
+        continue;
+      }
+      while (!current.nextSibling) {
+        current = current.parentNode;
+        if (current === root || !current) return;
+      }
+      current = current.nextSibling;
+    }
+  }
+
+  /**
+   * @param {Node} node
+   * @returns {number} the position of a node: larger for later nodes
+   */
+  position(node) {
+    const type = node.nodeType;
+    if (type === NODE_TYPES.namespace) {
+      const element = parentOf(node);
+      const siblings = namespaceNodesOf(element);
+      const rank = siblings.indexOf(node) + 1;
+      return this.position(element) + rank / (2 * (siblings.length + 1));
+    }
+    if (type === NODE_TYPES.attribute && node.ownerElement) {
+      return this.position(node.ownerElement) + ATTRIBUTE_OFFSET;
+    }
+    let position = this.positions.get(node);
+    if (position === undefined) {
+      this.index(node);
+      position = this.positions.get(node);
+    }
+    return position;
+  }
+
+  /**
+   * @param {Attr} attribute - An attribute with an owner element
+   * @returns {number} its index in the attribute list of its element
+   */
+  attributeIndex(attribute) {
+    let index = this.attributeIndexes.get(attribute);
+    if (index === undefined) {
+      const attributes = attribute.ownerElement.attributes;
+      for (let i = 0, n = attributes.length; i < n; i++) {
+        this.attributeIndexes.set(attributes[i], i);
+      }
+      index = this.attributeIndexes.get(attribute) ?? 0;
+    }
+    return index;
+  }
+
+  /**
+   * Order of two nodes at the same position: the attributes of one
+   * element (or the same node twice).
+   * @returns {number}
+   */
+  tie(a, b) {
+    return a === b ? 0 : this.attributeIndex(a) - this.attributeIndex(b);
+  }
+
+  /**
+   * @param {Node} a
+   * @param {Node} b
+   * @returns {number} negative when a comes first, positive when b does,
+   *   0 for the same node
+   */
+  compare(a, b) {
+    if (a === b) return 0;
+    return this.position(a) - this.position(b) || this.tie(a, b);
+  }
+
+  /**
+   * @param {Node[]} nodes
+   * @returns {Node[]} the nodes in document order without duplicates (a
+   *   new array)
+   */
+  sort(nodes) {
+    if (nodes.length < 2) return nodes.slice();
+    const keyed = nodes.map((node) => ({ node, key: this.position(node) }));
+    keyed.sort((x, y) => x.key - y.key || this.tie(x.node, y.node));
+    const result = [keyed[0].node];
+    for (let i = 1; i < keyed.length; i++) {
+      if (keyed[i].node !== keyed[i - 1].node) result.push(keyed[i].node);
+    }
+    return result;
+  }
+}

package/src/xpath/eval/domNodes.js

@@ -0,0 +1,174 @@
+/**
+ * The XDM view of DOM nodes, for any DOM implementation (browsers, jsdom,
+ * @xmldom/xmldom): node kinds, names, parents, children and attributes.
+ *
+ * - Document fragments are document nodes; CDATA sections are text nodes
+ *   (adjacent text nodes are not merged); document type nodes are skipped.
+ * - Namespace declarations (`xmlns` attributes) are namespace nodes, never
+ *   attributes.
+ * - Namespace nodes are the objects of namespaceNodes.js (nodeType 13).
+ *
+ * @module @tradik/xslt3/xpath/eval/domNodes
+ */
+
+/** DOM nodeType values. */
+export const NODE_TYPES = Object.freeze({
+  element: 1,
+  attribute: 2,
+  text: 3,
+  cdata: 4,
+  processingInstruction: 7,
+  comment: 8,
+  document: 9,
+  documentType: 10,
+  fragment: 11,
+  namespace: 13,
+});
+
+/** Namespace of `xmlns` attributes. */
+export const XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
+
+/** XDM node kinds by DOM nodeType. */
+const KINDS = {
+  1: "element",
+  2: "attribute",
+  3: "text",
+  4: "text",
+  7: "processing-instruction",
+  8: "comment",
+  9: "document",
+  11: "document",
+  13: "namespace",
+};
+
+/** @param {Node} node @returns {string|undefined} the XDM node kind */
+export const nodeKind = (node) => KINDS[node.nodeType];
+
+/**
+ * @param {Node} attribute
+ * @returns {boolean} whether an attribute is a namespace declaration
+ */
+export function isNamespaceDeclaration(attribute) {
+  if (attribute.namespaceURI === XMLNS_NAMESPACE) return true;
+  const name = attribute.name ?? attribute.nodeName;
+  return (
+    !attribute.namespaceURI && (name === "xmlns" || name.startsWith("xmlns:"))
+  );
+}
+
+/**
+ * @param {Node} node
+ * @returns {Node|null} the parent in XDM terms (the element of an
+ *   attribute or namespace node)
+ */
+export function parentOf(node) {
+  const type = node.nodeType;
+  if (type === 2 || type === 13) return node.ownerElement ?? null;
+  return node.parentNode ?? null;
+}
+
+/**
+ * @param {Node} node
+ * @returns {boolean} whether the node is an XDM node (not a document type)
+ */
+export const isXdmNode = (node) => KINDS[node.nodeType] !== undefined;
+
+/**
+ * @param {Node} node
+ * @returns {boolean} whether the node can have children (element,
+ *   document, document fragment)
+ */
+export const isContainer = (node) => {
+  const type = node.nodeType;
+  return type === 1 || type === 9 || type === 11;
+};
+
+/**
+ * @param {Node} node
+ * @returns {Node[]} the children in XDM terms
+ */
+export function childrenOf(node) {
+  if (!isContainer(node)) return [];
+  const result = [];
+  // firstChild/nextSibling: childNodes is a live list behind a Proxy in
+  // jsdom, several times slower to iterate
+  for (let child = node.firstChild; child; child = child.nextSibling) {
+    if (isXdmNode(child)) result.push(child);
+  }
+  return result;
+}
+
+/**
+ * @param {Node} node
+ * @returns {Attr[]} the attributes of an element, without namespace
+ *   declarations; none for other nodes
+ */
+export function attributesOf(node) {
+  if (node.nodeType !== 1) return [];
+  const attributes = node.attributes;
+  const result = [];
+  for (let i = 0, n = attributes.length; i < n; i++) {
+    const attribute = attributes[i];
+    if (!isNamespaceDeclaration(attribute)) result.push(attribute);
+  }
+  return result;
+}
+
+/**
+ * The attribute of an element with a name, without walking its attribute
+ * list (slow in jsdom).
+ * @param {Node} node
+ * @param {string} uri - Namespace URI, "" for none
+ * @param {string} local - Local name
+ * @returns {Attr|null} the attribute, null when the element has none of
+ *   that name (or the node is not an element); undefined when the DOM
+ *   cannot look attributes up by name
+ */
+export function namedAttributeOf(node, uri, local) {
+  if (node.nodeType !== 1) return null;
+  if (typeof node.getAttributeNodeNS !== "function") return undefined;
+  const attribute = node.getAttributeNodeNS(uri === "" ? null : uri, local);
+  return attribute && !isNamespaceDeclaration(attribute) ? attribute : null;
+}
+
+/** @param {Node} node @returns {string} namespace URI of the name, "" for none */
+export const nodeNamespace = (node) => node.namespaceURI ?? "";
+
+/**
+ * @param {Node} node
+ * @returns {string} local part of the node name: the target of a
+ *   processing instruction, the prefix of a namespace node, "" for unnamed
+ *   nodes
+ */
+export function nodeLocalName(node) {
+  switch (node.nodeType) {
+    case 1:
+    case 2:
+      return node.localName ?? node.nodeName;
+    case 7:
+      return node.target ?? node.nodeName;
+    case 13:
+      return node.localName;
+    default:
+      return "";
+  }
+}
+
+/**
+ * @param {Node} node
+ * @returns {string} prefix of an element or attribute name, "" for none
+ */
+export const nodePrefix = (node) =>
+  node.nodeType === 1 || node.nodeType === 2 ? (node.prefix ?? "") : "";
+
+/**
+ * @param {Node} node
+ * @returns {Node} the root of the tree containing the node
+ */
+export function rootOf(node) {
+  let current = node;
+  for (let parent = parentOf(current); parent; parent = parentOf(current)) {
+    current = parent;
+  }
+  return current;
+}

package/src/xpath/eval/dynamicCall.js

@@ -0,0 +1,27 @@
+/**
+ * The dynamic context of dynamic function calls and inline function
+ * bodies, which XSLT 3.0 distinguishes (fn:current-output-uri is absent
+ * there).
+ *
+ * @module @tradik/xslt3/xpath/eval/dynamicCall
+ */
+
+/** @type {WeakMap<object, object>} */
+const dynamicCallContexts = new WeakMap();
+
+/**
+ * The dynamic context of a dynamic function call or an inline function
+ * body: the caller's, marked `dynamicCall` (XSLT 3.0 clears the current
+ * output URI there, see fn:current-output-uri).
+ * @param {object} dyn - Dynamic context the function item was made in
+ * @returns {object} a context inheriting from it, one per context
+ */
+export function dynamicCallContext(dyn) {
+  let derived = dynamicCallContexts.get(dyn);
+  if (!derived) {
+    derived = Object.create(dyn);
+    derived.dynamicCall = true;
+    dynamicCallContexts.set(dyn, derived);
+  }
+  return derived;
+}

package/src/xpath/eval/dynamicContext.js

@@ -0,0 +1,161 @@
+/**
+ * The dynamic context of one evaluation (XPath 3.1 section 2.1.2), shared
+ * by every evaluator of the expression and passed to function
+ * implementations: implicit timezone, current date and time (stable during
+ * the evaluation), available documents, document order, collation.
+ *
+ * @module @tradik/xslt3/xpath/eval/dynamicContext
+ */
+
+import { XPathError } from "../../errors.js";
+import { DateTimeValue } from "../../xdm/datetime.js";
+import { Decimal } from "../../xdm/decimal.js";
+import { DocumentOrder } from "./documentOrder.js";
+import { deepEqualItem } from "../../functions/mapArrayEqual.js";
+import { compareCodepoints } from "../../xdm/strings.js";
+import { functionItemOf, resolveFunction } from "./functionItems.js";
+import {
+  createCollections,
+  createTextLoader,
+  createXmlParser,
+} from "./resources.js";
+import { resolveUri } from "./uris.js";
+
+const XSL_NAMESPACE = "http://www.w3.org/1999/XSL/Transform";
+
+/**
+ * The date and time of a JS Date in a timezone.
+ * @param {Date} date
+ * @param {number} timezone - Offset in minutes
+ * @returns {DateTimeValue}
+ */
+export function dateTimeOf(date, timezone) {
+  const shifted = new Date(date.getTime() + timezone * 60000);
+  const millis = shifted.getUTCMilliseconds();
+  return new DateTimeValue({
+    year: shifted.getUTCFullYear(),
+    month: shifted.getUTCMonth() + 1,
+    day: shifted.getUTCDate(),
+    hour: shifted.getUTCHours(),
+    minute: shifted.getUTCMinutes(),
+    second: Decimal.of(BigInt(shifted.getUTCSeconds() * 1000 + millis), 3),
+    timezone,
+  });
+}
+
+/**
+ * A document loader with the stability of fn:doc (the same URI gives the
+ * same document during an evaluation). Raises FODC0005 for an invalid URI
+ * (a colon not preceded by a valid scheme) and FODC0002 when the loader
+ * fails or finds nothing.
+ * @param {((uri: string, base?: string) => Node)|undefined} loader - Gets
+ *   the absolute URI and the base URI it was resolved against
+ * @param {string|undefined} baseUri
+ * @returns {(uri: string, base?: string) => Node}
+ */
+function documentLoader(loader, baseUri) {
+  const documents = new Map();
+  return (uri, base = baseUri) => {
+    const scheme = /^([^/?#]*):/.exec(uri);
+    if (scheme && !/^[A-Za-z][A-Za-z0-9+.-]*$/.test(scheme[1])) {
+      throw new XPathError("FODC0005", `Invalid URI ${uri}`);
+    }
+    const absolute = resolveUri(uri, base);
+    if (documents.has(absolute)) return documents.get(absolute);
+    let document;
+    try {
+      document = loader?.(absolute, base);
+    } catch (error) {
+      throw new XPathError("FODC0002", `Cannot load ${absolute}`, {
+        cause: error,
+      });
+    }
+    if (!document) {
+      throw new XPathError("FODC0002", `No document at ${absolute}`);
+    }
+    documents.set(absolute, document);
+    return document;
+  };
+}
+
+/**
+ * A factory of empty documents for functions that build nodes (such as
+ * fn:analyze-string): the DOM implementation of the context node, else of
+ * the global document.
+ * @param {*} contextNode
+ * @returns {() => Document}
+ */
+function documentFactory(contextNode) {
+  return () => {
+    const owner = contextNode?.ownerDocument ?? contextNode;
+    const implementation =
+      owner?.implementation ?? globalThis.document?.implementation;
+    if (!implementation) {
+      throw new XPathError(
+        "XPDY0130",
+        "No DOM implementation to build nodes with: pass createDocument",
+      );
+    }
+    return implementation.createDocument(null, null, null);
+  };
+}
+
+/**
+ * Creates the dynamic context of an evaluation.
+ * @param {import("./staticContext.js").StaticContext} sc
+ * @param {object} options - Dynamic options (see xpath/index.js)
+ * @param {*} [contextNode] - Context item, whose DOM builds new nodes when
+ *   `options.createDocument` is absent
+ * @returns {object} the dynamic context
+ */
+export function createDynamicContext(sc, options, contextNode) {
+  const implicitTimezone = options.implicitTimezone ?? 0;
+  const now = options.currentDateTime;
+  const currentDateTime =
+    now instanceof DateTimeValue
+      ? now
+      : dateTimeOf(now ?? new Date(), implicitTimezone);
+  const compareOptions = { implicitTimezone };
+  return {
+    implicitTimezone,
+    currentDateTime,
+    defaultCollation: sc.defaultCollation,
+    staticBaseUri: sc.baseUri,
+    defaultLanguage: "en",
+    contextItem: undefined,
+    position: 0,
+    size: 0,
+    loadDocument: documentLoader(options.documentLoader, sc.baseUri),
+    loadText: createTextLoader(options.textLoader, sc.baseUri),
+    parseXml: createXmlParser(options.xmlParser),
+    collection: createCollections(options.collections, sc.baseUri),
+    trace: options.trace ?? (() => {}),
+    decimalFormats: sc.decimalFormats,
+    createDocument: options.createDocument ?? documentFactory(contextNode),
+    deepEqualItem: function hook(a, b, itemOptions) {
+      return deepEqualItem(a, b, {
+        ...compareOptions,
+        collation: compareCodepoints,
+        deepEqualItem: hook,
+        ...itemOptions,
+      });
+    },
+    order: options.documentOrder ?? new DocumentOrder(),
+    // Set by the owner of an evaluation (see descendantMemo.js)
+    descendantMemo: null,
+    compareOptions,
+    compatibleCompareOptions: { ...compareOptions, backwardsCompatible: true },
+    lookupFunction(uri, local, arity, ctx) {
+      // xsl:original is only reachable by a static call (XSLT 3.0 3.5.3)
+      if (uri === XSL_NAMESPACE) return null;
+      try {
+        // the static context of the calling expression, when one is set
+        const callSc = this.sc ?? sc;
+        return functionItemOf(resolveFunction(uri, local, arity, callSc), ctx);
+      } catch (error) {
+        if (error.code === "XPST0017") return null;
+        throw error;
+      }
+    },
+  };
+}

package/src/xpath/eval/flow.js

@@ -0,0 +1,115 @@
+/**
+ * Compilers of the control-flow expressions: for, let, some/every, if and
+ * the simple map operator `!` (XPath 3.1 sections 3.12 to 3.14, 3.17).
+ *
+ * @module @tradik/xslt3/xpath/eval/flow
+ */
+
+import { effectiveBooleanValue } from "../../xdm/nodes.js";
+import { booleanItem } from "./atomics.js";
+import { bindVariable, withFocus, withVariable } from "./scope.js";
+import { clark, namespaceOf } from "./staticContext.js";
+
+/**
+ * @param {import("../syntax/ast.js").Binding} binding
+ * @param {import("./scope.js").Scope} scope
+ * @returns {string} Clark name of the bound variable
+ */
+const bindingKey = (binding, scope) =>
+  clark(namespaceOf(binding.name, scope.sc, ""), binding.name.local);
+
+/**
+ * Compiles nested bindings, innermost last: `wrap` builds the evaluator of
+ * one binding from its input and the evaluator of what it encloses.
+ * @param {import("../syntax/ast.js").Binding[]} bindings
+ * @param {import("./scope.js").Scope} scope
+ * @param {Function} compile
+ * @param {(scope: object) => Function} body - Compiles the innermost part
+ * @param {(input: Function, inner: Function) => Function} wrap
+ * @returns {import("./scope.js").Evaluator}
+ */
+function nest(bindings, scope, compile, body, wrap) {
+  const level = (index, current) => {
+    if (index === bindings.length) return body(current);
+    const binding = bindings[index];
+    const input = compile(binding.expr, current);
+    const inner = level(
+      index + 1,
+      bindVariable(current, bindingKey(binding, current)),
+    );
+    return wrap(input, inner);
+  };
+  return level(0, scope);
+}
+
+/** Compilers by node type. */
+export const flowCompilers = {
+  ForExpr(node, scope, compile) {
+    return nest(
+      node.bindings,
+      scope,
+      compile,
+      (inner) => compile(node.returnExpr, inner),
+      (input, inner) => (ctx) => {
+        const result = [];
+        for (const item of input(ctx)) {
+          for (const out of inner(withVariable(ctx, [item]))) result.push(out);
+        }
+        return result;
+      },
+    );
+  },
+
+  LetExpr(node, scope, compile) {
+    return nest(
+      node.bindings,
+      scope,
+      compile,
+      (inner) => compile(node.returnExpr, inner),
+      (input, inner) => (ctx) => inner(withVariable(ctx, input(ctx))),
+    );
+  },
+
+  QuantifiedExpr(node, scope, compile) {
+    const some = node.quantifier === "some";
+    const test = nest(
+      node.bindings,
+      scope,
+      compile,
+      (inner) => {
+        const satisfies = compile(node.satisfies, inner);
+        return (ctx) => effectiveBooleanValue(satisfies(ctx));
+      },
+      (input, inner) => (ctx) => {
+        for (const item of input(ctx)) {
+          if (inner(withVariable(ctx, [item])) === some) return some;
+        }
+        return !some;
+      },
+    );
+    return (ctx) => [booleanItem(test(ctx))];
+  },
+
+  IfExpr(node, scope, compile) {
+    const condition = compile(node.condition, scope);
+    const thenExpr = compile(node.thenExpr, scope);
+    const elseExpr = compile(node.elseExpr, scope);
+    return (ctx) =>
+      effectiveBooleanValue(condition(ctx)) ? thenExpr(ctx) : elseExpr(ctx);
+  },
+
+  SimpleMapExpr(node, scope, compile) {
+    const left = compile(node.left, scope);
+    const right = compile(node.right, scope);
+    return (ctx) => {
+      const input = left(ctx);
+      const result = [];
+      const size = input.length;
+      for (let i = 0; i < size; i++) {
+        const out = right(withFocus(ctx, input[i], i + 1, size));
+        for (const item of out) result.push(item);
+      }
+      return result;
+    };
+  },
+};