@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/instructions/try.js

@@ -0,0 +1,186 @@
+/**
+ * xsl:try and xsl:catch (XSLT 3.0 section 8.3): the result of the try
+ * body is built apart, and replaced by the result of the first matching
+ * xsl:catch when a dynamic error occurs; the catch body sees the error in
+ * the variables err:code, err:description, err:value...
+ *
+ * @module @tradik/xslt3/xslt/instructions/try
+ */
+
+import { AtomicValue } from "../../xdm/atomic.js";
+import { QNameValue } from "../../xdm/qname.js";
+import { types } from "../../xdm/types.js";
+import { compileBody } from "../compiler/body.js";
+import { checkAttributes } from "../compiler/attributes.js";
+import { infoOf } from "../compiler/elementInfo.js";
+import { derive, evaluate } from "../runtime/context.js";
+import { escapesTry, markOutside } from "../runtime/lazy.js";
+import { SequenceReceiver } from "../runtime/sequenceReceiver.js";
+import { attr, isXsl, tokens, xsltError } from "../names.js";
+
+/** Namespace of the error codes and of the err:* variables. */
+const ERR = "http://www.w3.org/2005/xqt-errors";
+
+/** The variables of a catch body, outermost first. */
+const ERROR_VARIABLES = [
+  "code",
+  "description",
+  "value",
+  "module",
+  "line-number",
+  "column-number",
+  "additional",
+];
+
+/**
+ * The expanded name of an error code (`LOCAL` in the err namespace, or
+ * `Q{uri}local`).
+ * @param {string} code
+ * @returns {{uri: string, local: string}}
+ */
+function codeName(code) {
+  const eq = /^Q\{([^}]*)\}(.*)$/.exec(code);
+  return eq ? { uri: eq[1], local: eq[2] } : { uri: ERR, local: code };
+}
+
+/**
+ * Compiles the name tests of an errors attribute.
+ * @param {Element} element - xsl:catch
+ * @returns {(name: {uri: string, local: string}) => boolean}
+ */
+function errorTests(element) {
+  const namespaces = infoOf(element).namespaces;
+  const tests = tokens(attr(element, "errors") ?? "*").map((token) => {
+    if (token === "*") return () => true;
+    if (token.startsWith("*:")) return (n) => n.local === token.slice(2);
+    const eq = /^Q\{([^}]*)\}(.*)$/.exec(token);
+    const [uri, local] = eq
+      ? [eq[1], eq[2]]
+      : token.includes(":")
+        ? [namespaces.get(token.split(":")[0]) ?? "", token.split(":")[1]]
+        : ["", token];
+    return (n) => n.uri === uri && (local === "*" || n.local === local);
+  });
+  return (name) => tests.some((test) => test(name));
+}
+
+/**
+ * An optional atomic value.
+ * @param {object} type
+ * @param {string|number|undefined} value - Absent when undefined
+ * @returns {Array}
+ */
+const optional = (type, value) =>
+  value === undefined
+    ? []
+    : [new AtomicValue(type, type === types.integer ? BigInt(value) : value)];
+
+/**
+ * The values of the err:* variables for an error.
+ * @param {Error} error
+ * @returns {Array[]} in the order of ERROR_VARIABLES
+ */
+function errorValues(error) {
+  const { uri, local } = codeName(error.code);
+  const description = (error.plainMessage ?? error.message).replace(
+    /^[^ ]+: /,
+    "",
+  );
+  return [
+    [new AtomicValue(types.QName, new QNameValue(uri, local, "err"))],
+    [new AtomicValue(types.string, description)],
+    error.errorObject ?? error.value ?? [],
+    // where the error was raised (see runtime/locations.js)
+    optional(types.string, error.location?.module),
+    optional(types.integer, error.location?.line),
+    optional(types.integer, error.location?.column),
+    [],
+  ].map((value) => (Array.isArray(value) ? value : [value]));
+}
+
+/**
+ * Compiles the body or select of xsl:try / xsl:catch.
+ * @returns {(xc: object, machine: object) => Array}
+ */
+function compileContent(element, children, cx, scope, conflictCode) {
+  const select = attr(element, "select");
+  if (select !== undefined && children.length > 0) {
+    throw xsltError(
+      conflictCode,
+      `xsl:${element.localName} has select and content`,
+    );
+  }
+  if (select !== undefined) {
+    const expr = cx.exprs.xpath(select, element, scope.vars);
+    return (xc) => evaluate(expr, xc);
+  }
+  const body = compileBody(element, cx, scope, children);
+  return (xc, machine) => {
+    const out = new SequenceReceiver(xc.tx.scratch);
+    machine.runBody(body, xc, out);
+    return out.items;
+  };
+}
+
+/**
+ * xsl:try.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileTry(element, cx, scope) {
+  const children = cx.children(element).filter((c) => !isXsl(c, "fallback"));
+  const first = children.findIndex((child) => isXsl(child, "catch"));
+  if (first < 0) throw xsltError("XTSE0010", "xsl:try needs an xsl:catch");
+  const catchElements = children.slice(first);
+  if (!catchElements.every((child) => isXsl(child, "catch"))) {
+    throw xsltError("XTSE0010", "xsl:catch must come last in xsl:try");
+  }
+  const content = compileContent(
+    element,
+    children.slice(0, first),
+    cx,
+    scope,
+    "XTSE3140",
+  );
+  let catchScope = scope;
+  for (const name of ERROR_VARIABLES) {
+    catchScope = {
+      ...catchScope,
+      vars: { key: `{${ERR}}${name}`, next: catchScope.vars },
+    };
+  }
+  const catches = catchElements.map((catchElement) => {
+    checkAttributes(catchElement);
+    return {
+      matches: errorTests(catchElement),
+      content: compileContent(
+        catchElement,
+        cx.children(catchElement),
+        cx,
+        catchScope,
+        "XTSE3150",
+      ),
+    };
+  });
+  return (xc, out, machine) => {
+    let items;
+    const marker = {};
+    markOutside(xc.env, xc.tx.globalEnv, marker);
+    try {
+      items = content(xc, machine);
+    } catch (error) {
+      // errors of variables declared outside are not caught (XSLT 3.0 8.3)
+      if (typeof error?.code !== "string" || escapesTry(error, marker)) {
+        throw error;
+      }
+      const handler = catches.find((c) => c.matches(codeName(error.code)));
+      if (!handler) throw error;
+      let env = xc.env;
+      for (const value of errorValues(error)) env = { value, next: env };
+      items = handler.content(derive(xc, { env }), machine);
+    }
+    for (const item of items) out.item(item);
+  };
+}

package/src/xslt/instructions/variables.js

@@ -0,0 +1,119 @@
+/**
+ * Values of variables and parameters (XSLT 3.0 section 9.3): the select
+ * expression, or the content as a temporary tree (as a sequence when
+ * there is an `as` attribute), converted to the declared type.
+ *
+ * @module @tradik/xslt3/xslt/instructions/variables
+ */
+
+import { setBaseUri } from "../../functions/baseUris.js";
+import { stringItem } from "../../xpath/eval/atomics.js";
+import { coerce } from "../../xpath/eval/coercion.js";
+import { compileBody } from "../compiler/body.js";
+import { required } from "../compiler/attributes.js";
+import { infoOf } from "../compiler/elementInfo.js";
+import { derive, evaluate } from "../runtime/context.js";
+import { LazyEntry } from "../runtime/lazy.js";
+import { bodySequence, temporaryTree } from "../runtime/values.js";
+import { attr, clarkOf, declaredName, isXsl, xsltError } from "../names.js";
+
+/**
+ * A converter to a declared sequence type, raising a given error code
+ * when the value does not match.
+ * @param {object|null} type - Compiled sequence type, null for none
+ * @param {string} code - Error code for a type mismatch
+ * @param {string} what - Description for messages
+ * @param {boolean} [compatible] - XPath 1.0 compatibility
+ * @returns {(value: Array) => Array}
+ */
+export function typeConverter(type, code, what, compatible = false) {
+  if (!type) return (value) => value;
+  return (value) => {
+    try {
+      return coerce(value, type, { what, compatible });
+    } catch (error) {
+      if (error.code === "XPTY0004" || error.code === "FORG0001") {
+        throw xsltError(code, error.message.replace(/^[A-Z]{4}\d{4}: /, ""));
+      }
+      throw error;
+    }
+  };
+}
+
+/**
+ * Compiles the value of a variable, parameter or with-param.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope - Scope of the select expression and content
+ * @param {string} code - Error code of a type mismatch
+ * @returns {{value: (xc: object, machine: object) => Array, type: object|null,
+ *   hasDefault: boolean}}
+ */
+export function compileValue(element, cx, scope, code) {
+  const select = attr(element, "select");
+  const asText = attr(element, "as");
+  const type =
+    asText === undefined ? null : cx.exprs.sequenceType(asText, element);
+  const children = cx
+    .children(element)
+    .filter((child) => !isXsl(child, "fallback"));
+  if (select !== undefined && children.length > 0) {
+    throw xsltError(
+      "XTSE0620",
+      `xsl:${element.localName} cannot have both select and content`,
+    );
+  }
+  const name = attr(element, "name") ?? "";
+  const convert = typeConverter(
+    type,
+    code,
+    `value of $${name}`,
+    infoOf(element).version < 2,
+  );
+  const hasDefault = select !== undefined || children.length > 0;
+  if (select !== undefined) {
+    const expr = cx.exprs.xpath(select, element, scope.vars);
+    return { value: (xc) => convert(evaluate(expr, xc)), type, hasDefault };
+  }
+  if (children.length > 0) {
+    const body = compileBody(element, cx, scope, children);
+    const base = infoOf(element).baseUri;
+    const value = type
+      ? (xc, machine) => convert(bodySequence(body, xc, machine))
+      : (xc, machine) => [setBaseUri(temporaryTree(body, xc, machine), base)];
+    return { value, type, hasDefault };
+  }
+  const empty = type ? [] : [stringItem("")];
+  return { value: () => convert(empty), type, hasDefault };
+}
+
+/**
+ * The Clark name of a variable or parameter.
+ * @param {Element} element
+ * @param {object} cx
+ * @returns {string}
+ */
+export const variableName = (element, cx) =>
+  clarkOf(declaredName(cx.exprs.qname(required(element, "name"), element)));
+
+/**
+ * Compiles a local xsl:variable.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {{step: {binding: Function}, scope: object}} the binding step and
+ *   the scope of the following siblings
+ */
+export function compileLocalVariable(element, cx, scope) {
+  const key = variableName(element, cx);
+  const { value } = compileValue(element, cx, scope, "XTTE0570");
+  return {
+    step: {
+      binding: (xc, machine) =>
+        derive(xc, {
+          env: new LazyEntry(xc.env, () => value(xc, machine), key),
+        }),
+    },
+    scope: { ...scope, vars: { key, next: scope.vars } },
+  };
+}

package/src/xslt/names.js

@@ -0,0 +1,204 @@
+/**
+ * Names shared by the XSLT compiler and runtime: namespace URIs, the
+ * errors of the XSLT specification, attribute access and the resolution
+ * of the QNames written in stylesheet attributes.
+ *
+ * @module @tradik/xslt3/xslt/names
+ */
+
+import { XPathError } from "../errors.js";
+
+/** The XSLT namespace. */
+export const XSL_NS = "http://www.w3.org/1999/XSL/Transform";
+/** Namespace of namespace declarations. */
+export const XMLNS_NS = "http://www.w3.org/2000/xmlns/";
+/** The namespace bound to the xml prefix. */
+export const XML_NS = "http://www.w3.org/XML/1998/namespace";
+
+// combining marks (U+0300-036F) are in \p{M}
+const NCNAME = /^[\p{L}_][\p{L}\p{N}\p{M}_.\-·‿⁀]*$/u;
+
+/**
+ * @param {string} text
+ * @returns {boolean} whether the text is an NCName
+ */
+export const isNCName = (text) => NCNAME.test(text);
+
+/**
+ * @param {string} text
+ * @returns {boolean} whether the text is a lexical QName
+ */
+export function isQName(text) {
+  const colon = text.indexOf(":");
+  if (colon < 0) return isNCName(text);
+  return isNCName(text.slice(0, colon)) && isNCName(text.slice(colon + 1));
+}
+
+/**
+ * An error of the XSLT specification.
+ * @param {string} code - Error code, e.g. "XTSE0010"
+ * @param {string} message
+ * @returns {XPathError}
+ */
+export const xsltError = (code, message) => new XPathError(code, message);
+
+/**
+ * @param {Node} node
+ * @param {string} [local] - Local name required
+ * @returns {boolean} whether the node is an element of the XSLT namespace
+ */
+export const isXsl = (node, local) =>
+  node.nodeType === 1 &&
+  node.namespaceURI === XSL_NS &&
+  (local === undefined || node.localName === local);
+
+/** @type {WeakMap<Element, Map<string, string>>} shadow attribute values */
+const shadows = new WeakMap();
+
+/**
+ * Records the values of the shadow attributes of an element (XSLT 3.0
+ * section 3.13.2): they replace the attributes of the same name.
+ * @param {Element} element
+ * @param {Map<string, string>} values - By attribute name
+ */
+export function setShadowAttributes(element, values) {
+  shadows.set(element, values);
+}
+
+/**
+ * Value of an attribute without namespace (or of its shadow attribute).
+ * @param {Element} element
+ * @param {string} name
+ * @returns {string|undefined} undefined when absent
+ */
+export function attr(element, name) {
+  const shadow = shadows.get(element)?.get(name);
+  if (shadow !== undefined) return shadow;
+  const node = element.getAttributeNode(name);
+  return node && !node.namespaceURI ? node.value : undefined;
+}
+
+/**
+ * Value of an attribute in the XSLT namespace (standard attributes of
+ * literal result elements, such as xsl:version).
+ * @param {Element} element
+ * @param {string} local
+ * @returns {string|undefined}
+ */
+export function xslAttr(element, local) {
+  return element.hasAttributeNS(XSL_NS, local)
+    ? element.getAttributeNS(XSL_NS, local)
+    : undefined;
+}
+
+/**
+ * A standard attribute: unprefixed on XSLT elements, in the XSLT
+ * namespace on other elements.
+ * @param {Element} element
+ * @param {string} local
+ * @returns {string|undefined}
+ */
+export const standardAttr = (element, local) =>
+  element.namespaceURI === XSL_NS
+    ? attr(element, local)
+    : xslAttr(element, local);
+
+/**
+ * @typedef {object} ExpandedName
+ * @property {string} uri - Namespace URI, "" for none
+ * @property {string} local - Local part
+ * @property {string} prefix - Prefix as written, "" for none
+ */
+
+/**
+ * Resolves a QName or EQName written in a stylesheet.
+ * @param {string} text
+ * @param {Map<string, string>} namespaces - In-scope namespaces
+ * @param {object} [options]
+ * @param {boolean} [options.useDefault] - Unprefixed names take the
+ *   default namespace
+ * @param {string} [options.code] - Error code of an undeclared prefix
+ *   (default XTSE0280), and of an invalid name when `syntaxCode` is absent
+ * @param {string} [options.syntaxCode] - Error code of an invalid name
+ *   (default XTSE0020 with the default `code`)
+ * @returns {ExpandedName}
+ * @throws {XPathError} for an invalid name or undeclared prefix
+ */
+export function resolveQName(text, namespaces, options = {}) {
+  const { useDefault = false, code = "XTSE0280" } = options;
+  const syntaxCode =
+    options.syntaxCode ?? (options.code === undefined ? "XTSE0020" : code);
+  const name = text.trim();
+  const eq = /^Q\{([^{}]*)\}(.*)$/s.exec(name);
+  if (eq) {
+    if (!isNCName(eq[2])) throw xsltError(syntaxCode, `Invalid name ${name}`);
+    return { uri: eq[1], local: eq[2], prefix: "" };
+  }
+  if (!isQName(name)) throw xsltError(syntaxCode, `Invalid QName "${name}"`);
+  const colon = name.indexOf(":");
+  if (colon < 0) {
+    const uri = useDefault ? (namespaces.get("") ?? "") : "";
+    return { uri, local: name, prefix: "" };
+  }
+  const prefix = name.slice(0, colon);
+  const uri = namespaces.get(prefix);
+  if (uri === undefined || uri === "") {
+    throw xsltError(code, `The prefix ${prefix} is not declared`);
+  }
+  return { uri, local: name.slice(colon + 1), prefix };
+}
+
+/** Namespaces in which stylesheets cannot declare names (XTSE0080). */
+export const RESERVED_NAMESPACES = new Set([
+  XSL_NS,
+  "http://www.w3.org/2005/xpath-functions",
+  "http://www.w3.org/2005/xpath-functions/math",
+  "http://www.w3.org/2005/xpath-functions/map",
+  "http://www.w3.org/2005/xpath-functions/array",
+  "http://www.w3.org/2001/XMLSchema",
+  "http://www.w3.org/2001/XMLSchema-instance",
+  XML_NS,
+]);
+
+/**
+ * Checks that a declared name is not in a reserved namespace.
+ * @param {ExpandedName} name
+ * @param {string} [allowed] - Clark name allowed anyway
+ *   (`{XSL}initial-template` for templates)
+ * @returns {ExpandedName} the name
+ * @throws {XPathError} XTSE0080
+ */
+export function declaredName(name, allowed) {
+  if (RESERVED_NAMESPACES.has(name.uri) && clarkOf(name) !== allowed) {
+    throw xsltError("XTSE0080", `The namespace ${name.uri} is reserved`);
+  }
+  return name;
+}
+
+/**
+ * @param {{uri: string, local: string}} name
+ * @returns {string} Clark notation `{uri}local`
+ */
+export const clarkOf = (name) => `{${name.uri}}${name.local}`;
+
+/**
+ * A Clark name as messages show it: `local` without namespace, else the
+ * EQName `Q{uri}local`.
+ * @param {string} clark - `{uri}local` (other names are kept)
+ * @returns {string}
+ */
+export function displayName(clark) {
+  if (clark.startsWith("{}")) return clark.slice(2);
+  return clark.startsWith("{") ? `Q${clark}` : clark;
+}
+
+/**
+ * Splits a whitespace-separated list.
+ * @param {string|undefined} text
+ * @returns {string[]}
+ */
+export const tokens = (text) => (text ?? "").split(/\s+/).filter(Boolean);
+
+/** The name xsl:original, by which an overriding component reaches the
+ * overridden one (XSLT 3.0 section 3.5.3.4), in Clark notation. */
+export const ORIGINAL = `{${XSL_NS}}original`;

package/src/xslt/patterns/axisOrigins.js

@@ -0,0 +1,121 @@
+/**
+ * The origins of an axis step in a pattern (see general.js): the nodes
+ * from which the step selects a node, found through the inverse of its
+ * axis, with the child-or-top, attribute-or-top and namespace-or-top
+ * adjustments of the first step of a relative pattern (XSLT 3.0 section
+ * 5.5.3).
+ *
+ * @module @tradik/xslt3/xslt/patterns/axisOrigins
+ */
+
+import { parentOf } from "../../xpath/eval/domNodes.js";
+import { compileNode } from "../../xpath/eval/compiler.js";
+import { compileNodeTest } from "../../xpath/eval/nodeTests.js";
+import { compilePredicate } from "../../xpath/eval/predicates.js";
+
+/** Node kinds the child-or-top axis selects when they have no parent. */
+const TOP_KINDS = new Set([1, 3, 4, 7, 8]);
+
+/**
+ * The ancestors of a node, nearest first.
+ * @param {Node} node
+ * @returns {Node[]}
+ */
+function ancestors(node) {
+  const result = [];
+  for (let a = parentOf(node); a; a = parentOf(a)) result.push(a);
+  return result;
+}
+
+/**
+ * The nodes from which an axis can reach a node.
+ * @param {string} axis
+ * @param {Node} node
+ * @returns {Node[]}
+ */
+function inverseAxis(axis, node) {
+  switch (axis) {
+    case "self":
+      return [node];
+    case "descendant":
+      return ancestors(node);
+    case "descendant-or-self":
+      return [node, ...ancestors(node)];
+    default: {
+      const parent = parentOf(node);
+      return parent ? [parent] : [];
+    }
+  }
+}
+
+/**
+ * Whether a step selects nodes as child-or-top / attribute-or-top /
+ * namespace-or-top does for a parentless node (the first step of a
+ * relative pattern).
+ * @param {object} step - AxisStep
+ * @param {Node} node
+ * @returns {boolean}
+ */
+function selectsTop(step, node) {
+  if (parentOf(node)) return false;
+  if (step.axis === "child") return TOP_KINDS.has(node.nodeType);
+  return step.axis === "attribute" || step.axis === "namespace";
+}
+
+/**
+ * Compiles predicates applied to a node alone (position 1 of 1).
+ * @param {object[]} predicates
+ * @param {object} env
+ * @returns {(node: Node, xc: object) => Node[]} [node] when it passes
+ */
+export function filterAlone(predicates, env) {
+  const scope = { sc: env.sc, vars: env.vars };
+  const compiled = predicates.map((p) =>
+    compilePredicate(p, scope, compileNode),
+  );
+  return (node, xc) => {
+    const ctx = env.cx.patternContext(node, xc, env.local);
+    let items = [node];
+    for (const predicate of compiled) items = predicate(items, ctx);
+    return items;
+  };
+}
+
+/**
+ * Compiles an axis step: `origins(node, xc)` returns the context nodes
+ * from which the step selects the node.
+ * @param {object} step - AxisStep
+ * @param {object} env - See compile.js
+ * @param {boolean} first - First step of a relative pattern
+ * @param {(ctx: object) => Array} run - The step compiled as an expression
+ * @returns {{origins: (node: Node, xc: object) => Node[]}}
+ */
+export function compileAxisOrigins(step, env, first, run) {
+  // document-node() without an axis matches document nodes (self axis)
+  const documentStep =
+    first &&
+    step.axis === "child" &&
+    step.nodeTest.type === "DocumentTest" &&
+    !env.text.startsWith("child::", step.start);
+  const axis = documentStep ? "self" : step.axis;
+  const effective = documentStep ? { ...step, axis } : step;
+  const evaluate = documentStep
+    ? env.cx.exprs.compileAst(effective, env.sc, env.vars)
+    : run;
+  const nodeTest = compileNodeTest(step.nodeTest, axis, env.sc);
+  const simple = step.predicates.length === 0;
+  const alone = filterAlone(step.predicates, env);
+  return {
+    origins(node, xc) {
+      if (first && !documentStep && selectsTop(step, node)) {
+        // the predicates see the node alone (position 1 of 1)
+        return nodeTest(node) ? alone(node, xc) : [];
+      }
+      const candidates = inverseAxis(axis, node);
+      if (simple) return nodeTest(node) ? candidates : [];
+      return candidates.filter((c) =>
+        evaluate(env.cx.patternContext(c, xc, env.local)).includes(node),
+      );
+    },
+  };
+}