@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/instructions/control.js

@@ -0,0 +1,123 @@
+/**
+ * Conditional and repetition instructions: xsl:if, xsl:choose,
+ * xsl:for-each (XSLT 3.0 sections 8 and 7.1).
+ *
+ * @module @tradik/xslt3/xslt/instructions/control
+ */
+
+import { effectiveBooleanValue } from "../../xdm/nodes.js";
+import { compileBody } from "../compiler/body.js";
+import { checkAttributes, required } from "../compiler/attributes.js";
+import { derive, evaluate } from "../runtime/context.js";
+import { BodyFrame, LoopFrame } from "../runtime/machine.js";
+import { isXsl, xsltError } from "../names.js";
+import { compileSorts, splitSorts } from "./sort.js";
+
+/**
+ * xsl:if.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileIf(element, cx, scope) {
+  const test = cx.exprs.xpath(required(element, "test"), element, scope.vars);
+  const body = compileBody(element, cx, scope);
+  return (xc, out, machine) => {
+    if (effectiveBooleanValue(evaluate(test, xc)) && body.length > 0) {
+      machine.push(new BodyFrame(body, xc, out));
+    }
+  };
+}
+
+/**
+ * xsl:choose.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileChoose(element, cx, scope) {
+  const branches = [];
+  let otherwise = null;
+  for (const child of cx.children(element)) {
+    const misplaced =
+      child.nodeType !== 1 ||
+      otherwise !== null ||
+      !(isXsl(child, "when") || isXsl(child, "otherwise"));
+    if (misplaced) {
+      throw xsltError(
+        "XTSE0010",
+        "xsl:choose may only contain xsl:when then xsl:otherwise",
+      );
+    }
+    checkAttributes(child);
+    if (isXsl(child, "when")) {
+      branches.push({
+        test: cx.exprs.xpath(required(child, "test"), child, scope.vars),
+        body: compileBody(child, cx, scope),
+      });
+    } else otherwise = compileBody(child, cx, scope);
+  }
+  if (branches.length === 0) {
+    throw xsltError("XTSE0010", "xsl:choose needs at least one xsl:when");
+  }
+  return (xc, out, machine) => {
+    let body = otherwise;
+    for (const branch of branches) {
+      if (effectiveBooleanValue(evaluate(branch.test, xc))) {
+        body = branch.body;
+        break;
+      }
+    }
+    if (body && body.length > 0) machine.push(new BodyFrame(body, xc, out));
+  };
+}
+
+/**
+ * Runs a body once per item, with that item as the focus.
+ * @param {Array} items
+ * @param {import("../runtime/machine.js").Body} body
+ * @param {object} xc - Context of the instruction
+ * @param {object} out
+ * @param {import("../runtime/machine.js").Machine} machine
+ * @param {object} [changes] - Further changes to the context
+ */
+export function forEachItem(items, body, xc, out, machine, changes = {}) {
+  if (items.length === 0 || body.length === 0) return;
+  const size = items.length;
+  const base = derive(xc, { rule: null, ...changes });
+  machine.push(
+    new LoopFrame(size, (i) =>
+      machine.push(
+        new BodyFrame(
+          body,
+          derive(base, { item: items[i], position: i + 1, size }),
+          out,
+        ),
+      ),
+    ),
+  );
+}
+
+/**
+ * xsl:for-each.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileForEach(element, cx, scope) {
+  const select = cx.exprs.xpath(
+    required(element, "select"),
+    element,
+    scope.vars,
+  );
+  const { sorts, rest } = splitSorts(cx.children(element));
+  const sort = compileSorts(sorts, cx, scope);
+  const body = compileBody(element, cx, scope, rest);
+  return (xc, out, machine) => {
+    const items = sort(evaluate(select, xc), xc, machine);
+    forEachItem(items, body, xc, out, machine);
+  };
+}

package/src/xslt/instructions/copy.js

@@ -0,0 +1,151 @@
+/**
+ * Copying and new documents: xsl:copy, xsl:copy-of, xsl:document and
+ * xsl:perform-sort (XSLT 3.0 sections 11.8, 11.9.1 and 13.2).
+ *
+ * @module @tradik/xslt3/xslt/instructions/copy
+ */
+
+import { isAtomic, isNode } from "../../xdm/atomic.js";
+import { compileBody } from "../compiler/body.js";
+import { required, yesNo } from "../compiler/attributes.js";
+import { derive, evaluate, withFocus } from "../runtime/context.js";
+import { setOrigin } from "../runtime/accumulators.js";
+import { markCopied, markDocumentCopied } from "../runtime/baseUri.js";
+import { copyLeaf, copyNamespaceNodes } from "../runtime/copy.js";
+import { BodyFrame } from "../runtime/machine.js";
+import { bodySequence } from "../runtime/values.js";
+import { attr, isXsl, xsltError } from "../names.js";
+import { applyAttributeSets, attributeSetNames } from "./attributeSets.js";
+import { compileSorts, splitSorts } from "./sort.js";
+
+/**
+ * xsl:copy.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileCopy(element, cx, scope) {
+  const selectText = attr(element, "select");
+  const select =
+    selectText === undefined
+      ? null
+      : cx.exprs.xpath(selectText, element, scope.vars);
+  const copyNamespaces = yesNo(element, "copy-namespaces", true);
+  const sets = attributeSetNames(
+    attr(element, "use-attribute-sets"),
+    element,
+    cx,
+  );
+  const body = compileBody(element, cx, scope);
+  return (xc, out, machine) => {
+    let context = xc;
+    if (select) {
+      const items = evaluate(select, xc);
+      if (items.length === 0) return;
+      if (items.length > 1) {
+        throw xsltError("XTTE3180", "xsl:copy select gives several items");
+      }
+      // a new focus: no current template rule (XTDE0560 for next-match)
+      context = derive(withFocus(xc, items[0], 1, 1), { rule: null });
+    }
+    const item = context.item;
+    if (item === undefined) {
+      throw xsltError("XTTE0945", "xsl:copy needs a context item");
+    }
+    let content;
+    if (isAtomic(item) || !isNode(item)) {
+      out.item(item);
+      return;
+    }
+    if (item.nodeType === 1) {
+      content = out.element(item.namespaceURI ?? "", item.nodeName);
+      markCopied(item, content.parent, false);
+      if (copyNamespaces) copyNamespaceNodes(item, content);
+    } else if (item.nodeType === 9 || item.nodeType === 11) {
+      content = out.document();
+      markDocumentCopied(item, content);
+    } else {
+      copyLeaf(item, out);
+      return;
+    }
+    if (sets.length > 0) {
+      applyAttributeSets(sets, context, content, machine, cx);
+    }
+    if (body.length > 0) machine.push(new BodyFrame(body, context, content));
+  };
+}
+
+/**
+ * xsl:copy-of.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileCopyOf(element, cx, scope) {
+  if (cx.children(element).some((child) => !isXsl(child, "fallback"))) {
+    throw xsltError("XTSE0260", "xsl:copy-of must be empty");
+  }
+  const select = cx.exprs.xpath(
+    required(element, "select"),
+    element,
+    scope.vars,
+  );
+  const copyNamespaces = yesNo(element, "copy-namespaces", true);
+  const copyAccumulators = yesNo(element, "copy-accumulators", false);
+  return (xc, out) => {
+    for (const item of evaluate(select, xc)) {
+      if (isNode(item)) {
+        out.copy(item, copyNamespaces);
+        // a parentless copy keeps the accumulator values of the original
+        if (copyAccumulators && out.items) {
+          setOrigin(xc.tx, out.items.at(-1), item);
+        }
+      } else out.item(item);
+    }
+  };
+}
+
+/**
+ * xsl:document.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileDocument(element, cx, scope) {
+  const body = compileBody(element, cx, scope);
+  return (xc, out, machine) => {
+    const content = out.document();
+    if (body.length > 0) machine.push(new BodyFrame(body, xc, content));
+  };
+}
+
+/**
+ * xsl:perform-sort.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compilePerformSort(element, cx, scope) {
+  const { sorts, rest } = splitSorts(cx.children(element));
+  const content = rest.filter((child) => !isXsl(child, "fallback"));
+  const selectText = attr(element, "select");
+  if (selectText !== undefined && content.length > 0) {
+    throw xsltError("XTSE1040", "xsl:perform-sort has select and content");
+  }
+  const sort = compileSorts(sorts, cx, scope);
+  const select =
+    selectText === undefined
+      ? null
+      : cx.exprs.xpath(selectText, element, scope.vars);
+  const body = compileBody(element, cx, scope, content);
+  return (xc, out, machine) => {
+    const items = select
+      ? evaluate(select, xc)
+      : bodySequence(body, xc, machine, false);
+    for (const item of sort(items, xc, machine)) out.item(item);
+  };
+}

package/src/xslt/instructions/elements.js

@@ -0,0 +1,161 @@
+/**
+ * xsl:element and xsl:attribute (XSLT 3.0 sections 11.2 and 11.3):
+ * nodes with computed names.
+ *
+ * @module @tradik/xslt3/xslt/instructions/elements
+ */
+
+import { compileBody } from "../compiler/body.js";
+import { required } from "../compiler/attributes.js";
+import { infoOf } from "../compiler/elementInfo.js";
+import { evaluate } from "../runtime/context.js";
+import { markConstructed } from "../runtime/baseUri.js";
+import { BodyFrame } from "../runtime/machine.js";
+import {
+  avtEvaluator,
+  bodySequence,
+  simpleContent,
+} from "../runtime/values.js";
+import { attr, isQName, XML_NS, XMLNS_NS, xsltError } from "../names.js";
+import { applyAttributeSets, attributeSetNames } from "./attributeSets.js";
+
+/**
+ * Compiles the computed name of an element or attribute.
+ * @param {Element} element - The instruction
+ * @param {object} cx
+ * @param {object} scope
+ * @param {object} codes - Error codes: `name` (invalid QName), `prefix`
+ *   (undeclared prefix), `namespace` (reserved namespace)
+ * @param {boolean} useDefault - Unprefixed names take the default namespace
+ * @returns {(xc: object) => {uri: string, qname: string, prefix: string, local: string}}
+ */
+function compileName(element, cx, scope, codes, useDefault) {
+  const name = avtEvaluator(
+    cx.exprs.avt(required(element, "name"), element, scope.vars),
+  );
+  const nsText = attr(element, "namespace");
+  const namespace =
+    nsText === undefined
+      ? null
+      : avtEvaluator(cx.exprs.avt(nsText, element, scope.vars));
+  const namespaces = infoOf(element).namespaces;
+  return (xc) => {
+    const qname = name(xc).trim();
+    if (!isQName(qname)) {
+      throw xsltError(codes.name, `Invalid name "${qname}"`);
+    }
+    const colon = qname.indexOf(":");
+    const prefix = colon < 0 ? "" : qname.slice(0, colon);
+    const local = qname.slice(colon + 1);
+    let uri;
+    if (namespace) uri = namespace(xc);
+    else if (prefix === "xml") uri = XML_NS;
+    else if (prefix) {
+      uri = namespaces.get(prefix);
+      if (!uri) throw xsltError(codes.prefix, `Undeclared prefix ${prefix}`);
+    } else uri = useDefault ? (namespaces.get("") ?? "") : "";
+    if (uri === XMLNS_NS || (uri !== XML_NS && prefix === "xml")) {
+      throw xsltError(codes.namespace, `The namespace ${uri} is reserved`);
+    }
+    if (uri === "") return { uri, qname: local, prefix: "", local };
+    return { uri, qname, prefix, local };
+  };
+}
+
+/**
+ * xsl:element.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileElement(element, cx, scope) {
+  const name = compileName(
+    element,
+    cx,
+    scope,
+    { name: "XTDE0820", prefix: "XTDE0830", namespace: "XTDE0835" },
+    true,
+  );
+  const sets = attributeSetNames(
+    attr(element, "use-attribute-sets"),
+    element,
+    cx,
+  );
+  const body = compileBody(element, cx, scope);
+  const base = infoOf(element).baseUri;
+  return (xc, out, machine) => {
+    const { uri, qname } = name(xc);
+    const content = out.element(uri, qname);
+    markConstructed(content, base);
+    if (sets.length > 0) applyAttributeSets(sets, xc, content, machine, cx);
+    if (body.length > 0) machine.push(new BodyFrame(body, xc, content));
+  };
+}
+
+/**
+ * The value of an instruction with simple content: its select
+ * expression or its content, joined with a separator.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @param {string} contentSeparator - Default separator for content
+ * @param {string} conflictCode - Error code for select and content
+ * @returns {(xc: object, machine: object) => string}
+ */
+export function compileSimpleContent(
+  element,
+  cx,
+  scope,
+  contentSeparator,
+  conflictCode,
+) {
+  const select = attr(element, "select");
+  const body = compileBody(element, cx, scope);
+  if (select !== undefined && body.length > 0) {
+    throw xsltError(
+      conflictCode,
+      `xsl:${element.localName} cannot have both select and content`,
+    );
+  }
+  const separatorText = attr(element, "separator");
+  const separator =
+    separatorText === undefined
+      ? () => (select === undefined ? contentSeparator : " ")
+      : avtEvaluator(cx.exprs.avt(separatorText, element, scope.vars));
+  if (select === undefined) {
+    return (xc, machine) =>
+      simpleContent(bodySequence(body, xc, machine, false), separator(xc));
+  }
+  const expr = cx.exprs.xpath(select, element, scope.vars);
+  if (infoOf(element).version < 2 && separatorText === undefined) {
+    return (xc) => simpleContent(evaluate(expr, xc).slice(0, 1), "");
+  }
+  return (xc) => simpleContent(evaluate(expr, xc), separator(xc));
+}
+
+/**
+ * xsl:attribute.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileAttribute(element, cx, scope) {
+  const name = compileName(
+    element,
+    cx,
+    scope,
+    { name: "XTDE0850", prefix: "XTDE0860", namespace: "XTDE0865" },
+    false,
+  );
+  const value = compileSimpleContent(element, cx, scope, "", "XTSE0840");
+  return (xc, out, machine) => {
+    const { uri, qname, prefix, local } = name(xc);
+    if (qname === "xmlns" || (uri === "" && local === "xmlns")) {
+      throw xsltError("XTDE0855", "An attribute cannot be named xmlns");
+    }
+    const actual = prefix === "xmlns" ? local : qname;
+    out.attribute(uri, actual, value(xc, machine));
+  };
+}

package/src/xslt/instructions/evaluate.js

@@ -0,0 +1,189 @@
+/**
+ * xsl:evaluate (XSLT 3.0 section 10.4): compiles the string of the xpath
+ * attribute and evaluates it with the parameters of the xsl:with-param
+ * children and of the with-params map, and the context item of the
+ * context-item attribute. The transform() option `dynamicEvaluation:
+ * false` disables it: then the xsl:fallback children run, or XTDE3175 is
+ * raised.
+ *
+ * @module @tradik/xslt3/xslt/instructions/evaluate
+ */
+
+import { isMap, isNode } from "../../xdm/atomic.js";
+import { types } from "../../xdm/types.js";
+import { resolveUri } from "../../xpath/eval/uris.js";
+import { compileFallback } from "../compiler/body.js";
+import { required } from "../compiler/attributes.js";
+import { infoOf } from "../compiler/elementInfo.js";
+import { derive, dynamicContextOf, evaluate } from "../runtime/context.js";
+import { compileTarget, nodeNamespaces } from "../runtime/dynamicXPath.js";
+import { avtEvaluator } from "../runtime/values.js";
+import { attr, isXsl, xsltError } from "../names.js";
+import { compileWithParams } from "./params.js";
+import { typeConverter } from "./variables.js";
+
+/**
+ * The variables given by the with-params map.
+ * @param {Array} value
+ * @returns {Map<string, Array>} values by Clark name
+ * @throws {import("../../errors.js").XPathError} XTTE3165
+ */
+function mapParams(value) {
+  const map = value[0];
+  if (value.length !== 1 || !isMap(map)) {
+    throw xsltError("XTTE3165", "with-params must be a single map");
+  }
+  const params = new Map();
+  for (const { key, value: item } of map.entries.values()) {
+    if (key.type !== types.QName) {
+      throw xsltError("XTTE3165", "The keys of with-params must be QNames");
+    }
+    params.set(`{${key.value.namespaceURI}}${key.value.localName}`, item);
+  }
+  return params;
+}
+
+/**
+ * The values of the xsl:with-param children; a value that does not
+ * match its declared type is a type error of the target (XPTY0004).
+ * @param {object} params - Compiled xsl:with-param children
+ * @param {object} xc
+ * @param {object} machine
+ * @returns {Map<string, Array>}
+ */
+function withParamValues(params, xc, machine) {
+  try {
+    return params.evaluate(xc, machine).params;
+  } catch (error) {
+    if (error.code !== "XTTE0570") throw error;
+    throw xsltError("XPTY0004", error.message.replace(/^[A-Z]+\d+: /, ""));
+  }
+}
+
+/**
+ * The boolean value of schema-aware.
+ * @param {string} text
+ * @returns {boolean}
+ * @throws {import("../../errors.js").XPathError} XTDE0030 for another value
+ */
+function schemaAware(text) {
+  const value = text.trim();
+  if (["yes", "true", "1"].includes(value)) return true;
+  if (["no", "false", "0"].includes(value)) return false;
+  throw xsltError("XTDE0030", `Invalid schema-aware value "${text}"`);
+}
+
+/**
+ * xsl:evaluate.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileEvaluate(element, cx, scope) {
+  const children = cx.children(element);
+  if (!children.every((c) => isXsl(c, "with-param") || isXsl(c, "fallback"))) {
+    throw xsltError("XTSE0010", "xsl:evaluate contains xsl:with-param");
+  }
+  const xpath = (name) => {
+    const text = attr(element, name);
+    return text === undefined
+      ? null
+      : cx.exprs.xpath(text, element, scope.vars);
+  };
+  const target = cx.exprs.xpath(
+    required(element, "xpath"),
+    element,
+    scope.vars,
+  );
+  const toString = typeConverter(
+    cx.exprs.sequenceType("xs:string", element),
+    "XPTY0004",
+    "xpath attribute of xsl:evaluate",
+  );
+  const contextItem = xpath("context-item");
+  const withParamsMap = xpath("with-params");
+  const namespaceContext = xpath("namespace-context");
+  const avt = (name) => {
+    const text = attr(element, name);
+    return text === undefined
+      ? null
+      : avtEvaluator(cx.exprs.avt(text, element, scope.vars));
+  };
+  const baseUri = avt("base-uri");
+  const schema = avt("schema-aware");
+  const asText = attr(element, "as");
+  const convert = typeConverter(
+    asText === undefined ? null : cx.exprs.sequenceType(asText, element),
+    "XPTY0004",
+    "result of xsl:evaluate",
+  );
+  const params = compileWithParams(children, cx, scope);
+  const fallback = children.some((c) => isXsl(c, "fallback"))
+    ? compileFallback(element, cx, scope)
+    : null;
+  const info = infoOf(element);
+  const staticPart = {
+    namespaces: new Map([...info.namespaces].filter(([p]) => p !== "")),
+    defaultElementNamespace: info.xpathDefaultNs,
+    baseUri: info.baseUri,
+    library: cx.exprs.library,
+    decimalFormats: cx.exprs.decimalFormats,
+  };
+  const cache = new Map();
+  return (xc, out, machine) => {
+    if (!xc.tx.dynamicEvaluation) {
+      if (fallback) return fallback(xc, out, machine);
+      throw xsltError("XTDE3175", "xsl:evaluate is disabled");
+    }
+    const text = toString(evaluate(target, xc))[0].value;
+    if (schema) schemaAware(schema(xc));
+    const values = withParamValues(params, xc, machine);
+    if (withParamsMap) {
+      for (const [key, value] of mapParams(evaluate(withParamsMap, xc))) {
+        values.set(key, value);
+      }
+    }
+    const context = { ...staticPart };
+    if (namespaceContext) {
+      const nodes = evaluate(namespaceContext, xc);
+      if (nodes.length !== 1 || !isNode(nodes[0])) {
+        throw xsltError("XTTE3170", "namespace-context must be a single node");
+      }
+      Object.assign(context, nodeNamespaces(nodes[0]));
+    }
+    if (baseUri) context.baseUri = resolveUri(baseUri(xc), info.baseUri);
+    const keys = [...values.keys()];
+    const cacheKey = `${text}\u0000${keys.join(" ")}`;
+    let run = namespaceContext || baseUri ? null : cache.get(cacheKey);
+    if (!run) {
+      run = compileTarget(text, context, keys);
+      if (!namespaceContext && !baseUri) cache.set(cacheKey, run);
+    }
+    const focus = contextItem ? evaluate(contextItem, xc) : [];
+    if (focus.length > 1) {
+      throw xsltError("XTTE3210", "context-item must be at most one item");
+    }
+    let env = null;
+    for (const key of keys) env = { value: values.get(key), next: env };
+    const targetXc = derive(xc, {
+      group: undefined,
+      groupKey: undefined,
+      regex: undefined,
+      merge: undefined,
+    });
+    const dyn = dynamicContextOf(targetXc);
+    dyn.sc = run.sc;
+    dyn.staticBaseUri = run.sc.baseUri;
+    dyn.decimalFormats = run.sc.decimalFormats;
+    if (info.defaultCollation) dyn.defaultCollation = info.defaultCollation;
+    const result = run({
+      item: focus[0],
+      position: focus.length,
+      size: focus.length,
+      env,
+      dyn,
+    });
+    for (const item of convert(result)) out.item(item);
+  };
+}

package/src/xslt/instructions/fork.js

@@ -0,0 +1,35 @@
+/**
+ * xsl:fork (XSLT 3.0 section 16.1): its xsl:sequence or
+ * xsl:for-each-group children run one after the other (this processor
+ * does not stream, so there is nothing to fork) and their results are
+ * concatenated.
+ *
+ * @module @tradik/xslt3/xslt/instructions/fork
+ */
+
+import { compileBody } from "../compiler/body.js";
+import { isXsl, xsltError } from "../names.js";
+
+/**
+ * xsl:fork.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileFork(element, cx, scope) {
+  const children = cx.children(element);
+  const branches = children.filter((c) => !isXsl(c, "fallback"));
+  const groups = branches.filter((c) => isXsl(c, "for-each-group")).length;
+  const valid =
+    branches.every((c) => isXsl(c, "sequence") || isXsl(c, "for-each-group")) &&
+    (groups === 0 || branches.length === 1);
+  if (!valid) {
+    throw xsltError(
+      "XTSE0010",
+      "xsl:fork contains xsl:sequence elements or one xsl:for-each-group",
+    );
+  }
+  const body = compileBody(element, cx, scope, branches);
+  return (xc, out, machine) => machine.runBody(body, xc, out);
+}