@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/runtime/namespaceScope.js

@@ -0,0 +1,141 @@
+/**
+ * The namespaces of an element under construction: its own namespace
+ * nodes (from its name, its attributes' names and namespace
+ * instructions) and those in scope from its ancestors, with the `xmlns`
+ * declarations the DOM needs (XSLT 3.0 section 5.7.3, namespace fixup).
+ *
+ * @module @tradik/xslt3/xslt/runtime/namespaceScope
+ */
+
+import { XML_NS, XMLNS_NS } from "../names.js";
+
+/**
+ * @param {string} qname
+ * @returns {string} the prefix of a lexical QName, "" for none
+ */
+export const prefixOf = (qname) => {
+  const colon = qname.indexOf(":");
+  return colon < 0 ? "" : qname.slice(0, colon);
+};
+
+/** Namespace bookkeeping of the element a receiver builds. */
+export class NamespaceScope {
+  /**
+   * @param {Node} parent - The element (or document) built
+   * @param {Map<string, string>} namespaces - In scope at its parent
+   */
+  constructor(parent, namespaces) {
+    this.parent = parent;
+    this.inherited = namespaces;
+    this.namespaces = namespaces;
+    this.ownNamespaces = false;
+    /** @type {Map<string, string>|null} namespace nodes of this element */
+    this.own = null;
+    /** @type {Set<string>} prefixes of namespace nodes added explicitly */
+    this.explicit = new Set();
+    /** @type {((old: Element, element: Element) => void)|null} */
+    this.onReplace = null;
+  }
+
+  /**
+   * Gives the element a namespace node that conflicts with the prefix of
+   * its name: the element is renamed with a new prefix (namespace fixup).
+   * @param {string} prefix
+   * @param {string} uri
+   * @returns {boolean} false when the conflict is not with the name, or
+   *   when the name's namespace node was itself added explicitly
+   */
+  rebind(prefix, uri) {
+    const old = this.parent;
+    if (prefix === "" || old.prefix !== prefix || this.explicit.has(prefix)) {
+      return false;
+    }
+    let fresh;
+    for (let i = 0; this.namespaces.has((fresh = `${prefix}_${i}`)); i++);
+    const element = old.ownerDocument.createElementNS(
+      old.namespaceURI,
+      `${fresh}:${old.localName}`,
+    );
+    for (const attribute of old.attributes) {
+      if (attribute.name === `xmlns:${prefix}`) continue;
+      element.setAttributeNS(
+        attribute.namespaceURI,
+        attribute.name,
+        attribute.value,
+      );
+    }
+    old.parentNode?.replaceChild(element, old);
+    this.onReplace?.(old, element);
+    this.parent = element;
+    this.own.delete(prefix);
+    if (this.ownNamespaces) {
+      const before = this.inherited.get(prefix);
+      if (before === undefined) this.namespaces.delete(prefix);
+      else this.namespaces.set(prefix, before);
+    }
+    this.declare(fresh, old.namespaceURI);
+    return this.declare(prefix, uri);
+  }
+
+  /**
+   * Gives the element a namespace node, declared when not in scope.
+   * @param {string} prefix
+   * @param {string} uri
+   * @returns {boolean} false when the element already binds the prefix to
+   *   another URI
+   */
+  declare(prefix, uri) {
+    if (prefix === "xml") return uri === XML_NS;
+    const own = this.own?.get(prefix);
+    if (own !== undefined) return own === uri;
+    if (prefix !== "" && uri === "") return true;
+    if (!this.own) this.own = new Map();
+    this.own.set(prefix, uri);
+    if ((this.namespaces.get(prefix) ?? "") !== uri) {
+      if (!this.ownNamespaces) {
+        this.namespaces = new Map(this.namespaces);
+        this.ownNamespaces = true;
+      }
+      this.namespaces.set(prefix, uri);
+      const name = prefix === "" ? "xmlns" : `xmlns:${prefix}`;
+      this.parent.setAttributeNS(XMLNS_NS, name, uri);
+    }
+    return true;
+  }
+
+  /**
+   * Gives the element a namespace node that it must keep (copied by a
+   * literal result element or xsl:copy, or built by xsl:namespace): two
+   * such nodes for one prefix conflict (XTDE0430), rather than causing a
+   * namespace fixup.
+   * @param {string} prefix
+   * @param {string} uri
+   * @returns {boolean} as {@link NamespaceScope#declare}
+   */
+  declareExplicit(prefix, uri) {
+    const declared = this.declare(prefix, uri);
+    if (declared) this.explicit.add(prefix);
+    return declared;
+  }
+
+  /**
+   * A prefix bound to a URI on the element, declared when needed: one in
+   * scope, else `base_1`, `base_2`... (`ns0`, `ns1`... without base).
+   * @param {string} uri
+   * @param {string} base - Preferred prefix, "" for none
+   * @returns {string}
+   */
+  prefixFor(uri, base) {
+    for (const [prefix, bound] of this.namespaces) {
+      if (bound === uri && prefix !== "" && this.declare(prefix, uri)) {
+        return prefix;
+      }
+    }
+    for (let i = base ? 1 : 0; ; i++) {
+      const prefix = base ? `${base}_${i}` : `ns${i}`;
+      if (!this.namespaces.has(prefix) && this.declare(prefix, uri)) {
+        return prefix;
+      }
+    }
+  }
+}

package/src/xslt/runtime/numberFormat.js

@@ -0,0 +1,89 @@
+/**
+ * The format string of xsl:number (XSLT 3.0 section 12.4): alphanumeric
+ * format tokens separated by punctuation, with a prefix and a suffix,
+ * applied to a list of numbers.
+ *
+ * @module @tradik/xslt3/xslt/runtime/numberFormat
+ */
+
+import { formatToken } from "../../functions/format/formatInteger.js";
+import { numberLanguage } from "../../functions/format/numberLanguages.js";
+
+const ALPHANUMERIC = /[\p{L}\p{N}]/u;
+
+/**
+ * Splits a format string into a prefix, tokens with their separators,
+ * and a suffix.
+ * @param {string} format
+ * @returns {{prefix: string, tokens: string[], separators: string[], suffix: string}}
+ */
+export function parseFormat(format) {
+  const parts = [];
+  let current = "";
+  let alnum = null;
+  for (const c of format) {
+    const isAlnum = ALPHANUMERIC.test(c);
+    if (alnum !== null && isAlnum !== alnum) {
+      parts.push({ text: current, alnum });
+      current = "";
+    }
+    current += c;
+    alnum = isAlnum;
+  }
+  if (current) parts.push({ text: current, alnum });
+  let prefix = "";
+  let suffix = "";
+  if (parts[0] && !parts[0].alnum) prefix = parts.shift().text;
+  if (parts.length && !parts.at(-1).alnum) suffix = parts.pop().text;
+  const tokens = parts.filter((p) => p.alnum).map((p) => p.text);
+  const separators = parts.filter((p) => !p.alnum).map((p) => p.text);
+  if (tokens.length === 0) {
+    // no format token: "1", with the punctuation as prefix and suffix
+    return { prefix, tokens: ["1"], separators: [], suffix: prefix };
+  }
+  return { prefix, tokens, separators, suffix };
+}
+
+/**
+ * Inserts a grouping separator every `size` digits.
+ * @param {string} digits
+ * @param {string} separator
+ * @param {number} size
+ * @returns {string}
+ */
+function group(digits, separator, size) {
+  if (!separator || !(size > 0) || !/^\p{Nd}+$/u.test(digits)) return digits;
+  const chars = [...digits];
+  let result = "";
+  chars.forEach((c, i) => {
+    if (i > 0 && (chars.length - i) % size === 0) result += separator;
+    result += c;
+  });
+  return result;
+}
+
+/**
+ * Formats a list of numbers.
+ * @param {bigint[]} numbers
+ * @param {string} format
+ * @param {{ordinal: boolean|string, separator: string, size: number,
+ *   lang?: string|null}} options - ordinal: false, or the value of the
+ *   ordinal attribute
+ * @returns {string}
+ */
+export function formatNumbers(numbers, format, options) {
+  const { prefix, tokens, separators, suffix } = parseFormat(format);
+  const language = numberLanguage(options.lang);
+  let result = prefix;
+  numbers.forEach((n, i) => {
+    if (i > 0) {
+      result += separators[Math.min(i, separators.length) - 1] ?? ".";
+    }
+    const token = tokens[Math.min(i, tokens.length - 1)];
+    // a negative number (start-at below 1) gets a minus sign
+    const text = formatToken(n < 0n ? -n : n, token, options.ordinal, language);
+    result +=
+      (n < 0n ? "-" : "") + group(text, options.separator, options.size);
+  });
+  return result + suffix;
+}

package/src/xslt/runtime/numbering.js

@@ -0,0 +1,168 @@
+/**
+ * The place of a node in a document as xsl:number counts it (XSLT 3.0
+ * section 12.2): levels single, multiple and any, with count and from
+ * patterns.
+ *
+ * @module @tradik/xslt3/xslt/runtime/numbering
+ */
+
+import {
+  nodeLocalName,
+  nodeNamespace,
+  parentOf,
+} from "../../xpath/eval/domNodes.js";
+
+/**
+ * The default count pattern: nodes of the same kind and name.
+ * @param {Node} node
+ * @returns {(other: Node) => boolean}
+ */
+export function sameKindAndName(node) {
+  const type = node.nodeType === 4 ? 3 : node.nodeType;
+  const local = nodeLocalName(node);
+  const uri = nodeNamespace(node);
+  return (other) => {
+    const otherType = other.nodeType === 4 ? 3 : other.nodeType;
+    return (
+      otherType === type &&
+      nodeLocalName(other) === local &&
+      nodeNamespace(other) === uri
+    );
+  };
+}
+
+/**
+ * The key of the default count pattern of a node (see sameKindAndName):
+ * numbers memoized for one key are not valid for another.
+ * @param {Node} node
+ * @returns {string}
+ */
+export function countKey(node) {
+  const type = node.nodeType === 4 ? 3 : node.nodeType;
+  return `${type}|${nodeNamespace(node) ?? ""}|${nodeLocalName(node)}`;
+}
+
+/**
+ * The memo of an xsl:number instruction in a transformation: the numbers
+ * already given to nodes, so that numbering a long list stays linear.
+ * Only valid while counting depends on nothing but the tree: the caller
+ * does not memoize patterns that read variables.
+ * @param {object} tx - The transformation (holds the memos)
+ * @param {object} instruction - Identity of the instruction
+ * @param {string} key - The count pattern ("" for an explicit one, else
+ *   the {@link countKey} of the numbered node)
+ * @returns {WeakMap<Node, number>}
+ */
+export function numberMemo(tx, instruction, key) {
+  tx.numberMemos ??= new WeakMap();
+  let byKey = tx.numberMemos.get(instruction);
+  if (!byKey) tx.numberMemos.set(instruction, (byKey = new Map()));
+  let memo = byKey.get(key);
+  if (!memo) byKey.set(key, (memo = new WeakMap()));
+  return memo;
+}
+
+/**
+ * Number of preceding siblings that match, plus one; the walk stops at a
+ * sibling whose number is memoized (a counted node: its number includes
+ * itself and the counted siblings before it).
+ * @param {Node} node - A counted node
+ * @param {(node: Node) => boolean} count
+ * @param {WeakMap<Node, number>|null} memo
+ * @returns {number}
+ */
+function siblingNumber(node, count, memo) {
+  if (node.nodeType === 2 || node.nodeType === 13) return 1;
+  const own = memo?.get(node);
+  if (own !== undefined) return own;
+  let n = 1;
+  for (let s = node.previousSibling; s; s = s.previousSibling) {
+    const known = memo?.get(s);
+    if (known !== undefined) {
+      n += known;
+      break;
+    }
+    if (s.nodeType !== 10 && count(s)) n++;
+  }
+  memo?.set(node, n);
+  return n;
+}
+
+/**
+ * Ancestors-or-self of a node, innermost first, up to (including) the
+ * first one matching `from` (all of them when none matches).
+ * @param {Node} node
+ * @param {((node: Node) => boolean)|null} from
+ * @returns {Node[]}
+ */
+function ancestorsBelowFrom(node, from) {
+  const result = [];
+  for (let a = node; a; a = parentOf(a)) {
+    result.push(a);
+    if (from && from(a)) break;
+  }
+  return result;
+}
+
+/**
+ * level="single" and level="multiple".
+ * @param {Node} node
+ * @param {(node: Node) => boolean} count
+ * @param {((node: Node) => boolean)|null} from
+ * @param {boolean} multiple
+ * @param {WeakMap<Node, number>|null} [memo] - Sibling numbers already
+ *   computed with the same count pattern (see numberMemo)
+ * @returns {number[]}
+ */
+export function numberHierarchy(node, count, from, multiple, memo = null) {
+  const numbers = [];
+  for (const a of ancestorsBelowFrom(node, from)) {
+    if (!count(a)) continue;
+    numbers.unshift(siblingNumber(a, count, memo));
+    if (!multiple) break;
+  }
+  return numbers;
+}
+
+/**
+ * The node before another in document order (preceding or ancestor).
+ * @param {Node} node
+ * @returns {Node|null}
+ */
+function previousInDocument(node) {
+  if (node.nodeType === 2 || node.nodeType === 13) return parentOf(node);
+  const sibling = node.previousSibling;
+  if (!sibling) return parentOf(node);
+  let last = sibling;
+  while (last.lastChild) last = last.lastChild;
+  return last;
+}
+
+/**
+ * level="any": the counted nodes met walking back in document order from
+ * the node to a `from` node or the root. The walk from a node is the walk
+ * from any node it meets, so it stops at a node whose total is memoized:
+ * numbering in document order (for-each, apply-templates) only walks back
+ * to the node numbered before, and is linear instead of quadratic. In
+ * other orders nothing memoized is met and the walk is complete.
+ * @param {Node} node
+ * @param {(node: Node) => boolean} count
+ * @param {((node: Node) => boolean)|null} from
+ * @param {WeakMap<Node, number>|null} [memo] - Totals already computed
+ *   with the same count and from patterns (see numberMemo)
+ * @returns {number[]}
+ */
+export function numberAny(node, count, from, memo = null) {
+  let n = 0;
+  for (let p = node; p; p = previousInDocument(p)) {
+    const known = memo?.get(p);
+    if (known !== undefined) {
+      n += known;
+      break;
+    }
+    if (p.nodeType !== 10 && count(p)) n++;
+    if (from && from(p)) break;
+  }
+  memo?.set(node, n);
+  return n === 0 ? [] : [n];
+}

package/src/xslt/runtime/params.js

@@ -0,0 +1,59 @@
+/**
+ * Names and values given to the API: parameters by name, template and
+ * function names.
+ *
+ * @module @tradik/xslt3/xslt/runtime/params
+ */
+
+import { toSequence } from "../../xpath/eval/values.js";
+import { AtomicValue } from "../../xdm/atomic.js";
+import { types } from "../../xdm/types.js";
+
+/**
+ * The Clark name of a name given to the API: `local` (no namespace),
+ * `Q{uri}local` or `{uri}local`.
+ * @param {string} name
+ * @returns {string} `{uri}local`
+ */
+export function clarkName(name) {
+  if (name.startsWith("Q{")) return name.slice(1);
+  return name.startsWith("{") ? name : `{}${name}`;
+}
+
+/**
+ * An xs:untypedAtomic value, for parameters that should convert to the
+ * declared type of the parameter (as a string from a command line does)
+ * instead of being checked as an xs:string.
+ * @param {*} value - Converted to a string
+ * @returns {AtomicValue}
+ */
+export const untypedAtomic = (value) =>
+  new AtomicValue(types.untypedAtomic, String(value));
+
+/**
+ * A parameter value whose JavaScript strings become xs:untypedAtomic.
+ * @param {*} value
+ * @returns {*}
+ */
+const untypedStrings = (value) => {
+  if (typeof value === "string") return untypedAtomic(value);
+  return Array.isArray(value) ? value.map(untypedStrings) : value;
+};
+
+/**
+ * Normalizes parameters given by name to Clark names with XDM values
+ * (JavaScript values are converted, see xpath/eval/values.js).
+ * @param {object|Map|undefined} params
+ * @param {boolean} [asUntyped] - JavaScript strings are xs:untypedAtomic
+ * @returns {Map<string, Array>}
+ */
+export function normalizeParams(params, asUntyped = false) {
+  const result = new Map();
+  const entries =
+    params instanceof Map ? [...params] : Object.entries(params ?? {});
+  for (const [name, value] of entries) {
+    const converted = asUntyped ? untypedStrings(value) : value;
+    result.set(clarkName(name), toSequence(converted));
+  }
+  return result;
+}

package/src/xslt/runtime/properties.js

@@ -0,0 +1,103 @@
+/**
+ * What the processor reports about itself: system-property() values
+ * (XSLT 3.0 section 20.4.4) and the instructions element-available()
+ * knows.
+ *
+ * @module @tradik/xslt3/xslt/runtime/properties
+ */
+
+/** System properties in the XSLT namespace. */
+const PROPERTIES = {
+  version: "3.0",
+  vendor: "tradik",
+  "vendor-url": "https://xslt-processor.tradik.com/",
+  "product-name": "@tradik/xslt3",
+  "product-version": "0.0.0",
+  "is-schema-aware": "no",
+  "supports-serialization": "yes",
+  "supports-backwards-compatibility": "yes",
+  "supports-namespace-axis": "yes",
+  "supports-streaming": "no",
+  "supports-dynamic-evaluation": "yes",
+  "supports-higher-order-functions": "yes",
+  "xpath-version": "3.1",
+  "xsd-version": "1.1",
+};
+
+/**
+ * The value of a system property in the XSLT namespace.
+ * @param {string} local - Local name
+ * @returns {string} "" for an unknown property
+ */
+export const systemProperty = (local) => PROPERTIES[local] ?? "";
+
+/** @returns {string[]} the local names of the system properties */
+export const systemPropertyNames = () => Object.keys(PROPERTIES);
+
+/** Local names of the XSLT elements (instructions and declarations) implemented. */
+export const availableInstructions = new Set([
+  "attribute-set",
+  "character-map",
+  "decimal-format",
+  "function",
+  "import",
+  "include",
+  "key",
+  "mode",
+  "namespace-alias",
+  "output",
+  "param",
+  "preserve-space",
+  "strip-space",
+  "stylesheet",
+  "template",
+  "transform",
+  "analyze-string",
+  "apply-imports",
+  "apply-templates",
+  "attribute",
+  "call-template",
+  "choose",
+  "comment",
+  "copy",
+  "copy-of",
+  "document",
+  "element",
+  "fallback",
+  "for-each",
+  "for-each-group",
+  "if",
+  "message",
+  "namespace",
+  "next-match",
+  "number",
+  "perform-sort",
+  "processing-instruction",
+  "result-document",
+  "sequence",
+  "text",
+  "value-of",
+  "try",
+  "catch",
+  "map",
+  "map-entry",
+  "variable",
+  // XSLT 3.0 instructions of task 0031
+  "accumulator",
+  "accumulator-rule",
+  "assert",
+  "break",
+  "evaluate",
+  "fork",
+  "iterate",
+  "merge",
+  "merge-action",
+  "merge-key",
+  "merge-source",
+  "next-iteration",
+  "on-completion",
+  "on-empty",
+  "on-non-empty",
+  "source-document",
+  "where-populated",
+]);

package/src/xslt/runtime/rawResults.js

@@ -0,0 +1,82 @@
+/**
+ * Results of a transformation (XSLT 3.0 section 2.3.6, build-tree in
+ * Serialization 3.1 section 3): a result whose serialization parameters
+ * have build-tree "no" (the default of the json and adaptive methods) is
+ * the raw sequence the sequence constructor delivers, so that maps,
+ * arrays and atomic values reach the serializer as they are. Otherwise a
+ * result tree is built from it by sequence normalization: with an
+ * item-separator, the separator goes between all items.
+ *
+ * @module @tradik/xslt3/xslt/runtime/rawResults
+ */
+
+import { normalizeSequence } from "../../serialize/sequence.js";
+import { SequenceReceiver } from "./sequenceReceiver.js";
+import { TreeReceiver } from "./treeReceiver.js";
+
+/** Methods whose results are raw unless build-tree says otherwise. */
+const RAW_METHODS = new Set(["json", "adaptive"]);
+
+/**
+ * Whether a result with these serialization parameters is a tree.
+ * @param {object} [output] - Serialization parameters (spec names)
+ * @returns {boolean}
+ */
+export function buildsTree(output) {
+  const value = output?.["build-tree"];
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") return /^\s*(yes|true|1)\s*$/.test(value);
+  return !RAW_METHODS.has(output?.method);
+}
+
+/**
+ * A result tree from a raw sequence, normalized with an item separator.
+ * Nodes are copied, as the sequence may hold nodes of other trees.
+ * @param {Array} items
+ * @param {string} separator
+ * @param {DocumentFragment} fragment - Receives the tree
+ * @returns {DocumentFragment}
+ */
+function normalizedTree(items, separator, fragment) {
+  const document = fragment.ownerDocument;
+  for (const entry of normalizeSequence(items, separator)) {
+    fragment.appendChild(
+      typeof entry === "string"
+        ? document.createTextNode(entry)
+        : document.importNode(entry, true),
+    );
+  }
+  return fragment;
+}
+
+/**
+ * The receiver of a result: a tree under a new document fragment, or a
+ * sequence for a raw result.
+ * @param {object} output - Serialization parameters
+ * @param {() => Document} owner - Owner document of the result's nodes
+ * @param {boolean} [buildTree] - Overrides build-tree (the `buildTree`
+ *   option of the transformation)
+ * @returns {{receiver: object, value: () => (DocumentFragment|Array)}}
+ *   the receiver and, once the result is complete, the fragment or the
+ *   sequence
+ */
+export function resultReceiver(output, owner, buildTree) {
+  const separator = output?.["item-separator"];
+  const tree = buildTree ?? buildsTree(output);
+  if (!tree || separator !== undefined) {
+    const receiver = new SequenceReceiver(owner);
+    const value = tree
+      ? () =>
+          normalizedTree(
+            receiver.items,
+            separator,
+            owner().createDocumentFragment(),
+          )
+      : () => receiver.items;
+    return { receiver, value };
+  }
+  const fragment = owner().createDocumentFragment();
+  const receiver = new TreeReceiver(fragment, new Map());
+  receiver.resultTree = true;
+  return { receiver, value: () => fragment };
+}