@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/compiler/stylesheet.js

@@ -0,0 +1,205 @@
+/**
+ * The stylesheet compiler: loads the modules, collects the declarations
+ * by kind and compiles them in dependency order (namespace aliases,
+ * decimal formats and function signatures before any expression; global
+ * names before any body), then runs the checks that need everything
+ * (called templates, attribute sets).
+ *
+ * @module @tradik/xslt3/xslt/compiler/stylesheet
+ */
+
+import { defaultFunctionLibrary } from "../../xpath/index.js";
+import { xsltFunctions } from "../runtime/functions.js";
+import { declareAttributeSet } from "../instructions/attributeSets.js";
+import { declareAccumulators } from "./accumulatorDecl.js";
+import { declareGlobalContextItem } from "./globalContextItem.js";
+import { infoOf } from "./elementInfo.js";
+import { ExpressionCompiler } from "./expressions.js";
+import {
+  collectGlobals,
+  compileFunction,
+  functionSignature,
+  winners,
+} from "./globals.js";
+import { collectDeclarations } from "./declarationKinds.js";
+import { loadModuleTree } from "./modules.js";
+import { collectDecimalFormats } from "./decimalFormats.js";
+import {
+  checkCharacterMaps,
+  collectCharacterMaps,
+  collectOutputs,
+} from "./outputDecl.js";
+import { collectAliases, compileSpaceRules, declareKey } from "./miscDecl.js";
+import { checkModeDeclarations, declareMode } from "./modeDecl.js";
+import {
+  compileSlots,
+  importAccepted,
+  layoutGlobals,
+  markAbstract,
+} from "./linker.js";
+import { linkOverrides } from "./overrideLinks.js";
+import { buildTable, packageHeader } from "./packageTable.js";
+import { usePackage } from "./packages.js";
+import { checkDeclaredModes, checkExecutable } from "./packageChecks.js";
+import { PackageRegistry } from "./packageRegistry.js";
+import { declareSimplified, declareTemplate } from "./templatesDecl.js";
+
+/** Compiles a stylesheet; it is also the `cx` handed to every compiler. */
+export class StylesheetCompiler extends PackageRegistry {
+  /**
+   * @param {Element} element
+   * @returns {number} the effective version of an element
+   */
+  versionOf(element) {
+    return infoOf(element).version;
+  }
+
+  /**
+   * @param {Element} element
+   * @returns {string|undefined} its base URI
+   */
+  baseUriOf(element) {
+    return infoOf(element).baseUri;
+  }
+
+  /**
+   * The declarations of a module tree by kind, checked.
+   * @param {object} tree - See modules.js
+   * @returns {(kind: string) => object[]} the declarations of a kind
+   */
+  collectDeclarations(tree) {
+    return collectDeclarations(tree, this);
+  }
+
+  /**
+   * Compiles the declarations that every expression depends on: function
+   * signatures, decimal formats, global variable names.
+   * @param {(kind: string) => object[]} all
+   * @returns {{signatures: Map, globals: Map, definitions: Map}}
+   */
+  compileContext(all) {
+    this.aliases = collectAliases(all("namespace-alias"));
+    const signatures = winners(
+      all("function").map((d) => ({
+        ...d,
+        signature: functionSignature(d, this),
+      })),
+      (d) => d.signature.key,
+      "XTSE0770",
+    );
+    const definitions = new Map(
+      [...signatures.values()].map((d) => [
+        d.signature.key,
+        this.functionDefinition(d.signature),
+      ]),
+    );
+    const accepted = this.uses.flatMap((use) =>
+      use.accepted
+        .filter(({ component }) => component.kind === "function")
+        .map(({ component }) => component.definition),
+    );
+    this.exprs = new ExpressionCompiler({
+      library: defaultFunctionLibrary.extend(xsltFunctions, accepted, [
+        ...definitions.values(),
+      ]),
+      decimalFormats: collectDecimalFormats(all("decimal-format"), this),
+      owner: this,
+    });
+    const globals = collectGlobals([...all("variable"), ...all("param")], this);
+    return { signatures, globals, definitions };
+  }
+
+  /**
+   * A compiler for a package used by this one.
+   * @param {string[]} chain - Names of the packages being compiled
+   * @returns {StylesheetCompiler}
+   */
+  usedPackage(chain) {
+    return new StylesheetCompiler({
+      ...this.options,
+      staticParams: new Map(),
+      packageChain: chain,
+    });
+  }
+
+  /**
+   * The first stage: modules loaded, used packages prepared, names and
+   * visibilities of the components known.
+   * @param {Document|Element} source
+   * @param {string|undefined} uri
+   */
+  prepare(source, uri) {
+    const tree = loadModuleTree(source, uri, this);
+    this.tree = tree;
+    this.header = packageHeader(tree.root);
+    this.packageName = this.header.name;
+    this.packageVersion = this.header.version;
+    const all = this.collectDeclarations(tree);
+    this.all = all;
+    this.exprs = new ExpressionCompiler({ library: defaultFunctionLibrary });
+    this.uses = all("use-package").map((d) =>
+      usePackage({ ...d, imported: d.precedence !== tree.precedence }, this),
+    );
+    this.level = Math.max(-1, ...this.uses.map((use) => use.child.level)) + 1;
+    this.context = this.compileContext(all);
+    buildTable(this, all, this.context);
+  }
+
+  /** The second stage: every declaration compiled and linked. */
+  finish() {
+    for (const use of this.uses) use.child.finish();
+    const { all, tree } = this;
+    const { signatures } = this.context;
+    importAccepted(this);
+    this.outputs = collectOutputs(all("output"), this);
+    this.characterMaps = collectCharacterMaps(all("character-map"), this);
+    checkCharacterMaps(this.outputs, this.characterMaps);
+    this.spaceRules = compileSpaceRules(
+      [...all("strip-space"), ...all("preserve-space")],
+      this,
+    );
+    for (const declaration of all("mode")) declareMode(declaration, this);
+    checkModeDeclarations(this.modes.values());
+    this.globals = compileSlots(this);
+    declareAccumulators(all, this);
+    declareGlobalContextItem(all("global-context-item"), this);
+    for (const { element } of all("attribute-set")) {
+      declareAttributeSet(element, this);
+    }
+    for (const declaration of all("key")) declareKey(declaration, this);
+    for (const declaration of all("template")) {
+      declareTemplate(declaration, this);
+    }
+    for (const declaration of all("simplified")) {
+      declareSimplified(declaration, this);
+    }
+    for (const { signature } of signatures.values()) {
+      Object.assign(
+        this.functionBodies.get(signature.key),
+        compileFunction(signature, this),
+      );
+    }
+    markAbstract(this);
+    linkOverrides(this, this.level);
+    for (const check of this.deferred) check();
+    checkDeclaredModes(this);
+    this.finishModes();
+    this.sc = this.exprs.staticContext(tree.root);
+    this.defaultModeName = infoOf(tree.root).defaultMode;
+  }
+
+  /**
+   * Compiles the stylesheet (the top-level package and the packages it
+   * uses).
+   * @param {Document|Element} source
+   * @param {string|undefined} uri
+   * @returns {StylesheetCompiler} this, with everything compiled
+   */
+  compile(source, uri) {
+    this.prepare(source, uri);
+    checkExecutable(this);
+    layoutGlobals(this);
+    this.finish();
+    return this;
+  }
+}

package/src/xslt/compiler/tailPosition.js

@@ -0,0 +1,74 @@
+/**
+ * Tail positions (XSLT 3.0 section 7.2): xsl:break and
+ * xsl:next-iteration must be the last instruction of the body of the
+ * innermost xsl:iterate, or of an xsl:if, xsl:when, xsl:otherwise,
+ * xsl:try or xsl:catch that is itself in a tail position (XTSE3120).
+ *
+ * @module @tradik/xslt3/xslt/compiler/tailPosition
+ */
+
+import { isXsl, xsltError } from "../names.js";
+
+/** Containers through which a tail position extends, to the element in tail position. */
+const CONTAINERS = {
+  if: (parent) => parent,
+  when: (parent) => parent.parentNode,
+  otherwise: (parent) => parent.parentNode,
+  try: (parent) => parent,
+  catch: (parent) => parent.parentNode,
+};
+
+/**
+ * Whether a child is the last instruction of its parent, ignoring
+ * xsl:fallback (and the xsl:catch children of xsl:try).
+ * @param {object} child
+ * @param {Element} parent
+ * @param {object} cx - Stylesheet compiler (`children`)
+ * @returns {boolean}
+ */
+function isLast(child, parent, cx) {
+  const children = cx.children(parent);
+  const index = children.indexOf(child);
+  return children
+    .slice(index + 1)
+    .every(
+      (next) =>
+        isXsl(next, "fallback") ||
+        (isXsl(parent, "try") && isXsl(next, "catch")),
+    );
+}
+
+/**
+ * Checks that an xsl:break or xsl:next-iteration is in a tail position
+ * of an xsl:iterate body.
+ * @param {Element} element
+ * @param {object} cx
+ * @throws {import("../../errors.js").XPathError} XTSE0010 outside
+ *   xsl:iterate, XTSE3120 elsewhere than in a tail position
+ */
+export function checkTailPosition(element, cx) {
+  let ancestor = element.parentNode;
+  while (ancestor?.nodeType === 1 && !isXsl(ancestor, "iterate")) {
+    ancestor = ancestor.parentNode;
+  }
+  if (ancestor?.nodeType !== 1) {
+    throw xsltError(
+      "XTSE0010",
+      `xsl:${element.localName} is only allowed within xsl:iterate`,
+    );
+  }
+  let node = element;
+  for (;;) {
+    const parent = node.parentNode;
+    const container = parent?.nodeType === 1 && isXsl(parent) && parent;
+    if (!container || !isLast(node, parent, cx)) break;
+    if (isXsl(parent, "iterate")) return;
+    const up = CONTAINERS[parent.localName];
+    if (!up) break;
+    node = up(parent);
+  }
+  throw xsltError(
+    "XTSE3120",
+    `xsl:${element.localName} must be in a tail position of xsl:iterate`,
+  );
+}

package/src/xslt/compiler/templatesDecl.js

@@ -0,0 +1,180 @@
+/**
+ * xsl:template declarations (XSLT 3.0 section 6.1): named templates and
+ * template rules, registered in their modes.
+ *
+ * @module @tradik/xslt3/xslt/compiler/templatesDecl
+ */
+
+import { compileParams } from "../instructions/params.js";
+import { typeConverter } from "../instructions/variables.js";
+import {
+  attr,
+  declaredName,
+  isXsl,
+  tokens,
+  XSL_NS,
+  xsltError,
+} from "../names.js";
+import { compilePattern } from "../patterns/compile.js";
+import { splitContextItem } from "./contextItem.js";
+import { compileBody } from "./body.js";
+import { splitLeading } from "./children.js";
+import { infoOf } from "./elementInfo.js";
+
+/**
+ * Separates the leading xsl:param children of a template or function.
+ * @param {Array<object>} children
+ * @returns {{params: Element[], rest: Array<object>}}
+ */
+export function splitParams(children) {
+  const { leading, rest } = splitLeading(children, "param");
+  if (rest.some((child) => isXsl(child, "param"))) {
+    throw xsltError("XTSE0010", "xsl:param must come first");
+  }
+  return { params: leading, rest };
+}
+
+/**
+ * The priority attribute of a template.
+ * @param {string|undefined} text
+ * @returns {number|null}
+ */
+function parsePriority(text) {
+  if (text === undefined) return null;
+  const value = text.trim();
+  if (!/^[+-]?(\d+(\.\d*)?|\.\d+)$/.test(value)) {
+    throw xsltError("XTSE0530", `Invalid priority "${text}"`);
+  }
+  return Number(value);
+}
+
+/**
+ * The modes of a template rule.
+ * @param {Element} element
+ * @param {object} cx
+ * @returns {string[]} Clark names, "#all" for all modes
+ */
+export function modesOf(element, cx) {
+  const text = attr(element, "mode");
+  if (text === undefined) return [infoOf(element).defaultMode];
+  const names = tokens(text).map((token) => {
+    if (token === "#all") return "#all";
+    if (token === "#default") return infoOf(element).defaultMode;
+    if (token === "#unnamed") return "";
+    const name = cx.exprs.qname(token, element, { syntaxCode: "XTSE0550" });
+    return `{${name.uri}}${name.local}`;
+  });
+  if (names.length === 0 || new Set(names).size !== names.length) {
+    throw xsltError("XTSE0550", "Invalid mode attribute");
+  }
+  if (names.includes("#all") && names.length > 1) {
+    throw xsltError("XTSE0550", "#all must be alone");
+  }
+  return names;
+}
+
+/**
+ * The alternatives of a union pattern as one.
+ * @param {object[]} alternatives
+ * @returns {object} an alternative matching when any of them does
+ */
+function unionAlternative(alternatives) {
+  const keys = new Set(alternatives.map((alternative) => alternative.key));
+  return {
+    matches: (item, xc) => alternatives.some((a) => a.matches(item, xc)),
+    priority: 0.5,
+    key: keys.size === 1 ? alternatives[0].key : "*",
+  };
+}
+
+/**
+ * Compiles an xsl:template and registers it.
+ * @param {object} declaration - `{element, precedence, importLow}`
+ * @param {object} cx - Stylesheet compiler
+ */
+export function declareTemplate(declaration, cx) {
+  const { element, precedence, importLow } = declaration;
+  const match = attr(element, "match");
+  const nameText = attr(element, "name");
+  if (match === undefined) {
+    if (nameText === undefined) {
+      throw xsltError("XTSE0500", "xsl:template needs match or name");
+    }
+    if (
+      attr(element, "mode") !== undefined ||
+      attr(element, "priority") !== undefined
+    ) {
+      throw xsltError("XTSE0500", "mode and priority need a match pattern");
+    }
+  }
+  const contextItem = splitContextItem(cx.children(element), element, cx);
+  const { params: paramElements, rest } = splitParams(contextItem.rest);
+  const { params, scope } = compileParams(paramElements, cx, cx.globalScope());
+  const asText = attr(element, "as");
+  const template = {
+    params,
+    body: [...contextItem.steps, ...compileBody(element, cx, scope, rest)],
+    convert: asText
+      ? typeConverter(
+          cx.exprs.sequenceType(asText, element),
+          "XTTE0505",
+          "result of the template",
+        )
+      : null,
+    precedence,
+    importLow,
+    element,
+  };
+  if (nameText !== undefined) {
+    const name = declaredName(
+      cx.exprs.qname(nameText, element),
+      `{${XSL_NS}}initial-template`,
+    );
+    cx.addNamedTemplate(`{${name.uri}}${name.local}`, template);
+  }
+  if (match === undefined) return;
+  const pattern = compilePattern(match, element, cx);
+  const explicit = parsePriority(attr(element, "priority"));
+  // with a priority, a union pattern is one rule, not one per alternative
+  const alternatives =
+    explicit === null || pattern.alternatives.length === 1
+      ? pattern.alternatives
+      : [unionAlternative(pattern.alternatives)];
+  for (const mode of modesOf(element, cx)) {
+    for (const alternative of alternatives) {
+      cx.addRule(mode, {
+        template,
+        alternative,
+        priority: explicit ?? alternative.priority,
+        precedence,
+        position: cx.nextPosition(),
+      });
+    }
+  }
+}
+
+/**
+ * Builds the template of a simplified stylesheet: a rule for "/" whose
+ * body is the literal result element.
+ * @param {object} declaration
+ * @param {object} cx
+ */
+export function declareSimplified(declaration, cx) {
+  const { element, precedence, importLow } = declaration;
+  const template = {
+    params: [],
+    body: compileBody(element.parentNode, cx, cx.globalScope(), [element]),
+    convert: null,
+    precedence,
+    importLow,
+    element,
+  };
+  const pattern = compilePattern("/", element, cx);
+  cx.addRule("", {
+    template,
+    alternative: pattern.alternatives[0],
+    priority: -0.5,
+    precedence,
+    position: cx.nextPosition(),
+  });
+}

package/src/xslt/compiler/useAccumulators.js

@@ -0,0 +1,76 @@
+/**
+ * The use-accumulators attributes (XSLT 3.0 section 18.2.2) of xsl:mode,
+ * xsl:global-context-item, xsl:source-document and xsl:merge-source: the
+ * accumulators that apply to a tree.
+ *
+ * @module @tradik/xslt3/xslt/compiler/useAccumulators
+ */
+
+import { compareCodepoints } from "../../xdm/strings.js";
+import { attr, clarkOf, tokens, xsltError } from "../names.js";
+
+/**
+ * The use-accumulators attributes of the xsl:mode declarations: the one
+ * of the highest import precedence wins.
+ * @param {object[]} declarations
+ * @param {object} cx
+ * @throws {import("../../errors.js").XPathError} XTSE0545 for different
+ *   values at the same precedence
+ */
+export function declareModeAccumulators(declarations, cx) {
+  const chosen = new Map();
+  for (const { element, precedence } of declarations) {
+    const text = attr(element, "use-accumulators");
+    if (text === undefined) continue;
+    const nameText = attr(element, "name");
+    const name =
+      nameText === undefined || nameText.trim() === "#unnamed"
+        ? ""
+        : clarkOf(cx.exprs.qname(nameText, element));
+    const accumulators = useAccumulators(text, element, cx);
+    const key =
+      accumulators === "all"
+        ? "#all"
+        : [...accumulators].sort(compareCodepoints).join();
+    const current = chosen.get(name);
+    if (current?.precedence === precedence && current.key !== key) {
+      current.conflict = true;
+    } else if (!current || current.precedence < precedence) {
+      chosen.set(name, { precedence, key, accumulators, conflict: false });
+    }
+  }
+  for (const [name, { accumulators, conflict }] of chosen) {
+    if (conflict) {
+      throw xsltError("XTSE0545", "Conflicting use-accumulators for a mode");
+    }
+    cx.mode(name).accumulators = accumulators;
+  }
+}
+
+/**
+ * Parses a use-accumulators attribute.
+ * @param {string} text
+ * @param {Element} element
+ * @param {object} cx
+ * @returns {Set<string>|"all"} Clark names of the accumulators, or all
+ * @throws {import("../../errors.js").XPathError} XTSE3300
+ */
+export function useAccumulators(text, element, cx) {
+  const names = tokens(text);
+  if (names.includes("#all")) {
+    if (names.length > 1) {
+      throw xsltError("XTSE3300", "#all must be alone in use-accumulators");
+    }
+    return "all";
+  }
+  const keys = new Set();
+  for (const token of names) {
+    const name = cx.exprs.qname(token, element, { code: "XTSE3300" });
+    const key = clarkOf(name);
+    if (keys.has(key) || !cx.accumulators.has(key)) {
+      throw xsltError("XTSE3300", `Invalid accumulator ${token}`);
+    }
+    keys.add(key);
+  }
+  return keys;
+}

package/src/xslt/compiler/useWhen.js

@@ -0,0 +1,94 @@
+/**
+ * Static expressions (XSLT 3.0 section 9.7): use-when conditions, the
+ * values of static variables and parameters, and shadow attributes,
+ * evaluated at compile time in a restricted static context: the
+ * namespaces in scope, the static variables declared before, the
+ * standard functions and system-property(), function-available(),
+ * element-available() and type-available(); no context item.
+ *
+ * @module @tradik/xslt3/xslt/compiler/useWhen
+ */
+
+import { defaultFunctionLibrary } from "../../xpath/index.js";
+import { compileNode } from "../../xpath/eval/compiler.js";
+import { createDynamicContext } from "../../xpath/eval/dynamicContext.js";
+import { createStaticContext } from "../../xpath/eval/staticContext.js";
+import { parseXPath } from "../../xpath/syntax/index.js";
+import { effectiveBooleanValue } from "../../xdm/nodes.js";
+import { standardAttr } from "../names.js";
+import { availabilityFunctions } from "../runtime/availability.js";
+import { simpleContent } from "../runtime/values.js";
+import { parseAvt } from "./avt.js";
+import { infoOf } from "./elementInfo.js";
+
+const library = defaultFunctionLibrary.extend(availabilityFunctions);
+
+/**
+ * Evaluates a static expression written on a stylesheet element.
+ * @param {string} text
+ * @param {Element} element
+ * @param {Map<string, Array>} statics - Static variables by Clark name
+ * @param {object} [resources] - Dynamic options: `xmlParser` and
+ *   `createDocument`, for parse-xml(), json-to-xml() and the like
+ * @returns {Array} the value
+ */
+export function evaluateStatic(text, element, statics, resources = {}) {
+  const info = infoOf(element);
+  const sc = createStaticContext(
+    {
+      namespaces: new Map(
+        [...info.namespaces].filter(([prefix]) => prefix !== ""),
+      ),
+      defaultElementNamespace: info.xpathDefaultNs,
+      baseUri: info.baseUri,
+    },
+    library,
+  );
+  sc.defaultNamespace = info.namespaces.get("") ?? "";
+  let vars = null;
+  let env = null;
+  for (const [key, value] of statics) {
+    vars = { key, next: vars };
+    env = { value, next: env };
+  }
+  const run = compileNode(parseXPath(text), { sc, vars });
+  const dyn = createDynamicContext(sc, resources, undefined);
+  dyn.sc = sc;
+  return run({ item: undefined, position: 0, size: 0, env, dyn });
+}
+
+/**
+ * Evaluates a static attribute value template (shadow attributes).
+ * @param {string} text
+ * @param {Element} element
+ * @param {Map<string, Array>} statics
+ * @param {object} [resources] - See {@link evaluateStatic}
+ * @returns {string}
+ */
+export function evaluateStaticAvt(text, element, statics, resources) {
+  return parseAvt(text)
+    .map((part) =>
+      typeof part === "string"
+        ? part
+        : simpleContent(
+            evaluateStatic(part.expr, element, statics, resources),
+            " ",
+          ),
+    )
+    .join("");
+}
+
+/**
+ * Evaluates the use-when condition of an element.
+ * @param {Element} element
+ * @param {Map<string, Array>} [statics] - Static variables in scope
+ * @param {object} [resources] - See {@link evaluateStatic}
+ * @returns {boolean} true when the element is included
+ */
+export function useWhen(element, statics = new Map(), resources = {}) {
+  const condition = standardAttr(element, "use-when");
+  if (condition === undefined) return true;
+  return effectiveBooleanValue(
+    evaluateStatic(condition, element, statics, resources),
+  );
+}