@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/runtime/accumulators.js

@@ -0,0 +1,174 @@
+/**
+ * Accumulator values at run time (XSLT 3.0 sections 18.2.2 to 18.2.7):
+ * computed for a whole tree the first time a value of the tree is asked
+ * for, by a document-order traversal on an explicit stack, and cached
+ * per tree. Which accumulators apply to a tree is recorded per root (the
+ * source document: those of the initial mode; xsl:source-document: its
+ * use-accumulators; any other tree: all of them).
+ *
+ * @module @tradik/xslt3/xslt/runtime/accumulators
+ */
+
+import { childrenOf, rootOf } from "../../xpath/eval/domNodes.js";
+import { xsltError } from "../names.js";
+import { patternMatches } from "../patterns/compile.js";
+import { derive } from "./context.js";
+import { originalNode } from "./copyOrigins.js";
+
+/**
+ * The accumulator state of a transformation, created on first use.
+ * @param {object} tx
+ * @returns {{scopes: WeakMap, values: WeakMap, origins: WeakMap}}
+ */
+function stateOf(tx) {
+  tx.accumulatorState ??= {
+    scopes: new WeakMap(),
+    values: new WeakMap(),
+    origins: new WeakMap(),
+  };
+  return tx.accumulatorState;
+}
+
+/**
+ * Records which accumulators apply to a tree.
+ * @param {object} tx
+ * @param {Node} root - Root of the tree
+ * @param {Set<string>|"all"} accumulators
+ */
+export function setApplicable(tx, root, accumulators) {
+  stateOf(tx).scopes.set(root, accumulators);
+}
+
+/**
+ * Records that the nodes of a copy take their accumulator values from
+ * the nodes they were copied from.
+ * @param {object} tx
+ * @param {Node} copy
+ * @param {Node} original
+ */
+export function setOrigin(tx, copy, original) {
+  stateOf(tx).origins.set(copy, original);
+}
+
+/**
+ * The new value of an accumulator at a traversal event.
+ * @param {object} accumulator
+ * @param {Node} node
+ * @param {boolean} end - Phase
+ * @param {Array} value - The old value
+ * @param {object} xc - Context of the transformation
+ * @returns {Array}
+ */
+function step(accumulator, node, end, value, xc) {
+  const focus = derive(xc, { item: node, position: 1, size: 1 });
+  let rule = null;
+  for (const candidate of accumulator.rules) {
+    if (
+      candidate.end === end &&
+      patternMatches(candidate.pattern, node, focus)
+    ) {
+      rule = candidate;
+    }
+  }
+  if (!rule) return value;
+  const env = { value, next: xc.tx.globalEnv };
+  return rule.value(derive(focus, { env }), xc.tx.machine);
+}
+
+/**
+ * Computes the values of an accumulator for every node of a tree.
+ * @param {object} accumulator
+ * @param {Node} root
+ * @param {object} entry - Receives `before` and `after` (Maps by node)
+ * @param {object} xc - Context of the transformation
+ */
+function traverse(accumulator, root, entry, xc) {
+  let value;
+  let failure = null;
+  const apply = (compute) => {
+    if (failure) return;
+    try {
+      value = compute();
+    } catch (error) {
+      failure = { error };
+    }
+  };
+  apply(() =>
+    accumulator.initial(derive(xc, { item: root, position: 1, size: 1 })),
+  );
+  const stack = [[root, false]];
+  while (stack.length > 0) {
+    const [node, closing] = stack.pop();
+    apply(() => step(accumulator, node, closing, value, xc));
+    (closing ? entry.after : entry.before).set(node, failure ?? { value });
+    if (closing) continue;
+    stack.push([node, true]);
+    const children = childrenOf(node);
+    for (let i = children.length - 1; i >= 0; i--) {
+      stack.push([children[i], false]);
+    }
+  }
+}
+
+/**
+ * The pre- or post-descent value of an accumulator at a node.
+ * @param {object} xc - XSLT context
+ * @param {string} key - Clark name of the accumulator
+ * @param {Node} node
+ * @param {boolean} after - Post-descent value
+ * @param {object} accumulator - The declaration (packages may each have
+ *   one of that name)
+ * @returns {Array}
+ */
+export function accumulatorValue(xc, key, node, after, accumulator) {
+  const tx = xc.tx;
+  const state = stateOf(tx);
+  let target = node;
+  for (let o; (o = originalNode(state.origins, target));) target = o;
+  const root = rootOf(target);
+  const scope = state.scopes.get(root) ?? "all";
+  if (scope !== "all" && !scope.has(key)) {
+    throw xsltError("XTDE3362", `The accumulator ${key} does not apply here`);
+  }
+  let byKey = state.values.get(root);
+  if (!byKey) state.values.set(root, (byKey = new Map()));
+  let entry = byKey.get(accumulator);
+  if (!entry) {
+    entry = { before: new Map(), after: new Map(), done: false };
+    byKey.set(accumulator, entry);
+    traverse(accumulator, root, entry, tx.globalContext);
+    entry.done = true;
+  }
+  const result = (after ? entry.after : entry.before).get(target);
+  if (!result) {
+    throw xsltError("XTDE3400", `The accumulator ${key} depends on itself`);
+  }
+  if (result.error) throw result.error;
+  return result.value;
+}
+
+/**
+ * Records the accumulators that apply to the trees of the global context
+ * item (xsl:global-context-item, all by default) and of the initial match
+ * selection (those of the initial mode, none by default).
+ * @param {object} tx
+ * @param {object} options - See CompiledStylesheet.transform
+ * @param {*} source - The (stripped) source node
+ */
+export function setInitialAccumulators(tx, options, source) {
+  const { stylesheet } = tx;
+  const fromItems =
+    options.initialTemplate === undefined && !options.initialFunction;
+  const selection = fromItems
+    ? [options.initialMatchSelection ?? source].flat()
+    : [];
+  const fromMode = tx.defaultMode.accumulators ?? new Set();
+  for (const item of selection) {
+    if (typeof item?.nodeType === "number") {
+      setApplicable(tx, rootOf(item), fromMode);
+    }
+  }
+  if (typeof source?.nodeType === "number" && !selection.includes(source)) {
+    setApplicable(tx, rootOf(source), stylesheet.globalAccumulators);
+  }
+}

package/src/xslt/runtime/apply.js

@@ -0,0 +1,153 @@
+/**
+ * Template invocation at run time (XSLT 3.0 sections 6.7 to 6.9 and
+ * 10.1): applying templates to items in a mode, the built-in template
+ * rules, and binding the parameters of a template.
+ *
+ * @module @tradik/xslt3/xslt/runtime/apply
+ */
+
+import { childrenOf, attributesOf } from "../../xpath/eval/domNodes.js";
+import { isAtomic } from "../../xdm/atomic.js";
+import { canonicalString } from "../../xdm/lexical.js";
+import { stringValue } from "../../xdm/nodes.js";
+import { xsltError } from "../names.js";
+import { derive, withVariable } from "./context.js";
+import { markCopied, markDocumentCopied } from "./baseUri.js";
+import { copyNamespaceNodes } from "./copy.js";
+import { BodyFrame, LoopFrame } from "./machine.js";
+import { SequenceReceiver } from "./sequenceReceiver.js";
+
+/**
+ * Parameters passed to a template: non-tunnel ones by Clark name, and
+ * the tunnel parameters this call adds.
+ * @typedef {{params: Map<string, Array>, tunnel: Map<string, Array>|null}} Args
+ */
+
+/** No parameters. */
+export const NO_ARGS = Object.freeze({ params: new Map(), tunnel: null });
+
+/**
+ * Instantiates a template: binds its parameters and runs its body.
+ * @param {object} template - Compiled template
+ * @param {object} xc - Context of the invocation (focus, mode, rule set)
+ * @param {object} out - Receiver
+ * @param {import("./machine.js").Machine} machine
+ * @param {Args} args
+ */
+export function invokeTemplate(template, xc, out, machine, args) {
+  let tunnel = xc.tunnel;
+  if (args.tunnel && args.tunnel.size > 0) {
+    tunnel = new Map(tunnel ?? []);
+    for (const [key, value] of args.tunnel) tunnel.set(key, value);
+  }
+  let ctx = derive(xc, { env: xc.tx.globalEnv, tunnel, merge: undefined });
+  for (const param of template.params) {
+    let value = param.tunnel
+      ? tunnel?.get(param.key)
+      : args.params.get(param.key);
+    if (value !== undefined) value = param.convert(value);
+    else if (param.required) {
+      throw xsltError("XTDE0700", `The parameter ${param.key} is required`);
+    } else value = param.value(ctx, machine);
+    ctx = withVariable(ctx, value);
+  }
+  if (template.convert) {
+    const result = new SequenceReceiver(xc.tx.scratch);
+    machine.runBody(template.body, ctx, result);
+    for (const item of template.convert(result.items)) out.item(item);
+  } else if (template.body.length > 0) {
+    machine.push(new BodyFrame(template.body, ctx, out));
+  }
+}
+
+/**
+ * Applies templates to one item (the body of a LoopFrame visit).
+ * @param {*} item
+ * @param {object} xc - Context with the focus on the item
+ * @param {object} mode
+ * @param {object} out
+ * @param {import("./machine.js").Machine} machine
+ * @param {Args} args
+ */
+export function applyToItem(item, xc, mode, out, machine, args) {
+  const rule = mode.find(item, xc);
+  if (rule) {
+    invokeTemplate(rule.template, derive(xc, { rule }), out, machine, args);
+  } else applyBuiltIn(item, xc, mode, out, machine, args);
+}
+
+/**
+ * Applies templates to a sequence of items in a mode.
+ * @param {Array} items
+ * @param {object} mode
+ * @param {object} xc - Context of the instruction
+ * @param {object} out
+ * @param {import("./machine.js").Machine} machine
+ * @param {Args} args
+ */
+export function applyTemplates(items, mode, xc, out, machine, args) {
+  const size = items.length;
+  if (size === 0) return;
+  const base = derive(xc, {
+    mode,
+    group: undefined,
+    groupKey: undefined,
+  });
+  machine.push(
+    new LoopFrame(size, (i) => {
+      const item = items[i];
+      const ixc = derive(base, { item, position: i + 1, size });
+      applyToItem(item, ixc, mode, out, machine, args);
+    }),
+  );
+}
+
+/**
+ * The built-in template rule of a mode (its on-no-match behaviour).
+ * @param {*} item
+ * @param {object} xc - Context with the focus on the item
+ * @param {object} mode
+ * @param {object} out
+ * @param {import("./machine.js").Machine} machine
+ * @param {Args} args
+ */
+export function applyBuiltIn(item, xc, mode, out, machine, args) {
+  const action = mode.onNoMatch;
+  const type = item?.nodeType;
+  const container = type === 1 || type === 9 || type === 11;
+  if (action === "fail") {
+    throw xsltError("XTDE0555", "No template rule matches the item");
+  }
+  // deep-skip processes the children of a document node (XSLT 3.0 6.7.1)
+  if (action === "deep-skip" && type !== 9 && type !== 11) return;
+  const copy = action === "shallow-copy";
+  if (action === "deep-copy" || (copy && !container)) {
+    if (type === undefined) out.item(item);
+    else out.copy(item, true);
+    return;
+  }
+  if (!container) {
+    if (action === "text-only-copy") {
+      if (isAtomic(item)) out.text(canonicalString(item));
+      else if (type === 2 || type === 3 || type === 4) {
+        out.text(stringValue(item));
+      }
+    }
+    return;
+  }
+  let target = out;
+  if (copy && type === 1) {
+    target = out.element(item.namespaceURI ?? "", item.nodeName);
+    markCopied(item, target.parent);
+    copyNamespaceNodes(item, target);
+  } else if (copy) {
+    target = out.document();
+    markDocumentCopied(item, target);
+  }
+  const children = childrenOf(item);
+  const selected =
+    type === 1 && action !== "text-only-copy"
+      ? [...attributesOf(item), ...children]
+      : children;
+  applyTemplates(selected, mode, xc, target, machine, args);
+}

package/src/xslt/runtime/atomicKeys.js

@@ -0,0 +1,36 @@
+/**
+ * Hash keys of atomic values for keys and grouping: two values get the
+ * same key when they are equal under `eq` (untyped values compared as
+ * strings, numbers compared as doubles after promotion, strings under a
+ * collation).
+ *
+ * @module @tradik/xslt3/xslt/runtime/atomicKeys
+ */
+
+import { toDouble } from "../../functions/support.js";
+import { mapKey } from "../../items/mapKey.js";
+import { cast } from "../../xdm/cast.js";
+import { types } from "../../xdm/types.js";
+
+const NUMERIC = new Set(["decimal", "float", "double"]);
+
+/**
+ * The key of an atomic value.
+ * @param {import("../../xdm/atomic.js").AtomicValue} value
+ * @param {{key: ((s: string) => string)|null}|null} [collation]
+ * @returns {string}
+ */
+export function comparisonKey(value, collation = null) {
+  const atomic =
+    value.type === types.untypedAtomic ? cast(value, types.string) : value;
+  const primitive = atomic.type.primitive.localName;
+  if (NUMERIC.has(primitive)) return `n${toDouble(atomic)}`;
+  const key = mapKey(atomic);
+  if (collation?.key && key.startsWith("s")) {
+    return `s${collation.key(atomic.value)}`;
+  }
+  return key;
+}
+
+/** The key of NaN values. */
+export const NAN_KEY = "nNaN";

package/src/xslt/runtime/availability.js

@@ -0,0 +1,162 @@
+/**
+ * The functions that tell what the processor provides (XSLT 3.0 section
+ * 20.4): system-property(), available-system-properties(),
+ * element-available(), function-available() and type-available().
+ *
+ * @module @tradik/xslt3/xslt/runtime/availability
+ */
+
+import { isStandardFunction, NS } from "../../functions/signatures.js";
+import { booleanItem, stringItem } from "../../xpath/eval/atomics.js";
+import { AtomicValue } from "../../xdm/atomic.js";
+import { QNameValue } from "../../xdm/qname.js";
+import { getType, types, XS_NAMESPACE } from "../../xdm/types.js";
+import { LIST_TYPES } from "../../xpath/eval/typeExprs.js";
+import { resolveQName, XSL_NS } from "../names.js";
+import {
+  availableInstructions,
+  systemProperty,
+  systemPropertyNames,
+} from "./properties.js";
+
+/**
+ * Resolves a QName argument with the namespaces of the calling expression.
+ * @param {string} text
+ * @param {object} context - Dynamic context (with `sc`)
+ * @param {string} code - Error code for an invalid name
+ * @param {string} [defaultUri] - Namespace of unprefixed names
+ * @returns {{uri: string, local: string}}
+ */
+export function nameArgument(text, context, code, defaultUri = "") {
+  const namespaces = new Map(context.sc.namespaces);
+  namespaces.set("", defaultUri);
+  return resolveQName(text, namespaces, { code, useDefault: true });
+}
+
+/**
+ * Whether the transformation allows xsl:evaluate (the dynamicEvaluation
+ * option); always at compile time.
+ * @param {object} context - XPath dynamic context
+ * @returns {boolean}
+ */
+const dynamicEvaluation = (context) =>
+  context.xc?.tx.dynamicEvaluation !== false;
+
+/**
+ * Whether a function of a name exists with an arity.
+ * @param {object} library
+ * @param {string} uri
+ * @param {string} local
+ * @param {number} arity
+ * @returns {boolean}
+ */
+const hasFunction = (library, uri, local, arity) =>
+  Boolean(library.lookup(uri, local, arity)) ||
+  isStandardFunction(uri, local, arity);
+
+/**
+ * function-available().
+ * @param {Array} args
+ * @param {object} context
+ * @returns {Array}
+ */
+function functionAvailable([[name], arity], context) {
+  const { uri, local } = nameArgument(name.value, context, "XTDE1400", NS.fn);
+  const library = context.sc.functions;
+  const n = arity?.length ? Number(arity[0].value) : null;
+  let found = false;
+  for (let i = n ?? 0; i <= (n ?? 20) && !found; i++) {
+    found = hasFunction(library, uri, local, i);
+  }
+  if (!found && uri === XS_NAMESPACE && (n === null || n === 1)) {
+    try {
+      // list types (xs:NMTOKENS...) have constructor functions too
+      found = Boolean(LIST_TYPES[local]) || !getType(local).abstract;
+    } catch {
+      found = false;
+    }
+  }
+  return [booleanItem(found)];
+}
+
+/**
+ * type-available().
+ * @param {Array} args
+ * @param {object} context
+ * @returns {Array}
+ */
+function typeAvailable([[name]], context) {
+  const { uri, local } = nameArgument(name.value, context, "XTDE1428");
+  let found = false;
+  if (uri === XS_NAMESPACE) {
+    try {
+      found = Boolean(getType(local));
+    } catch {
+      found = ["anyType", "untyped", "anySimpleType"].includes(local);
+    }
+  }
+  return [booleanItem(found)];
+}
+
+/** Function definitions. */
+export const availabilityFunctions = [
+  {
+    local: "system-property",
+    params: ["xs:string"],
+    returns: "xs:string",
+    impl: ([[name]], context) => {
+      const { uri, local } = nameArgument(name.value, context, "XTDE1390");
+      if (uri !== XSL_NS) return [stringItem("")];
+      const off =
+        local === "supports-dynamic-evaluation" && !dynamicEvaluation(context);
+      return [stringItem(off ? "no" : systemProperty(local))];
+    },
+  },
+  {
+    local: "available-system-properties",
+    params: [],
+    returns: "xs:QName*",
+    impl: () =>
+      systemPropertyNames().map(
+        (local) =>
+          new AtomicValue(types.QName, new QNameValue(XSL_NS, local, "xsl")),
+      ),
+  },
+  {
+    local: "element-available",
+    params: ["xs:string"],
+    returns: "xs:boolean",
+    impl: ([[name]], context) => {
+      // unprefixed: the default namespace (xmlns) in scope
+      const { uri, local } = nameArgument(
+        name.value,
+        context,
+        "XTDE1440",
+        context.sc.defaultNamespace,
+      );
+      const available =
+        uri === XSL_NS &&
+        availableInstructions.has(local) &&
+        (local !== "evaluate" || dynamicEvaluation(context));
+      return [booleanItem(available)];
+    },
+  },
+  {
+    local: "function-available",
+    params: ["xs:string"],
+    returns: "xs:boolean",
+    impl: functionAvailable,
+  },
+  {
+    local: "function-available",
+    params: ["xs:string", "xs:integer"],
+    returns: "xs:boolean",
+    impl: functionAvailable,
+  },
+  {
+    local: "type-available",
+    params: ["xs:string"],
+    returns: "xs:boolean",
+    impl: typeAvailable,
+  },
+];

package/src/xslt/runtime/baseUri.js

@@ -0,0 +1,64 @@
+/**
+ * Base URIs of constructed nodes (XSLT 3.0 sections 11.1.? and 9.4): a
+ * temporary tree and the outermost element built by an instruction take
+ * the static base URI of the instruction; a copied element keeps the base
+ * URI of the original. Inner elements inherit theirs, adjusted by
+ * xml:base attributes, when fn:base-uri() asks (functions/nodePaths.js).
+ *
+ * @module @tradik/xslt3/xslt/runtime/baseUri
+ */
+
+import { recordedBaseUri, setBaseUri } from "../../functions/baseUris.js";
+import { nodeBaseUri } from "../../functions/nodePaths.js";
+
+/**
+ * Records the base URI of an element just built, when it is the
+ * outermost element of its tree and that tree's document node has no
+ * base URI of its own (a copied document keeps the original's, which its
+ * new children inherit).
+ * @param {{parent: Node}} content - Receiver of the element's content
+ * @param {string|undefined} base - Static base URI of the instruction
+ */
+export function markConstructed(content, base) {
+  const element = content.parent;
+  const parent = element?.parentNode;
+  if (parent?.nodeType === 1) return;
+  if (parent && copiedDocuments.has(parent)) return;
+  setBaseUri(element, base);
+}
+
+/** Document nodes made by copying a document. @type {WeakSet<Node>} */
+const copiedDocuments = new WeakSet();
+
+/**
+ * Records, on the copy of an element at the top of its new tree, the base
+ * URI its xml:base (copied too) applies to: the original's parent's. A
+ * shallow copy (xsl:copy), without the xml:base attribute, takes the
+ * original's own base URI. A copy attached to a new parent inherits.
+ * @param {Element} original
+ * @param {Element} copy
+ * @param {boolean} [withAttributes] - The attributes were copied too
+ */
+export function markCopied(original, copy, withAttributes = true) {
+  if (copy.parentNode) return;
+  if (!withAttributes) {
+    setBaseUri(copy, nodeBaseUri(original));
+    return;
+  }
+  const parent = original.parentNode;
+  setBaseUri(copy, parent ? nodeBaseUri(parent) : recordedBaseUri(original));
+}
+
+/**
+ * Records, on the copy of a document node, the base URI of the original,
+ * when the copy is a new document (not content added to a tree).
+ * @param {Node} original - Document node
+ * @param {{parent?: Node}} content - Receiver of the copy's content
+ */
+export function markDocumentCopied(original, content) {
+  const copy = content.parent;
+  if (copy && copy.nodeType !== 1 && !copy.parentNode) {
+    setBaseUri(copy, nodeBaseUri(original));
+    copiedDocuments.add(copy);
+  }
+}

package/src/xslt/runtime/compilerHook.js

@@ -0,0 +1,27 @@
+/**
+ * The stylesheet compiler as seen from the run time (fn:transform): set
+ * by the API module when it loads, so that the run time does not import
+ * the compiler (which imports the run time).
+ *
+ * @module @tradik/xslt3/xslt/runtime/compilerHook
+ */
+
+/** @type {(source: *, options: object) => object} */
+let compiler;
+
+/**
+ * Registers the compiler.
+ * @param {(source: *, options: object) => object} compile -
+ *   compileStylesheet of api.js
+ */
+export function setCompiler(compile) {
+  compiler = compile;
+}
+
+/**
+ * Compiles a stylesheet with the registered compiler.
+ * @param {*} source - Document, element or text of the stylesheet
+ * @param {object} options - Options of compileStylesheet
+ * @returns {object} the CompiledStylesheet
+ */
+export const compileWith = (source, options) => compiler(source, options);