@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/instructions/resultDocument.js

@@ -0,0 +1,143 @@
+/**
+ * xsl:result-document (XSLT 3.0 section 25.1): a new result tree, with
+ * the serialization parameters of an output definition overridden by
+ * the instruction's own attributes (attribute value templates); a raw
+ * sequence when build-tree is "no" (see runtime/rawResults.js).
+ *
+ * @module @tradik/xslt3/xslt/instructions/resultDocument
+ */
+
+import { resolveUri } from "../../xpath/eval/uris.js";
+import { compileBody } from "../compiler/body.js";
+import { infoOf } from "../compiler/elementInfo.js";
+import {
+  expandCharacterMaps,
+  readParameterDocument,
+} from "../compiler/outputDecl.js";
+import { derive } from "../runtime/context.js";
+import { resultReceiver } from "../runtime/rawResults.js";
+import { avtEvaluator } from "../runtime/values.js";
+import { attr, clarkOf, resolveQName, tokens, xsltError } from "../names.js";
+
+/** Serialization parameters given as attributes. */
+const PARAMETERS = [
+  "allow-duplicate-names",
+  "build-tree",
+  "byte-order-mark",
+  "doctype-public",
+  "doctype-system",
+  "encoding",
+  "escape-uri-attributes",
+  "html-version",
+  "include-content-type",
+  "indent",
+  "item-separator",
+  "json-node-output-method",
+  "media-type",
+  "method",
+  "normalization-form",
+  "omit-xml-declaration",
+  "standalone",
+  "undeclare-prefixes",
+  "output-version",
+];
+
+/** Parameters whose value is a list of element names. */
+const NAME_LISTS = ["cdata-section-elements", "suppress-indentation"];
+
+/**
+ * Compiles the serialization attributes.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {(xc: object) => object} the parameters they set
+ */
+function compileParameters(element, cx, scope) {
+  const namespaces = infoOf(element).namespaces;
+  const compiled = [...PARAMETERS, ...NAME_LISTS]
+    .filter((name) => attr(element, name) !== undefined)
+    .map((name) => [
+      name,
+      avtEvaluator(cx.exprs.avt(attr(element, name), element, scope.vars)),
+    ]);
+  const mapNames = tokens(attr(element, "use-character-maps")).map((token) =>
+    clarkOf(cx.exprs.qname(token, element)),
+  );
+  const characterMaps =
+    mapNames.length > 0
+      ? expandCharacterMaps(mapNames, cx.characterMaps)
+      : null;
+  const clark = (text, useDefault) =>
+    clarkOf(resolveQName(text, namespaces, { useDefault, code: "XTDE1460" }));
+  const documentText = attr(element, "parameter-document");
+  const document =
+    documentText === undefined
+      ? null
+      : avtEvaluator(cx.exprs.avt(documentText, element, scope.vars));
+  return (xc) => {
+    // the attributes override the parameter document
+    const params = document
+      ? readParameterDocument(document(xc), element, cx)
+      : {};
+    for (const [name, value] of compiled) {
+      const text = value(xc).trim();
+      if (NAME_LISTS.includes(name)) {
+        params[name] = tokens(text).map((token) => clark(token, true));
+      } else if (name === "method" && text.includes(":")) {
+        params[name] = clark(text, false);
+      } else params[name] = name === "item-separator" ? value(xc) : text;
+    }
+    if (characterMaps) params["use-character-maps"] = characterMaps;
+    return params;
+  };
+}
+
+/**
+ * xsl:result-document.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileResultDocument(element, cx, scope) {
+  const avt = (name) => {
+    const text = attr(element, name);
+    return text === undefined
+      ? null
+      : avtEvaluator(cx.exprs.avt(text, element, scope.vars));
+  };
+  const href = avt("href");
+  const format = avt("format");
+  const parameters = compileParameters(element, cx, scope);
+  const body = compileBody(element, cx, scope);
+  return (xc, out, machine) => {
+    const { tx } = xc;
+    if (xc.temporary) {
+      throw xsltError("XTDE1480", "xsl:result-document in a temporary tree");
+    }
+    const target = href ? href(xc) : "";
+    const uri = target === "" ? "" : resolveUri(target, tx.baseOutputUri);
+    if (tx.resultUris.has(uri)) {
+      throw xsltError(
+        "XTDE1490",
+        `Two results have the URI ${uri || "(principal)"}`,
+      );
+    }
+    tx.resultUris.add(uri);
+    // "#absent" (XSLT 3.0 section 26.1), here too: no item separator,
+    // overriding the one of the output definition
+    const output = cx.outputFor(
+      format ? format(xc) : null,
+      element,
+      parameters(xc),
+    );
+    const { receiver, value } = resultReceiver(
+      output,
+      tx.scratch,
+      tx.options.buildTree,
+    );
+    const context = derive(xc, { outputUri: uri || tx.baseOutputUri });
+    machine.runBody(body, context, receiver);
+    tx.addResult(uri, value(), output);
+  };
+}

package/src/xslt/instructions/sort.js

@@ -0,0 +1,114 @@
+/**
+ * Sorting (XSLT 3.0 section 13): xsl:sort keys of xsl:for-each,
+ * xsl:apply-templates, xsl:for-each-group and xsl:perform-sort.
+ *
+ * @module @tradik/xslt3/xslt/instructions/sort
+ */
+
+import { compileBody } from "../compiler/body.js";
+import { checkAttributes } from "../compiler/attributes.js";
+import { splitLeading } from "../compiler/children.js";
+import { infoOf } from "../compiler/elementInfo.js";
+import { withFocus } from "../runtime/context.js";
+import { compareValues, keyValue, settingsOf } from "../runtime/sortKeys.js";
+import { avtEvaluator } from "../runtime/values.js";
+import { attr, isXsl, xsltError } from "../names.js";
+
+/**
+ * Separates the leading xsl:sort children from the rest.
+ * @param {Node[]} children
+ * @returns {{sorts: Element[], rest: Node[]}}
+ */
+export function splitSorts(children) {
+  const { leading, rest } = splitLeading(children, "sort");
+  if (rest.some((child) => isXsl(child, "sort"))) {
+    throw xsltError("XTSE0010", "xsl:sort must come first");
+  }
+  return { sorts: leading, rest };
+}
+
+/**
+ * @param {Element} element
+ * @param {string} name
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {((xc: object) => string)|null}
+ */
+function optionalAvt(element, name, cx, scope) {
+  const text = attr(element, name);
+  return text === undefined
+    ? null
+    : avtEvaluator(cx.exprs.avt(text, element, scope.vars));
+}
+
+/**
+ * Compiles one xsl:sort.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {object} the compiled key
+ */
+export function compileSortKey(element, cx, scope) {
+  checkAttributes(element);
+  const select = attr(element, "select");
+  const children = cx.children(element);
+  if (select !== undefined && children.length > 0) {
+    throw xsltError("XTSE1015", "xsl:sort cannot have select and content");
+  }
+  const expr =
+    children.length > 0
+      ? null
+      : cx.exprs.xpath(select ?? ".", element, scope.vars);
+  return {
+    expr,
+    body: children.length > 0 ? compileBody(element, cx, scope) : null,
+    order: optionalAvt(element, "order", cx, scope),
+    dataType: optionalAvt(element, "data-type", cx, scope),
+    caseOrder: optionalAvt(element, "case-order", cx, scope),
+    lang: optionalAvt(element, "lang", cx, scope),
+    collation: optionalAvt(element, "collation", cx, scope),
+    compatible: infoOf(element).version < 2,
+  };
+}
+
+/**
+ * Compiles the xsl:sort elements of an instruction.
+ * @param {Element[]} elements
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {((items: Array, xc: object, machine: object) => Array) &
+ *   {order: Function}} sorts a sequence (the identity without sort keys);
+ *   `order(items, xc, machine, prepare)` gives the sorted indices, where
+ *   `prepare(focusContext, index)` adjusts the context of each key
+ */
+export function compileSorts(elements, cx, scope) {
+  if (
+    elements.slice(1).some((element) => attr(element, "stable") !== undefined)
+  ) {
+    throw xsltError("XTSE1017", "Only the first xsl:sort can have stable");
+  }
+  const keys = elements.map((element) => compileSortKey(element, cx, scope));
+  const order = (items, xc, machine, prepare) => {
+    const indices = items.map((_, i) => i);
+    if (keys.length === 0) return indices;
+    const settings = keys.map((key) => settingsOf(key, xc));
+    const size = items.length;
+    const rows = items.map((item, i) => {
+      let focus = withFocus(xc, item, i + 1, size);
+      if (prepare) focus = prepare(focus, i);
+      return keys.map((key, k) => keyValue(key, settings[k], focus, machine));
+    });
+    indices.sort((x, y) => {
+      for (let k = 0; k < keys.length; k++) {
+        const result = compareValues(rows[x][k], rows[y][k], settings[k], xc);
+        if (result !== 0) return settings[k].descending ? -result : result;
+      }
+      return 0;
+    });
+    return indices;
+  };
+  const sort = (items, xc, machine) =>
+    keys.length === 0 ? items : order(items, xc, machine).map((i) => items[i]);
+  sort.order = order;
+  return sort;
+}

package/src/xslt/instructions/sourceDocument.js

@@ -0,0 +1,73 @@
+/**
+ * xsl:source-document (XSLT 3.0 section 18.1): reads a document as
+ * doc() does and runs its content with the document node as the
+ * context item. This processor does not stream: streamable="yes" reads
+ * the whole document. The accumulators named by use-accumulators (none
+ * by default) apply to it.
+ *
+ * @module @tradik/xslt3/xslt/instructions/sourceDocument
+ */
+
+import { resolveUri } from "../../xpath/eval/uris.js";
+import { useAccumulators } from "../compiler/useAccumulators.js";
+import { required, yesNo } from "../compiler/attributes.js";
+import { compileBody } from "../compiler/body.js";
+import { setApplicable } from "../runtime/accumulators.js";
+import { derive, dynamicContextOf } from "../runtime/context.js";
+import { BodyFrame } from "../runtime/machine.js";
+import { avtEvaluator } from "../runtime/values.js";
+import { attr, xsltError } from "../names.js";
+
+/**
+ * Checks the validation and type attributes of an instruction of a
+ * processor that is not schema aware.
+ * @param {Element} element
+ * @throws {import("../../errors.js").XPathError} XTSE1660 for strict or
+ *   lax validation or a type, XTSE0020 for an invalid validation
+ */
+export function checkNoValidation(element) {
+  const validation = attr(element, "validation")?.trim();
+  if (
+    validation !== undefined &&
+    !["strict", "lax", "preserve", "strip"].includes(validation)
+  ) {
+    throw xsltError("XTSE0020", `Invalid validation "${validation}"`);
+  }
+  if (
+    validation === "strict" ||
+    validation === "lax" ||
+    attr(element, "type") !== undefined
+  ) {
+    throw xsltError("XTSE1660", "Schema validation needs schema awareness");
+  }
+}
+
+/**
+ * xsl:source-document.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileSourceDocument(element, cx, scope) {
+  yesNo(element, "streamable", false);
+  checkNoValidation(element);
+  const href = avtEvaluator(
+    cx.exprs.avt(required(element, "href"), element, scope.vars),
+  );
+  const accumulators = useAccumulators(
+    attr(element, "use-accumulators") ?? "",
+    element,
+    cx,
+  );
+  const base = cx.baseUriOf(element);
+  const body = compileBody(element, cx, scope);
+  return (xc, out, machine) => {
+    const uri = resolveUri(href(xc), base);
+    const document = dynamicContextOf(xc).loadDocument(uri);
+    setApplicable(xc.tx, document, accumulators);
+    if (body.length === 0) return;
+    const context = derive(xc, { item: document, position: 1, size: 1 });
+    machine.push(new BodyFrame(body, context, out));
+  };
+}

package/src/xslt/instructions/templates.js

@@ -0,0 +1,153 @@
+/**
+ * Template invocation instructions: xsl:apply-templates,
+ * xsl:call-template, xsl:apply-imports and xsl:next-match, with their
+ * xsl:with-param children (XSLT 3.0 sections 6 and 10.1).
+ *
+ * @module @tradik/xslt3/xslt/instructions/templates
+ */
+
+import { isNode } from "../../xdm/atomic.js";
+import { required } from "../compiler/attributes.js";
+import { derive, evaluate } from "../runtime/context.js";
+import {
+  applyBuiltIn,
+  applyTemplates,
+  invokeTemplate,
+} from "../runtime/apply.js";
+import {
+  attr,
+  clarkOf,
+  declaredName,
+  isXsl,
+  XSL_NS,
+  xsltError,
+} from "../names.js";
+import { compileSorts } from "./sort.js";
+import { compileWithParams } from "./params.js";
+
+/**
+ * Checks the children of an invocation instruction.
+ * @param {Element} element
+ * @param {Node[]} children
+ * @param {string[]} allowed - Local names allowed
+ */
+function checkChildren(element, children, allowed) {
+  for (const child of children) {
+    const ok =
+      child.nodeType === 1 &&
+      child.namespaceURI === element.namespaceURI &&
+      allowed.includes(child.localName);
+    if (!ok) {
+      throw xsltError(
+        "XTSE0010",
+        `xsl:${element.localName} may only contain ${allowed.join(", ")}`,
+      );
+    }
+  }
+}
+
+/**
+ * xsl:apply-templates.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileApplyTemplates(element, cx, scope) {
+  const children = cx.children(element);
+  checkChildren(element, children, ["sort", "with-param"]);
+  const selectText = attr(element, "select");
+  const select = cx.exprs.xpath(
+    selectText ?? "child::node()",
+    element,
+    scope.vars,
+  );
+  const mode = cx.modeRef(attr(element, "mode"), element);
+  const sort = compileSorts(
+    children.filter((child) => isXsl(child, "sort")),
+    cx,
+    scope,
+  );
+  const params = compileWithParams(children, cx, scope);
+  return (xc, out, machine) => {
+    if (selectText === undefined && !isNode(xc.item)) {
+      throw xsltError(
+        xc.item === undefined ? "XPDY0002" : "XTTE0510",
+        "xsl:apply-templates without select needs a context node",
+      );
+    }
+    // XSLT 3.0 applies templates to atomic values too (no XTTE0520)
+    const items = sort(evaluate(select, xc), xc, machine);
+    const target = mode.current ? xc.mode : cx.mode(mode.name);
+    applyTemplates(
+      items,
+      target,
+      xc,
+      out,
+      machine,
+      params.evaluate(xc, machine),
+    );
+  };
+}
+
+/**
+ * xsl:call-template.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileCallTemplate(element, cx, scope) {
+  const children = cx.children(element);
+  checkChildren(element, children, ["with-param"]);
+  const qname = cx.exprs.qname(required(element, "name"), element);
+  const key =
+    cx.originalName("template", clarkOf(qname)) ??
+    clarkOf(declaredName(qname, `{${XSL_NS}}initial-template`));
+  const params = compileWithParams(children, cx, scope);
+  cx.deferred.push(() => cx.checkCall(key, params, element));
+  return (xc, out, machine) => {
+    const template = cx.namedTemplates.get(key);
+    invokeTemplate(template, xc, out, machine, params.evaluate(xc, machine));
+  };
+}
+
+/**
+ * xsl:apply-imports and xsl:next-match.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileApplyImports(element, cx, scope) {
+  const children = cx.children(element);
+  const next = element.localName === "next-match";
+  // xsl:next-match may have xsl:fallback children (ignored: it exists)
+  checkChildren(
+    element,
+    children,
+    next ? ["with-param", "fallback"] : ["with-param"],
+  );
+  const params = compileWithParams(children, cx, scope);
+  return (xc, out, machine) => {
+    const current = xc.rule;
+    if (!current) {
+      throw xsltError(
+        "XTDE0560",
+        `xsl:${element.localName} needs a current template rule`,
+      );
+    }
+    const { template } = current;
+    const accept = next
+      ? (rule) => rule.rank > current.rank
+      : (rule) =>
+          rule.precedence < template.precedence &&
+          rule.precedence >= template.importLow;
+    const mode = xc.mode;
+    const args = params.evaluate(xc, machine);
+    const rule = mode.find(xc.item, xc, accept);
+    if (rule) {
+      invokeTemplate(rule.template, derive(xc, { rule }), out, machine, args);
+    } else applyBuiltIn(xc.item, xc, mode, out, machine, args);
+  };
+}

package/src/xslt/instructions/text.js

@@ -0,0 +1,151 @@
+/**
+ * Instructions that produce text and leaf nodes: xsl:value-of, xsl:text,
+ * xsl:sequence, xsl:comment, xsl:processing-instruction and xsl:namespace
+ * (XSLT 3.0 sections 11.4 to 11.7 and 11.9).
+ *
+ * @module @tradik/xslt3/xslt/instructions/text
+ */
+
+import { compileBody } from "../compiler/body.js";
+import { required } from "../compiler/attributes.js";
+import { evaluate } from "../runtime/context.js";
+import { avtEvaluator } from "../runtime/values.js";
+import { attr, isNCName, isXsl, xsltError } from "../names.js";
+import { compileSimpleContent } from "./elements.js";
+
+/**
+ * xsl:value-of.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileValueOf(element, cx, scope) {
+  // XSLT 3.0: neither select nor content makes a zero-length text node
+  const value = compileSimpleContent(element, cx, scope, "", "XTSE0870");
+  return (xc, out, machine) => out.text(value(xc, machine));
+}
+
+/**
+ * xsl:text.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileText(element, cx, scope) {
+  for (const child of cx.children(element)) {
+    if (child.nodeType === 1) {
+      throw xsltError("XTSE0010", "xsl:text cannot contain elements");
+    }
+  }
+  // an empty xsl:text makes a zero-length text node
+  return compileBody(element, cx, scope)[0] ?? ((xc, out) => out.text(""));
+}
+
+/**
+ * xsl:sequence.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileSequence(element, cx, scope) {
+  const select = attr(element, "select");
+  const children = cx.children(element);
+  const body = compileBody(
+    element,
+    cx,
+    scope,
+    children.filter((child) => !isXsl(child, "fallback")),
+  );
+  if (select === undefined) {
+    return (xc, out, machine) => machine.runBody(body, xc, out);
+  }
+  if (body.length > 0) {
+    throw xsltError("XTSE3185", "xsl:sequence cannot have select and content");
+  }
+  const expr = cx.exprs.xpath(select, element, scope.vars);
+  return (xc, out) => {
+    for (const item of evaluate(expr, xc)) out.item(item);
+  };
+}
+
+/**
+ * xsl:comment.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileComment(element, cx, scope) {
+  const value = compileSimpleContent(element, cx, scope, " ", "XTSE0940");
+  return (xc, out, machine) => {
+    let text = value(xc, machine).replace(/--/g, "- -");
+    text = text.replace(/--/g, "- -");
+    if (text.endsWith("-")) text += " ";
+    out.comment(text);
+  };
+}
+
+/**
+ * xsl:processing-instruction.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileProcessingInstruction(element, cx, scope) {
+  const name = avtEvaluator(
+    cx.exprs.avt(required(element, "name"), element, scope.vars),
+  );
+  const value = compileSimpleContent(element, cx, scope, " ", "XTSE0880");
+  return (xc, out, machine) => {
+    const target = name(xc).trim();
+    if (!isNCName(target) || target.toLowerCase() === "xml") {
+      throw xsltError(
+        "XTDE0890",
+        `Invalid processing instruction name ${target}`,
+      );
+    }
+    let data = value(xc, machine).replace(/^[ \t\r\n]+/, "");
+    data = data.replace(/\?>/g, "? >");
+    out.pi(target, data);
+  };
+}
+
+/**
+ * xsl:namespace.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileNamespace(element, cx, scope) {
+  const name = avtEvaluator(
+    cx.exprs.avt(required(element, "name"), element, scope.vars),
+  );
+  const value = compileSimpleContent(element, cx, scope, " ", "XTSE0910");
+  return (xc, out, machine) => {
+    const prefix = name(xc).trim();
+    if (prefix !== "" && !isNCName(prefix)) {
+      throw xsltError("XTDE0920", `Invalid namespace prefix ${prefix}`);
+    }
+    if (prefix === "xmlns") {
+      throw xsltError("XTDE0920", "The prefix xmlns cannot be bound");
+    }
+    const uri = value(xc, machine);
+    const xml = "http://www.w3.org/XML/1998/namespace";
+    if ((prefix === "xml") !== (uri === xml)) {
+      throw xsltError("XTDE0925", "The xml prefix and namespace go together");
+    }
+    if (uri === "http://www.w3.org/2000/xmlns/") {
+      throw xsltError("XTDE0905", "The xmlns namespace cannot be bound");
+    }
+    if (uri === "") {
+      throw xsltError("XTDE0930", "A namespace node cannot have an empty URI");
+    }
+    if (prefix === "xml") return;
+    out.namespace(prefix, uri);
+  };
+}