@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/runtime/sequenceReceiver.js

@@ -0,0 +1,102 @@
+/**
+ * The receiver that collects the result of a sequence constructor as a
+ * sequence (variables and parameters with `as`, function bodies,
+ * xsl:sequence content...): constructed nodes are parentless, existing
+ * nodes are kept as they are.
+ *
+ * @module @tradik/xslt3/xslt/runtime/sequenceReceiver
+ */
+
+import { NamespaceNode } from "../../xpath/eval/namespaceNodes.js";
+import { copyNode } from "./copy.js";
+import { prefixOf, TreeReceiver } from "./treeReceiver.js";
+
+/** Collects items. */
+export class SequenceReceiver {
+  /**
+   * @param {() => Document} scratch - Gives the document that owns new
+   *   nodes
+   */
+  constructor(scratch) {
+    this.scratch = scratch;
+    /** @type {Array} the items received */
+    this.items = [];
+  }
+
+  /**
+   * @param {string} uri
+   * @param {string} qname
+   * @returns {TreeReceiver} the receiver of the new element's content
+   */
+  element(uri, qname) {
+    const element = this.scratch().createElementNS(uri || null, qname);
+    this.items.push(element);
+    const content = new TreeReceiver(element, new Map());
+    content.declare(prefixOf(qname), uri);
+    content.onReplace = (old, renamed) => {
+      this.items[this.items.indexOf(old)] = renamed;
+    };
+    return content;
+  }
+
+  /**
+   * @param {string} uri
+   * @param {string} qname
+   * @param {string} value
+   */
+  attribute(uri, qname, value) {
+    let name = qname;
+    if (uri && !prefixOf(qname)) name = `ns0:${qname}`;
+    const attribute = this.scratch().createAttributeNS(uri || null, name);
+    attribute.value = value;
+    attribute.nodeValue = value;
+    this.items.push(attribute);
+  }
+
+  /**
+   * @param {string} prefix
+   * @param {string} uri
+   */
+  namespace(prefix, uri) {
+    this.items.push(new NamespaceNode(null, prefix, uri));
+  }
+
+  /** @param {string} text */
+  text(text) {
+    this.items.push(this.scratch().createTextNode(text));
+  }
+
+  /** @param {string} text */
+  comment(text) {
+    this.items.push(this.scratch().createComment(text));
+  }
+
+  /**
+   * @param {string} target
+   * @param {string} data
+   */
+  pi(target, data) {
+    this.items.push(this.scratch().createProcessingInstruction(target, data));
+  }
+
+  /** @param {*} item - Any item, kept as it is */
+  item(item) {
+    this.items.push(item);
+  }
+
+  /**
+   * Adds a copy of a node.
+   * @param {Node} node
+   * @param {boolean} copyNamespaces
+   */
+  copy(node, copyNamespaces) {
+    copyNode(node, this, copyNamespaces);
+  }
+
+  /** @returns {TreeReceiver} the receiver of a new document node */
+  document() {
+    const fragment = this.scratch().createDocumentFragment();
+    this.items.push(fragment);
+    return new TreeReceiver(fragment, new Map());
+  }
+}

package/src/xslt/runtime/snapshot.js

@@ -0,0 +1,66 @@
+/**
+ * fn:snapshot of one node (XSLT 3.0 section 20.7): a deep copy of the
+ * node inside copies of its ancestors. Each ancestor is copied with its
+ * attributes and namespaces but without its other children, so the copy
+ * keeps the node's root, parent, attributes and namespaces.
+ *
+ * @module @tradik/xslt3/xslt/runtime/snapshot
+ */
+
+import { namedAttributeOf, parentOf } from "../../xpath/eval/domNodes.js";
+import { namespaceNodesOf } from "../../xpath/eval/namespaceNodes.js";
+import { copyNode, startElementCopy } from "./copy.js";
+
+/**
+ * Copies the ancestors of a node, outermost first.
+ * @param {Node[]} ancestors - Root first
+ * @param {object} receiver - Sequence receiver that gets the root copy
+ * @param {(copy: Node, original: Node) => void} record - Told of each copy
+ * @returns {object} the tree receiver of the innermost copy's content
+ */
+function copyAncestors(ancestors, receiver, record) {
+  const [root, ...rest] = ancestors;
+  let content =
+    root.nodeType === 1
+      ? startElementCopy(root, receiver, true)
+      : receiver.document();
+  record(content.parent, root);
+  for (const element of rest) {
+    content = startElementCopy(element, content, true);
+    record(content.parent, element);
+  }
+  return content;
+}
+
+/**
+ * The snapshot of a node.
+ * @param {Node} node
+ * @param {object} receiver - Sequence receiver (items get the root copy)
+ * @param {(copy: Node, original: Node) => void} record - Told of the
+ *   copy of each ancestor (accumulator values are those of the originals)
+ * @returns {Node} the copy of the node inside the copied tree
+ */
+export function snapshotNode(node, receiver, record) {
+  const ancestors = [];
+  for (let p = parentOf(node); p; p = parentOf(p)) ancestors.unshift(p);
+  if (ancestors.length === 0) {
+    copyNode(node, receiver, true);
+    return receiver.items.at(-1);
+  }
+  const content = copyAncestors(ancestors, receiver, record);
+  const parent = content.parent;
+  if (node.nodeType === 2) {
+    return namedAttributeOf(
+      parent,
+      node.namespaceURI ?? "",
+      node.localName ?? node.nodeName,
+    );
+  }
+  if (node.nodeType === 13) {
+    return namespaceNodesOf(parent).find(
+      (ns) => ns.localName === node.localName,
+    );
+  }
+  copyNode(node, content, true);
+  return parent.lastChild;
+}

package/src/xslt/runtime/sortKeys.js

@@ -0,0 +1,119 @@
+/**
+ * Sort keys at run time (XSLT 3.0 sections 13.1.2 and 13.1.3): the
+ * settings of a key from its attribute value templates, the key value of
+ * an item, and the comparison of key values (empty first, then NaN).
+ *
+ * @module @tradik/xslt3/xslt/runtime/sortKeys
+ */
+
+import { getCollation } from "../../functions/collations.js";
+import { stringItem } from "../../xpath/eval/atomics.js";
+import { compareAtomic } from "../../xdm/compare.js";
+import { toNumber } from "../../xdm/generalCompare.js";
+import { atomize, stringValue } from "../../xdm/nodes.js";
+import { types } from "../../xdm/types.js";
+import { cast } from "../../xdm/cast.js";
+import { xsltError } from "../names.js";
+import { evaluate } from "./context.js";
+import { bodySequence } from "./values.js";
+
+/**
+ * The comparison function of a lang or case-order setting.
+ * @param {string|undefined} lang
+ * @param {string|undefined} caseOrder
+ * @returns {(a: string, b: string) => number}
+ */
+function languageCollation(lang, caseOrder) {
+  let collator;
+  try {
+    collator = new Intl.Collator(lang || "en", {
+      caseFirst: caseOrder === "lower-first" ? "lower" : "upper",
+    });
+  } catch {
+    throw xsltError("XTDE0030", `Invalid lang ${lang}`);
+  }
+  return (a, b) => collator.compare(a, b);
+}
+
+/**
+ * The comparison settings of a key, from its attribute value templates.
+ * @param {object} key - Compiled xsl:sort
+ * @param {object} xc
+ * @returns {{descending: boolean, dataType: string, compare: Function}}
+ */
+export function settingsOf(key, xc) {
+  const order = key.order?.(xc).trim() ?? "ascending";
+  if (order !== "ascending" && order !== "descending") {
+    throw xsltError("XTDE0030", `Invalid sort order ${order}`);
+  }
+  const dataType = key.dataType?.(xc).trim() ?? "";
+  if (!["", "text", "number"].includes(dataType) && !dataType.includes(":")) {
+    throw xsltError("XTDE0030", `Invalid data-type ${dataType}`);
+  }
+  const caseOrder = key.caseOrder?.(xc).trim();
+  if (caseOrder && caseOrder !== "upper-first" && caseOrder !== "lower-first") {
+    throw xsltError("XTDE0030", `Invalid case-order ${caseOrder}`);
+  }
+  const lang = key.lang?.(xc).trim();
+  let compare;
+  if (key.collation) {
+    const uri = key.collation(xc).trim();
+    try {
+      compare = getCollation(uri, xc.tx.dyn).compare;
+    } catch {
+      throw xsltError("XTDE1035", `Unknown collation ${uri}`);
+    }
+  } else if (lang || caseOrder) compare = languageCollation(lang, caseOrder);
+  return { descending: order === "descending", dataType, compare };
+}
+
+/**
+ * The sort key value of one item.
+ * @param {object} key - Compiled xsl:sort
+ * @param {object} settings
+ * @param {object} xc - Context with the item as focus
+ * @param {object} machine
+ * @returns {*} an atomic value, or null for the empty sequence
+ */
+export function keyValue(key, settings, xc, machine) {
+  let values = key.expr
+    ? evaluate(key.expr, xc)
+    : bodySequence(key.body, xc, machine);
+  if (key.compatible) values = values.slice(0, 1);
+  if (settings.dataType === "text") {
+    return values.length ? stringItem(values.map(stringValue).join(" ")) : null;
+  }
+  const atoms = atomize(values);
+  if (atoms.length > 1) {
+    throw xsltError("XTTE1020", "A sort key must be a single value");
+  }
+  if (atoms.length === 0) return null;
+  if (settings.dataType === "number") return toNumber(atoms[0]);
+  const [value] = atoms;
+  return value.type === types.untypedAtomic ? cast(value, types.string) : value;
+}
+
+const isNaNValue = (v) => typeof v.value === "number" && Number.isNaN(v.value);
+
+/**
+ * Compares two key values: the empty sequence first, then NaN.
+ * @param {*} a
+ * @param {*} b
+ * @param {object} settings
+ * @param {object} xc
+ * @returns {number}
+ */
+export function compareValues(a, b, settings, xc) {
+  if (a === null || b === null) {
+    return (a === null ? 0 : 1) - (b === null ? 0 : 1);
+  }
+  if (isNaNValue(a) || isNaNValue(b)) {
+    return Number(!isNaNValue(a)) - Number(!isNaNValue(b));
+  }
+  const options = { ...xc.tx.dyn.compareOptions, collation: settings.compare };
+  try {
+    return compareAtomic(a, b, options).order || 0;
+  } catch {
+    throw xsltError("XTDE1030", "Sort key values are not comparable");
+  }
+}

package/src/xslt/runtime/streamAvailable.js

@@ -0,0 +1,60 @@
+/**
+ * fn:stream-available (XSLT 3.0 section 18.1): whether a call of
+ * xsl:source-document with streamable="yes" on the URI would start
+ * successfully. The processor does not stream, so this holds when the
+ * resource is a well-formed document or, as a streaming parser would see
+ * it, a resource that starts with a well-formed prolog and an element
+ * (a later well-formedness error is only met while streaming).
+ *
+ * @module @tradik/xslt3/xslt/runtime/streamAvailable
+ */
+
+import { booleanItem } from "../../functions/support.js";
+
+/** XML declaration, comments, processing instructions and whitespace. */
+const MISC = String.raw`(?:\s+|<!--[\s\S]*?-->|<\?[\s\S]*?\?>)*`;
+
+/** A prolog (with an optional document type declaration), then a tag. */
+const STARTS_WITH_ELEMENT = new RegExp(
+  `^\\uFEFF?${MISC}(?:<!DOCTYPE[^\\[>]*(?:\\[[\\s\\S]*?\\]\\s*)?>${MISC})?<[\\p{L}_:]`,
+  "u",
+);
+
+/**
+ * Whether a text starts as an XML document with an element.
+ * @param {string} text
+ * @returns {boolean}
+ */
+export const startsWithElement = (text) => STARTS_WITH_ELEMENT.test(text);
+
+/**
+ * Whether a document is available for streaming.
+ * @param {string} uri
+ * @param {object} context - XPath dynamic context
+ * @returns {boolean}
+ */
+function available(uri, context) {
+  try {
+    const document = context.loadDocument(uri);
+    if (document.documentElement) return true;
+  } catch {
+    // not a well-formed document: perhaps one that starts well
+  }
+  try {
+    return startsWithElement(context.loadText(uri));
+  } catch {
+    return false;
+  }
+}
+
+/** Function definitions. */
+export const streamAvailableFunctions = [
+  {
+    local: "stream-available",
+    params: ["xs:string?"],
+    returns: "xs:boolean",
+    impl: ([uri], context) => [
+      booleanItem(uri.length > 0 && available(uri[0].value, context)),
+    ],
+  },
+];

package/src/xslt/runtime/strip.js

@@ -0,0 +1,102 @@
+/**
+ * Whitespace stripping of source documents (XSLT 3.0 section 4.3): the
+ * whitespace-only text nodes whose parent element matches xsl:strip-space
+ * (and no better xsl:preserve-space rule), outside xml:space="preserve",
+ * are removed from a copy of the document.
+ *
+ * @module @tradik/xslt3/xslt/runtime/strip
+ */
+
+import { XML_NS } from "../names.js";
+
+const WHITESPACE = /^[ \t\r\n]*$/;
+
+/**
+ * Builds the decision of the rules for an element name.
+ * @param {object[]} rules - Best first (see compileSpaceRules)
+ * @returns {(element: Element) => boolean} whether to strip its children
+ */
+export function stripDecider(rules) {
+  const cache = new Map();
+  return (element) => {
+    const uri = element.namespaceURI ?? "";
+    const local = element.localName;
+    const key = `{${uri}}${local}`;
+    let strip = cache.get(key);
+    if (strip === undefined) {
+      const rule = rules.find(
+        (r) =>
+          (r.uri === null || r.uri === uri) &&
+          (r.local === null || r.local === local),
+      );
+      strip = rule ? rule.strip : false;
+      cache.set(key, strip);
+    }
+    return strip;
+  };
+}
+
+/**
+ * Whether a text node is one that stripping removes: whitespace only,
+ * its parent element matched by xsl:strip-space and not under
+ * xml:space="preserve".
+ * @param {Node} node
+ * @param {object[]} rules
+ * @returns {boolean}
+ */
+export function isStrippedText(node, rules) {
+  const parent = node.parentNode;
+  if (node.nodeType !== 3 || parent?.nodeType !== 1) return false;
+  if (!WHITESPACE.test(node.nodeValue) || !stripDecider(rules)(parent)) {
+    return false;
+  }
+  for (let e = parent; e?.nodeType === 1; e = e.parentNode) {
+    const space = e.getAttributeNS(XML_NS, "space");
+    if (space) return space !== "preserve";
+  }
+  return true;
+}
+
+/**
+ * A stripped copy of a document (the document itself when no rule
+ * strips anything).
+ * @param {Document} document
+ * @param {object[]} rules
+ * @returns {Document}
+ */
+export function stripDocument(document, rules) {
+  if (!rules.some((rule) => rule.strip)) return document;
+  const decide = stripDecider(rules);
+  const copy = document.implementation.createDocument(null, null, null);
+  for (const child of document.childNodes) {
+    if (child.nodeType !== 10) copy.appendChild(copy.importNode(child, true));
+  }
+  if (document.documentURI) {
+    try {
+      copy.documentURI = document.documentURI;
+    } catch {
+      // read-only in some DOMs
+    }
+  }
+  const stack = [[copy.documentElement, false]];
+  while (stack.length > 0) {
+    const [element, preserved] = stack.pop();
+    if (!element) continue;
+    const space = element.getAttributeNS(XML_NS, "space");
+    const keep = space === "preserve" || (space !== "default" && preserved);
+    const strip = !keep && decide(element);
+    for (let child = element.firstChild; child;) {
+      const next = child.nextSibling;
+      if (child.nodeType === 1) stack.push([child, keep]);
+      else if (
+        strip &&
+        child.nodeType === 3 &&
+        WHITESPACE.test(child.nodeValue)
+      ) {
+        element.removeChild(child);
+      }
+      child = next;
+    }
+  }
+  return copy;
+}

package/src/xslt/runtime/transformFunction.js

@@ -0,0 +1,169 @@
+/**
+ * fn:transform (F&O 3.1, "Dynamic loading"): runs another stylesheet from an
+ * XPath expression and returns its results as a map: "output" for the
+ * principal result and the absolute URI of each secondary result, each
+ * delivered as a document (default), serialized as a string, or raw.
+ * The stylesheet is compiled with the options of the calling one (module
+ * and package loaders) and runs with the resource loaders of the calling
+ * transformation.
+ *
+ * @module @tradik/xslt3/xslt/runtime/transformFunction
+ */
+
+import { XdmMap } from "../../items/map.js";
+import { serialize } from "../../serialize/index.js";
+import { atomize } from "../../xdm/nodes.js";
+import { parametersFromMap } from "../../serialize/params/fromMap.js";
+import { stringItem } from "../../xpath/eval/atomics.js";
+import { resolveUri } from "../../xpath/eval/uris.js";
+import { xsltError } from "../names.js";
+import { compileWith } from "./compilerHook.js";
+
+/**
+ * @param {*} item - An xs:QName value
+ * @returns {string} its Clark name
+ */
+const clark = (item) => `{${item.value.namespaceURI}}${item.value.localName}`;
+
+/**
+ * A map with QName keys as a Map by Clark name.
+ * @param {XdmMap|undefined} map
+ * @returns {Map<string, Array>}
+ */
+function byClarkName(map) {
+  const result = new Map();
+  for (const { key, value } of map?.entries.values() ?? []) {
+    result.set(clark(key), value);
+  }
+  return result;
+}
+
+/**
+ * The string value of an option, atomized (a value built by
+ * xsl:map-entry content is a text node).
+ * @param {Array|undefined} value
+ * @returns {string|undefined}
+ */
+const text = (value) =>
+  value?.length ? String(atomize(value.slice(0, 1))[0]?.value) : undefined;
+
+/**
+ * Reads the options map.
+ * @param {XdmMap} map
+ * @returns {(name: string) => Array|undefined} the value of an option
+ */
+const reader = (map) => (name) => map.get(stringItem(name));
+
+/**
+ * The stylesheet to run, compiled.
+ * @param {(name: string) => Array|undefined} option
+ * @param {object} context - XPath dynamic context
+ * @param {object} compileOptions - Options of the calling stylesheet
+ * @returns {object} the CompiledStylesheet
+ * @throws {import("../../errors.js").XPathError} FOXT0002 when no
+ *   stylesheet is given or it cannot be loaded
+ */
+function compiled(option, context, compileOptions) {
+  const value = (name) => option(name)?.[0];
+  const staticParams = byClarkName(value("static-params"));
+  const base = text(option("stylesheet-base-uri"));
+  const compile = (source, baseUri) =>
+    compileWith(source, { ...compileOptions, baseUri, staticParams });
+  const location = text(option("stylesheet-location"));
+  if (location !== undefined) {
+    const uri = resolveUri(location, context.staticBaseUri);
+    let source;
+    try {
+      source = compileOptions.loadStylesheet?.(uri, context.staticBaseUri);
+    } catch (error) {
+      throw xsltError("FOXT0002", `Cannot load ${uri}: ${error.message}`);
+    }
+    if (!source) throw xsltError("FOXT0002", `No stylesheet at ${uri}`);
+    return compile(source, uri);
+  }
+  const node = value("stylesheet-node") ?? text(option("stylesheet-text"));
+  if (node !== undefined) return compile(node, base);
+  const name = text(option("package-name"));
+  const found =
+    name === undefined
+      ? undefined
+      : compileOptions.resolvePackage?.(
+          name,
+          text(option("package-version")) ?? "*",
+        );
+  if (!found) throw xsltError("FOXT0002", "fn:transform: no stylesheet");
+  return compile(found.source ?? found, found.baseUri ?? base);
+}
+
+/**
+ * A result in the requested delivery format.
+ * @param {*} value - Document, fragment or raw sequence
+ * @param {string} format - "document", "serialized" or "raw"
+ * @param {object} output - Its serialization parameters
+ * @returns {Array}
+ */
+function delivered(value, format, output) {
+  const sequence = [value].flat();
+  if (format === "serialized") return [stringItem(serialize(sequence, output))];
+  return sequence;
+}
+
+/**
+ * fn:transform.
+ * @param {Array} args - The options map
+ * @param {object} context - XPath dynamic context
+ * @returns {Array} the result map
+ */
+function transform([[map]], context) {
+  const option = reader(map);
+  const value = (name) => option(name)?.[0];
+  const tx = context.xc?.tx;
+  const compileOptions =
+    tx?.stylesheet.options ?? context.sc?.owner?.options ?? {};
+  const format = text(option("delivery-format")) ?? "document";
+  const stylesheet = compiled(option, context, compileOptions);
+  const initial = (name) => (value(name) ? clark(value(name)) : undefined);
+  const functionParams = value("function-params");
+  const result = stylesheet.transform({
+    ...tx?.options,
+    source: value("source-node"),
+    initialTemplate: initial("initial-template"),
+    initialMode: initial("initial-mode"),
+    initialMatchSelection: option("initial-match-selection"),
+    initialFunction: value("initial-function") && {
+      name: initial("initial-function"),
+      args: functionParams?.members ?? [],
+    },
+    globalContextItem: value("global-context-item"),
+    params: byClarkName(value("stylesheet-params")),
+    templateParams: byClarkName(value("template-params")),
+    tunnelParams: byClarkName(value("tunnel-params")),
+    baseOutputUri: text(option("base-output-uri")),
+    buildTree: format === "raw" ? false : undefined,
+    onMessage: undefined,
+  });
+  const extra = value("serialization-params");
+  const params = extra ? parametersFromMap(extra) : {};
+  const entries = [];
+  const principal = [result.principal].flat();
+  if (principal.length > 0 || format !== "raw") {
+    entries.push([
+      stringItem("output"),
+      delivered(result.principal, format, { ...result.output, ...params }),
+    ]);
+  }
+  for (const [uri, { document, output }] of result.secondary) {
+    entries.push([stringItem(uri), delivered(document, format, output)]);
+  }
+  return [XdmMap.from(entries)];
+}
+
+/** Function definitions. */
+export const transformFunctions = [
+  {
+    local: "transform",
+    params: ["map(*)"],
+    returns: "map(*)",
+    impl: transform,
+  },
+];