@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/compiler/globalContextItem.js

@@ -0,0 +1,92 @@
+/**
+ * xsl:global-context-item (XSLT 3.0 section 3.5.6): whether the global
+ * context item is required, optional or absent, and its type, checked
+ * when a transformation starts.
+ *
+ * @module @tradik/xslt3/xslt/compiler/globalContextItem
+ */
+
+import { coerce } from "../../xpath/eval/coercion.js";
+import { attr, xsltError } from "../names.js";
+
+/** Values of the use attribute. */
+const USES = new Set(["required", "optional", "absent"]);
+
+/**
+ * Compiles the xsl:global-context-item declarations into
+ * `cx.globalContextItem`: `{use, type}`.
+ * @param {object[]} declarations
+ * @param {object} cx
+ * @throws {import("../../errors.js").XPathError} XTSE3087 for two
+ *   different declarations, XTSE0020 for an invalid use, XTSE3089 for a
+ *   type with use="absent"
+ */
+export function declareGlobalContextItem(declarations, cx) {
+  cx.globalContextItem = { use: "optional", type: null };
+  const seen = new Set();
+  const modules = new Set();
+  for (const { element } of declarations) {
+    if (modules.has(element.parentNode)) {
+      throw xsltError("XTSE3087", "Two xsl:global-context-item in a module");
+    }
+    modules.add(element.parentNode);
+    const use = (attr(element, "use") ?? "optional").trim();
+    if (!USES.has(use)) throw xsltError("XTSE0020", `Invalid use "${use}"`);
+    const asText = attr(element, "as");
+    if (use === "absent" && asText !== undefined) {
+      throw xsltError("XTSE3089", 'use="absent" cannot have a type');
+    }
+    // the types compared without whitespace, which is not significant
+    seen.add(`${use}|${asText?.replace(/\s+/g, "")}`);
+    if (seen.size > 1) {
+      throw xsltError("XTSE3087", "Conflicting xsl:global-context-item");
+    }
+    const type =
+      asText === undefined ? null : cx.exprs.sequenceType(asText, element);
+    cx.globalContextItem = { use, type };
+  }
+}
+
+/**
+ * Checks the used packages: their global context item is absent, so one
+ * that declares it required cannot run (XSLT 3.0 xsl:global-context-item:
+ * XTTE0590).
+ * @param {object} cx - The top-level package's compiler
+ * @throws {import("../../errors.js").XPathError} XTTE0590
+ */
+export function checkLibraryContextItems(cx) {
+  for (const { child } of cx.uses) {
+    if (child.globalContextItem.use === "required") {
+      throw xsltError(
+        "XTTE0590",
+        `The used package ${child.packageName} requires a global context item`,
+      );
+    }
+    checkLibraryContextItems(child);
+  }
+}
+
+/**
+ * The global context item of a transformation, checked against the
+ * declaration.
+ * @param {object} declared - `{use, type}`
+ * @param {*} item - The item supplied, undefined for none
+ * @returns {*} the item, undefined when absent
+ * @throws {import("../../errors.js").XPathError} XTDE3086 when a
+ *   required item is missing, XTTE0590 when it has the wrong type
+ */
+export function globalContextItem(declared, item) {
+  if (declared.use === "absent") return undefined;
+  if (item === undefined) {
+    if (declared.use === "required") {
+      throw xsltError("XTDE3086", "A global context item is required");
+    }
+    return undefined;
+  }
+  if (!declared.type) return item;
+  try {
+    return coerce([item], declared.type, { what: "global context item" })[0];
+  } catch (error) {
+    throw xsltError("XTTE0590", error.message.replace(/^[A-Z]+\d+: /, ""));
+  }
+}

package/src/xslt/compiler/globals.js

@@ -0,0 +1,209 @@
+/**
+ * Global variables and parameters (XSLT 3.0 section 9.5) and stylesheet
+ * functions (section 10.3): names collected first (they are in scope
+ * everywhere), the declaration of highest import precedence chosen, then
+ * compiled.
+ *
+ * @module @tradik/xslt3/xslt/compiler/globals
+ */
+
+import { coerce } from "../../xpath/eval/coercion.js";
+import { compileParams } from "../instructions/params.js";
+import {
+  compileValue,
+  typeConverter,
+  variableName,
+} from "../instructions/variables.js";
+import {
+  attr,
+  displayName,
+  isXsl,
+  RESERVED_NAMESPACES,
+  xsltError,
+} from "../names.js";
+import { required, yesNo } from "./attributes.js";
+import { compileBody } from "./body.js";
+import { splitParams } from "./templatesDecl.js";
+
+/**
+ * Chooses, among declarations with the same key, the one of highest
+ * import precedence.
+ * @param {object[]} declarations
+ * @param {(declaration: object) => string} keyOf
+ * @param {string} code - Error code for two at the same precedence
+ * @returns {Map<string, object>} the winners by key, in declaration order
+ */
+export function winners(declarations, keyOf, code) {
+  const chosen = new Map();
+  for (const declaration of declarations) {
+    const key = keyOf(declaration);
+    const current = chosen.get(key);
+    if (current && current.precedence === declaration.precedence) {
+      throw xsltError(code, `Duplicate declaration of ${key}`);
+    }
+    if (!current || current.precedence < declaration.precedence) {
+      chosen.set(key, declaration);
+    }
+  }
+  return chosen;
+}
+
+/**
+ * Collects the global variables and parameters: their keys, in scope
+ * everywhere, and the winning declarations.
+ * @param {object[]} declarations - xsl:variable and xsl:param declarations
+ * @param {object} cx
+ * @returns {Map<string, object>}
+ */
+export function collectGlobals(declarations, cx) {
+  return winners(
+    declarations,
+    (declaration) => {
+      declaration.key ??= variableName(declaration.element, cx);
+      return declaration.key;
+    },
+    "XTSE0630",
+  );
+}
+
+/**
+ * A scope without a variable: its binding keeps its place (references are
+ * resolved to depths) but cannot be found by name.
+ * @param {object} scope - `{vars}`
+ * @param {string} key - Clark name hidden
+ * @returns {object} the scope
+ */
+function hideVariable(scope, key) {
+  const before = [];
+  let found = scope.vars;
+  while (found !== null && found.key !== key) {
+    before.push(found.key);
+    found = found.next;
+  }
+  if (found === null) return scope;
+  let vars = { key: "", next: found.next };
+  for (let i = before.length - 1; i >= 0; i--) {
+    vars = { key: before[i], next: vars };
+  }
+  return { ...scope, vars };
+}
+
+/**
+ * Compiles a global variable or parameter. Its own name is not in scope
+ * in its declaration (XSLT 3.0 section 9.9: XPST0008).
+ * @param {{element: Element, key: string}} declaration
+ * @param {object} cx
+ * @param {object} [global] - Default: the global scope of the package
+ * @returns {object} `{key, isParam, required, value, convert}`
+ */
+export function compileGlobal({ element, key }, cx, global = cx.globalScope()) {
+  const scope = hideVariable(global, key);
+  const isParam = isXsl(element, "param");
+  if (isParam && yesNo(element, "tunnel", false)) {
+    throw xsltError(
+      "XTSE0020",
+      "A global parameter cannot be a tunnel parameter",
+    );
+  }
+  const compiled = compileValue(
+    element,
+    cx,
+    scope,
+    isParam ? "XTTE0590" : "XTTE0570",
+  );
+  return {
+    key,
+    isParam,
+    required: isParam && yesNo(element, "required", false),
+    // a static variable keeps the value of the static stage
+    value:
+      cx.staticDeclarations?.get(key)?.element === element
+        ? () =>
+            typeConverter(
+              compiled.type,
+              isParam ? "XTTE0590" : "XTTE0570",
+              `value of $${displayName(key)}`,
+            )(cx.statics.get(key))
+        : compiled.value,
+    convert: typeConverter(
+      compiled.type,
+      "XTTE0590",
+      `parameter $${displayName(key)}`,
+    ),
+  };
+}
+
+/**
+ * The function definition of an xsl:function for the function library;
+ * its body is compiled later by {@link compileFunction}.
+ * @param {object} declaration
+ * @param {object} cx
+ * @returns {object} `{key, uri, local, arity, declaration}`
+ */
+export function functionSignature(declaration, cx) {
+  const { element } = declaration;
+  const name = cx.exprs.qname(required(element, "name"), element, {
+    syntaxCode: "XTSE0020",
+  });
+  yesNo(element, "override", true);
+  yesNo(element, "override-extension-function", true);
+  if (!name.uri) throw xsltError("XTSE0740", "A function name needs a prefix");
+  if (RESERVED_NAMESPACES.has(name.uri)) {
+    throw xsltError("XTSE0080", `The namespace ${name.uri} is reserved`);
+  }
+  const children = cx.children(element);
+  const arity = splitParams(children).params.length;
+  return {
+    key: `{${name.uri}}${name.local}#${arity}`,
+    ...name,
+    arity,
+    declaration,
+  };
+}
+
+/**
+ * Compiles the body of a stylesheet function.
+ * @param {object} signature - From {@link functionSignature}
+ * @param {object} cx
+ * @returns {object} `{params, body, convert}`
+ */
+export function compileFunction(signature, cx) {
+  const { element } = signature.declaration;
+  const { params: paramElements, rest } = splitParams(cx.children(element));
+  const { params, scope } = compileParams(
+    paramElements,
+    cx,
+    cx.globalScope(),
+    true,
+  );
+  const asText = attr(element, "as");
+  const type = asText ? cx.exprs.sequenceType(asText, element) : null;
+  return {
+    params: params.map((param) => ({
+      ...param,
+      convert: param.type
+        ? (value) =>
+            coerce(value, param.type, {
+              what: `argument $${displayName(param.key)}`,
+            })
+        : (value) => value,
+    })),
+    body: compileBody(element, cx, { ...scope, inFunction: true }, rest),
+    convert: typeConverter(type, "XTTE0780", "result of the function"),
+    memo: isMemoized(element),
+  };
+}
+
+/**
+ * Whether the results of a function are cached: cache="yes", or
+ * new-each-time="no" (the same arguments give the same nodes).
+ * @param {Element} element - xsl:function
+ * @returns {boolean}
+ */
+function isMemoized(element) {
+  const flag = (name) => attr(element, name)?.trim();
+  return (
+    ["yes", "true", "1"].includes(flag("cache")) ||
+    ["no", "false", "0"].includes(flag("new-each-time"))
+  );
+}

package/src/xslt/compiler/linker.js

@@ -0,0 +1,134 @@
+/**
+ * Linking the packages of a stylesheet (XSLT 3.0 section 3.5.3.5): one
+ * environment for the global variables of every package, the components
+ * accepted from used packages entered in the registries of the using
+ * package, and abstract components made to fail when invoked (overriding
+ * declarations: see overrideLinks.js).
+ *
+ * @module @tradik/xslt3/xslt/compiler/linker
+ */
+
+import { xsltError } from "../names.js";
+import { compileGlobal } from "./globals.js";
+import { usesOriginal } from "./overrideLinks.js";
+
+/** A body that raises XTDE3052: an abstract component was invoked. */
+const ABSTRACT_BODY = [
+  () => {
+    throw xsltError("XTDE3052", "An abstract component was invoked");
+  },
+];
+
+/**
+ * Lays out the global variables of every package of the stylesheet in
+ * one environment, and gives each package the names it sees.
+ * @param {object} top - The top-level package's compiler
+ */
+export function layoutGlobals(top) {
+  const slots = [];
+  const packages = [];
+  const visit = (cx) => {
+    for (const use of cx.uses) visit(use.child);
+    packages.push(cx);
+    slots.push(...cx.ownSlots);
+  };
+  visit(top);
+  for (const cx of packages) {
+    cx.layout = slots;
+    cx.setGlobals(
+      slots.map((slot, i) =>
+        cx.globalNames.get(slot.name) === slot ? slot.name : `\u0000${i}`,
+      ),
+    );
+  }
+}
+
+/**
+ * Evaluates a global variable of a library package with an absent focus.
+ * @param {object} compiled - Compiled global
+ */
+function withoutFocus(compiled) {
+  const { value } = compiled;
+  compiled.value = (xc, machine) =>
+    value({ ...xc, item: undefined, position: 0, size: 0 }, machine);
+}
+
+/**
+ * Compiles the global variables whose value this package gives.
+ * @param {object} cx
+ * @returns {object[]} compiled globals of the whole layout (meaningful
+ *   for the top-level package, once every package is compiled)
+ */
+export function compileSlots(cx) {
+  cx.layout.forEach((slot) => {
+    if (slot.owner !== cx) return;
+    const original = slot.original
+      ? cx.layout.indexOf(slot.original)
+      : undefined;
+    if (slot.original?.abstract && usesOriginal(slot.declaration.element)) {
+      throw xsltError("XTSE3075", "The overridden variable is abstract");
+    }
+    slot.compiled = compileGlobal(
+      slot.declaration,
+      cx,
+      cx.globalScope(original),
+    );
+    // the value an overriding variable replaced is only read through it
+    if (slot.name === "") slot.compiled.required = false;
+    // the global context item belongs to the top-level package
+    if (cx.packageChain.length > 0) withoutFocus(slot.compiled);
+    if (slot.abstract) {
+      slot.compiled.value = ABSTRACT_BODY[0];
+      slot.compiled.required = false;
+    }
+  });
+  return cx.layout.map((slot, i) => ({
+    ...slot.compiled,
+    key: cx.globalKeys[i],
+  }));
+}
+
+/**
+ * Enters the templates, attribute sets and modes accepted from used
+ * packages in the registries of this package.
+ * @param {object} cx
+ */
+export function importAccepted(cx) {
+  for (const use of cx.uses) {
+    for (const { component } of use.accepted) {
+      const { owner, key } = component;
+      if (component.kind === "template") {
+        cx.namedTemplates.set(key, owner.namedTemplates.get(key));
+      } else if (component.kind === "attribute-set") {
+        cx.attributeSets.set(key, owner.attributeSets.get(key));
+      } else if (component.kind === "mode") {
+        cx.acceptedModes.set(key, owner.mode(key));
+      }
+    }
+  }
+}
+
+/**
+ * Makes the abstract components of this package raise XTDE3052.
+ * @param {object} cx
+ */
+export function markAbstract(cx) {
+  for (const entry of cx.table.values()) {
+    if (entry.owner !== cx || entry.visibility !== "abstract") continue;
+    if (entry.kind === "template") {
+      const template = cx.namedTemplates.get(entry.key);
+      template.body = ABSTRACT_BODY;
+      // its parameters are not evaluated: the call fails first
+      template.params = template.params.map((param) => ({
+        ...param,
+        required: false,
+        value: () => [],
+      }));
+    } else if (entry.kind === "function") {
+      entry.cell.body = ABSTRACT_BODY;
+    } else if (entry.kind === "attribute-set") {
+      const parts = cx.attributeSets.get(entry.key);
+      parts.splice(0, parts.length, { uses: [], body: ABSTRACT_BODY, cx });
+    }
+  }
+}

package/src/xslt/compiler/miscDecl.js

@@ -0,0 +1,171 @@
+/**
+ * Other declarations: xsl:strip-space and xsl:preserve-space (XSLT 3.0
+ * section 4.3), xsl:namespace-alias (11.1.3) and xsl:key (20.2.1);
+ * xsl:mode is in modeDecl.js.
+ *
+ * @module @tradik/xslt3/xslt/compiler/miscDecl
+ */
+
+import { compileBody } from "./body.js";
+import { getCollation } from "../../functions/collations.js";
+import { resolveUri } from "../../xpath/eval/uris.js";
+import { required, yesNo } from "./attributes.js";
+import { infoOf } from "./elementInfo.js";
+import { attr, clarkOf, tokens, xsltError } from "../names.js";
+import { compilePattern } from "../patterns/compile.js";
+
+/**
+ * A name test of xsl:strip-space or xsl:preserve-space: `*`, `prefix:*`,
+ * `*:local` or a QName (in the xpath-default-namespace when unprefixed).
+ * @param {string} token
+ * @param {Element} element
+ * @param {object} cx
+ * @returns {{uri: string|null, local: string|null, priority: number}}
+ */
+function nameTest(token, element, cx) {
+  if (token === "*") return { uri: null, local: null, priority: -0.5 };
+  if (token.startsWith("*:")) {
+    return { uri: null, local: token.slice(2), priority: -0.25 };
+  }
+  const eqWildcard = /^Q\{([^}]*)\}\*$/.exec(token);
+  if (eqWildcard) return { uri: eqWildcard[1], local: null, priority: -0.25 };
+  if (token.endsWith(":*")) {
+    const prefix = token.slice(0, -2);
+    const uri = infoOf(element).namespaces.get(prefix);
+    if (uri === undefined) {
+      throw xsltError("XTSE0280", `Undeclared prefix ${prefix}`);
+    }
+    return { uri, local: null, priority: -0.25 };
+  }
+  const name = cx.exprs.qname(token, element);
+  const uri = name.uri || infoOf(element).xpathDefaultNs;
+  return { uri, local: name.local, priority: 0 };
+}
+
+/**
+ * Compiles the whitespace stripping rules.
+ * @param {object[]} declarations - xsl:strip-space and xsl:preserve-space
+ * @param {object} cx
+ * @returns {object[]} rules `{strip, uri, local, priority, precedence,
+ *   position}` (uri or local null for wildcards), best first
+ */
+export function compileSpaceRules(declarations, cx) {
+  const rules = [];
+  declarations.forEach(({ element, precedence }, position) => {
+    const strip = element.localName === "strip-space";
+    for (const token of tokens(required(element, "elements"))) {
+      const test = nameTest(token, element, cx);
+      rules.push({ strip, ...test, precedence, position });
+    }
+  });
+  const seen = new Map();
+  for (const rule of rules) {
+    const key = `${rule.precedence}|${rule.uri}|${rule.local}`;
+    if (seen.has(key) && seen.get(key) !== rule.strip) {
+      throw xsltError(
+        "XTSE0270",
+        "The same name is in xsl:strip-space and xsl:preserve-space",
+      );
+    }
+    seen.set(key, rule.strip);
+  }
+  rules.sort(
+    (a, b) =>
+      b.precedence - a.precedence ||
+      b.priority - a.priority ||
+      b.position - a.position,
+  );
+  return rules;
+}
+
+/**
+ * Collects the namespace aliases.
+ * @param {object[]} declarations
+ * @returns {Map<string, {uri: string, prefix: string}>} result namespace
+ *   and prefix by stylesheet namespace URI
+ */
+export function collectAliases(declarations) {
+  const aliases = new Map();
+  const from = new Map();
+  for (const { element, precedence } of declarations) {
+    const namespaces = infoOf(element).namespaces;
+    const lookup = (name) => {
+      const prefix = required(element, name).trim();
+      const key = prefix === "#default" ? "" : prefix;
+      const uri = namespaces.get(key);
+      if (uri === undefined && key !== "") {
+        throw xsltError("XTSE0812", `Undeclared prefix ${prefix}`);
+      }
+      return { prefix: key, uri: uri ?? "" };
+    };
+    const source = lookup("stylesheet-prefix");
+    const result = lookup("result-prefix");
+    const previous = aliases.get(source.uri);
+    if (
+      previous &&
+      from.get(source.uri) === precedence &&
+      previous.uri !== result.uri
+    ) {
+      throw xsltError("XTSE0810", "Conflicting namespace aliases");
+    }
+    if (!previous || from.get(source.uri) <= precedence) {
+      aliases.set(source.uri, result);
+      from.set(source.uri, precedence);
+    }
+  }
+  return aliases;
+}
+
+/**
+ * XTSE1210: the collation of a key must be known.
+ * @param {string} uri - The collation attribute
+ * @param {Element} element
+ */
+function knownCollation(uri, element) {
+  try {
+    getCollation(resolveUri(uri.trim(), infoOf(element).baseUri));
+  } catch {
+    throw xsltError("XTSE1210", `Unknown collation ${uri}`);
+  }
+}
+
+/**
+ * Compiles an xsl:key into the key registry.
+ * @param {object} declaration
+ * @param {object} cx
+ */
+export function declareKey({ element }, cx) {
+  const name = clarkOf(cx.exprs.qname(required(element, "name"), element));
+  const use = attr(element, "use");
+  const children = cx.children(element);
+  if (use !== undefined && children.length > 0) {
+    // content that is no sequence constructor is the first error (XTSE0010)
+    compileBody(element, cx, cx.globalScope());
+    throw xsltError("XTSE1205", "xsl:key cannot have use and content");
+  }
+  if (use === undefined && children.length === 0) {
+    throw xsltError("XTSE1205", "xsl:key needs use or content");
+  }
+  const scope = cx.globalScope();
+  const collation = attr(element, "collation");
+  const definition = {
+    match: compilePattern(required(element, "match"), element, cx),
+    // namespace nodes are indexed only for keys that can match them
+    namespaces: required(element, "match").includes("namespace-node"),
+    use: use === undefined ? null : cx.exprs.xpath(use, element, scope.vars),
+    body: use === undefined ? compileBody(element, cx, scope) : null,
+    collation: collation ?? infoOf(element).defaultCollation,
+    compatible: infoOf(element).version < 2,
+  };
+  if (collation !== undefined) knownCollation(collation, element);
+  definition.composite = yesNo(element, "composite", false);
+  const list = cx.keys.get(name) ?? [];
+  if (list.length > 0 && list[0].collation !== definition.collation) {
+    throw xsltError("XTSE1220", `The key ${name} has different collations`);
+  }
+  if (list.length > 0 && list[0].composite !== definition.composite) {
+    throw xsltError("XTSE1222", `The key ${name} is composite and not`);
+  }
+  list.push(definition);
+  cx.keys.set(name, list);
+}

package/src/xslt/compiler/modeDecl.js

@@ -0,0 +1,88 @@
+/**
+ * xsl:mode declarations (XSLT 3.0 section 6.7.1): the behaviour of a
+ * mode for unmatched and ambiguously matched items, several declarations
+ * of a mode combined (XTSE0545 for a conflict at the same import
+ * precedence).
+ *
+ * @module @tradik/xslt3/xslt/compiler/modeDecl
+ */
+
+import { attr, clarkOf, xsltError } from "../names.js";
+
+const ON_NO_MATCH = new Set([
+  "deep-copy",
+  "shallow-copy",
+  "deep-skip",
+  "shallow-skip",
+  "text-only-copy",
+  "fail",
+]);
+
+/**
+ * Records the attributes of an xsl:mode declaration, noting two values
+ * of an attribute at the same import precedence (XTSE0545 unless a
+ * declaration of higher precedence settles it).
+ * @param {object} mode
+ * @param {Element} element
+ * @param {number} precedence
+ */
+function recordModeAttributes(mode, element, precedence) {
+  mode.declared ??= new Map();
+  for (const attribute of element.attributes) {
+    const key = attribute.name;
+    // use-accumulators is compared as a set (useAccumulators.js)
+    if (
+      key === "name" ||
+      key === "use-accumulators" ||
+      key.includes(":") ||
+      key.startsWith("xmlns")
+    ) {
+      continue;
+    }
+    const value = attribute.value.trim();
+    const previous = mode.declared.get(key);
+    const conflict =
+      previous?.precedence === precedence &&
+      (previous.conflict || previous.value !== value);
+    mode.declared.set(key, { value, precedence, conflict });
+  }
+}
+
+/**
+ * XTSE0545: checks the xsl:mode declarations once all are recorded.
+ * @param {Iterable<object>} modes
+ */
+export function checkModeDeclarations(modes) {
+  for (const mode of modes) {
+    for (const [key, { conflict }] of mode.declared ?? []) {
+      if (conflict) {
+        throw xsltError("XTSE0545", `Conflicting values of ${key} for a mode`);
+      }
+    }
+  }
+}
+
+/**
+ * Applies an xsl:mode declaration.
+ * @param {object} declaration
+ * @param {object} cx
+ */
+export function declareMode({ element, precedence }, cx) {
+  if (cx.children(element).length > 0) {
+    throw xsltError("XTSE0010", "xsl:mode must be empty");
+  }
+  const nameText = attr(element, "name");
+  const name =
+    nameText === undefined ? "" : clarkOf(cx.exprs.qname(nameText, element));
+  const mode = cx.mode(name);
+  recordModeAttributes(mode, element, precedence);
+  const onNoMatch = attr(element, "on-no-match");
+  if (onNoMatch !== undefined) {
+    if (!ON_NO_MATCH.has(onNoMatch.trim())) {
+      throw xsltError("XTSE0020", `Invalid on-no-match ${onNoMatch}`);
+    }
+    mode.onNoMatch = onNoMatch.trim();
+  }
+  const onMultiple = attr(element, "on-multiple-match");
+  if (onMultiple !== undefined) mode.onMultipleMatch = onMultiple.trim();
+}