@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/compiler/decimalFormats.js

@@ -0,0 +1,132 @@
+/**
+ * xsl:decimal-format declarations (XSLT 3.0 section 21.2.1): the
+ * properties of each format merged by import precedence and checked,
+ * as definitions for the XPath static context (see
+ * xpath/eval/decimalFormats.js).
+ *
+ * @module @tradik/xslt3/xslt/compiler/decimalFormats
+ */
+
+import { clarkOf, xsltError } from "../names.js";
+
+/** Properties holding one character. */
+const CHARACTERS = [
+  "decimal-separator",
+  "grouping-separator",
+  "minus-sign",
+  "exponent-separator",
+  "percent",
+  "per-mille",
+  "zero-digit",
+  "digit",
+  "pattern-separator",
+];
+
+/** Properties holding a string. */
+const STRINGS = ["infinity", "NaN"];
+
+/** Properties whose characters must differ (XTSE1300). */
+const DISTINCT = [
+  "decimal-separator",
+  "grouping-separator",
+  "exponent-separator",
+  "percent",
+  "per-mille",
+  "digit",
+  "pattern-separator",
+];
+
+/** Default values of the distinct properties. */
+const DEFAULTS = {
+  "decimal-separator": ".",
+  "grouping-separator": ",",
+  "exponent-separator": "e",
+  percent: "%",
+  "per-mille": "‰",
+  digit: "#",
+  "pattern-separator": ";",
+  "zero-digit": "0",
+};
+
+/**
+ * Whether a code point is a decimal digit with value zero: Unicode
+ * decimal digits come in runs of ten, from zero to nine.
+ * @param {number} codePoint
+ * @returns {boolean}
+ */
+function isZeroDigit(codePoint) {
+  const digit = (cp) => /^\p{Nd}$/u.test(String.fromCodePoint(cp));
+  if (!digit(codePoint)) return false;
+  let before = 0;
+  while (codePoint - before - 1 >= 0 && digit(codePoint - before - 1)) {
+    before++;
+  }
+  return before % 10 === 0;
+}
+
+/**
+ * Checks a merged format: zero-digit is a digit with value 0, and the
+ * picture characters are distinct (the ten digits included).
+ * @param {object} format
+ */
+function checkFormat(format) {
+  const zero = format["zero-digit"] ?? "0";
+  const base = zero.codePointAt(0);
+  if (!isZeroDigit(base)) {
+    throw xsltError("XTSE1295", "zero-digit must be a digit with value zero");
+  }
+  const used = new Set();
+  for (let i = 0; i < 10; i++) used.add(String.fromCodePoint(base + i));
+  for (const property of DISTINCT) {
+    const value = format[property] ?? DEFAULTS[property];
+    if (used.has(value)) {
+      throw xsltError("XTSE1300", `The decimal format uses ${value} twice`);
+    }
+    used.add(value);
+  }
+}
+
+/**
+ * Collects the decimal formats.
+ * @param {object[]} declarations
+ * @param {object} cx
+ * @returns {object[]} definitions with a `name` (Q{uri}local, "" for the
+ *   default format)
+ */
+export function collectDecimalFormats(declarations, cx) {
+  const formats = new Map();
+  for (const { element, precedence } of declarations) {
+    const nameText = element.getAttribute("name");
+    const name = nameText
+      ? `Q${clarkOf(cx.exprs.qname(nameText, element))}`
+      : "";
+    const format = formats.get(name) ?? { name, from: {}, conflict: {} };
+    for (const property of [...CHARACTERS, ...STRINGS]) {
+      if (!element.hasAttribute(property)) continue;
+      const value = element.getAttribute(property);
+      if (CHARACTERS.includes(property) && [...value].length !== 1) {
+        throw xsltError("XTSE0020", `${property} must be one character`);
+      }
+      if (format.from[property] === precedence && format[property] !== value) {
+        format.conflict[property] = precedence;
+      }
+      if (
+        format.from[property] === undefined ||
+        format.from[property] <= precedence
+      ) {
+        format[property] = value;
+        format.from[property] = precedence;
+      }
+    }
+    formats.set(name, format);
+  }
+  for (const format of formats.values()) {
+    for (const [property, precedence] of Object.entries(format.conflict)) {
+      if (format.from[property] === precedence) {
+        throw xsltError("XTSE1290", `Conflicting values of ${property}`);
+      }
+    }
+    checkFormat(format);
+  }
+  return [...formats.values()];
+}

package/src/xslt/compiler/declarationKinds.js

@@ -0,0 +1,82 @@
+/**
+ * The top-level declarations of a stylesheet module tree, grouped by kind
+ * and checked: known XSLT declarations (XTSE0010), elements in no
+ * namespace (XTSE0130), xsl:expose only in xsl:package, empty
+ * declarations (XTSE0260), no xsl:import-schema (XTSE1650: this
+ * processor is not schema aware).
+ *
+ * @module @tradik/xslt3/xslt/compiler/declarationKinds
+ */
+
+import { isXsl, XSL_NS, xsltError } from "../names.js";
+import { checkAttributes, checkEmpty } from "./attributes.js";
+import { infoOf } from "./elementInfo.js";
+import { declarationsOf } from "./modules.js";
+
+/** Top-level XSLT declarations. */
+const DECLARATIONS = new Set([
+  "template",
+  "function",
+  "variable",
+  "param",
+  "key",
+  "output",
+  "decimal-format",
+  "namespace-alias",
+  "strip-space",
+  "preserve-space",
+  "character-map",
+  "attribute-set",
+  "mode",
+  "import-schema",
+  "global-context-item",
+  "accumulator",
+  "use-package",
+  "expose",
+]);
+
+/** Declarations that must be empty. */
+const EMPTY_DECLARATIONS = new Set([
+  "strip-space",
+  "preserve-space",
+  "namespace-alias",
+  "output",
+  "decimal-format",
+]);
+
+/**
+ * The declarations of a module tree by kind, checked.
+ * @param {object} tree - See modules.js
+ * @param {object} cx - Stylesheet compiler (records the precedences)
+ * @returns {(kind: string) => object[]} the declarations of a kind
+ */
+export function collectDeclarations(tree, cx) {
+  const packageRoot = isXsl(tree.root, "package") ? tree.root : null;
+  const byKind = new Map();
+  for (const declaration of declarationsOf(tree)) {
+    const { element, simplified } = declaration;
+    const kind = simplified ? "simplified" : element.localName;
+    if (!simplified && element.namespaceURI !== XSL_NS) {
+      if (!element.namespaceURI) {
+        throw xsltError("XTSE0130", `${element.nodeName} has no namespace`);
+      }
+      continue;
+    }
+    if (!simplified && !DECLARATIONS.has(kind)) {
+      if (infoOf(element).version > 3) continue;
+      throw xsltError("XTSE0010", `xsl:${kind} is not a declaration`);
+    }
+    if (kind === "expose" && element.parentNode !== packageRoot) {
+      throw xsltError("XTSE0010", "xsl:expose belongs in xsl:package");
+    }
+    if (!simplified) checkAttributes(element);
+    if (EMPTY_DECLARATIONS.has(kind)) checkEmpty(element, cx);
+    if (!byKind.has(kind)) byKind.set(kind, []);
+    byKind.get(kind).push(declaration);
+    cx.declarationPrecedence.set(element, declaration.precedence);
+  }
+  if (byKind.has("import-schema")) {
+    throw xsltError("XTSE1650", "xsl:import-schema needs schema awareness");
+  }
+  return (kind) => byKind.get(kind) ?? [];
+}

package/src/xslt/compiler/elementInfo.js

@@ -0,0 +1,246 @@
+/**
+ * What a stylesheet element inherits from its ancestors: in-scope
+ * namespaces, the effective version, the standard attributes
+ * xpath-default-namespace, default-collation, exclude-result-prefixes,
+ * extension-element-prefixes and expand-text, and the base URI (xml:base).
+ * Computed once per element and cached.
+ *
+ * @module @tradik/xslt3/xslt/compiler/elementInfo
+ */
+
+import { getCollation } from "../../functions/collations.js";
+import { resolveUri } from "../../xpath/eval/uris.js";
+import {
+  clarkOf,
+  RESERVED_NAMESPACES,
+  resolveQName,
+  standardAttr,
+  tokens,
+  XML_NS,
+  XMLNS_NS,
+  XSL_NS,
+  xsltError,
+} from "../names.js";
+
+/**
+ * @typedef {object} ElementInfo
+ * @property {Map<string, string>} namespaces - Prefix to URI ("" default)
+ * @property {number} version - Effective version
+ * @property {string} xpathDefaultNs - Default element namespace of XPath
+ * @property {string|undefined} defaultCollation - Collation URI
+ * @property {string|undefined} baseUri
+ * @property {Set<string>} excluded - Excluded result namespace URIs
+ * @property {Set<string>} extension - Extension namespace URIs
+ * @property {boolean} expandText - Text value templates enabled
+ * @property {string} defaultMode - Clark name, "" for the unnamed mode
+ */
+
+/** @type {WeakMap<Element, ElementInfo>} */
+const cache = new WeakMap();
+/** @type {WeakMap<Element, string>} base URIs of module roots */
+const moduleUris = new WeakMap();
+
+/**
+ * Records the URI of a stylesheet module, the base URI of its root.
+ * @param {Element} root
+ * @param {string|undefined} uri
+ */
+export function setModuleUri(root, uri) {
+  if (uri !== undefined) moduleUris.set(root, uri);
+}
+
+/**
+ * Forgets the info of an element whose attributes changed (shadow
+ * attributes evaluated after its use-when condition read its info).
+ * @param {Element} element
+ */
+export function forgetInfo(element) {
+  cache.delete(element);
+}
+
+/**
+ * The URI of the stylesheet module an element belongs to.
+ * @param {Node} element
+ * @returns {string|undefined}
+ */
+export function moduleUriOf(element) {
+  for (let node = element; node?.nodeType === 1; node = node.parentNode) {
+    if (moduleUris.has(node)) return moduleUris.get(node);
+  }
+  return undefined;
+}
+
+const ROOT_INFO = Object.freeze({
+  namespaces: new Map([["xml", XML_NS]]),
+  version: 3,
+  xpathDefaultNs: "",
+  defaultCollation: undefined,
+  baseUri: undefined,
+  excluded: new Set([XSL_NS]),
+  extension: new Set(),
+  expandText: false,
+  defaultMode: "",
+});
+
+/**
+ * @param {Element} element
+ * @param {Map<string, string>} inherited
+ * @returns {Map<string, string>} the in-scope namespaces of the element
+ */
+function namespacesOf(element, inherited) {
+  let namespaces = inherited;
+  for (const attribute of element.attributes) {
+    const name = attribute.name;
+    const declaration =
+      attribute.namespaceURI === XMLNS_NS ||
+      name === "xmlns" ||
+      name.startsWith("xmlns:");
+    if (!declaration) continue;
+    if (namespaces === inherited) namespaces = new Map(inherited);
+    namespaces.set(name === "xmlns" ? "" : name.slice(6), attribute.value);
+  }
+  if (element.namespaceURI && !namespaces.has(element.prefix ?? "")) {
+    if (namespaces === inherited) namespaces = new Map(inherited);
+    namespaces.set(element.prefix ?? "", element.namespaceURI);
+  }
+  return namespaces;
+}
+
+/**
+ * URIs of a list of prefixes (exclude-result-prefixes and friends).
+ * @param {string} text
+ * @param {Map<string, string>} namespaces
+ * @param {Set<string>} into - Receives the URIs
+ * @param {string} code - Error code for an undeclared prefix
+ */
+function addPrefixUris(text, namespaces, into, code) {
+  for (const token of tokens(text)) {
+    if (token === "#all") {
+      for (const uri of namespaces.values()) into.add(uri);
+      continue;
+    }
+    const prefix = token === "#default" ? "" : token;
+    const uri = namespaces.get(prefix);
+    if (uri === undefined || (uri === "" && prefix !== "")) {
+      throw xsltError(
+        prefix === "" ? "XTSE0809" : code,
+        `No namespace is bound to the prefix "${token}"`,
+      );
+    }
+    into.add(uri);
+  }
+}
+
+/**
+ * The first collation of a default-collation list that is supported.
+ * @param {string} text
+ * @param {string|undefined} base
+ * @returns {string}
+ */
+function chooseCollation(text, base) {
+  for (const token of tokens(text)) {
+    const uri = resolveUri(token, base);
+    try {
+      getCollation(uri);
+      return uri;
+    } catch {
+      // try the next one
+    }
+  }
+  throw xsltError("XTSE0125", `No supported collation in "${text}"`);
+}
+
+/**
+ * The parsed version attribute.
+ * @param {string} text
+ * @returns {number}
+ */
+function parseVersion(text) {
+  if (!/^\s*\+?(\d+(\.\d*)?|\.\d+)\s*$/.test(text)) {
+    throw xsltError("XTSE0110", `Invalid version "${text}"`);
+  }
+  return Number(text);
+}
+
+/**
+ * Computes the info of an element from the info of its parent.
+ * @param {Element} element
+ * @param {ElementInfo} parent
+ * @returns {ElementInfo}
+ */
+function computeInfo(element, parent) {
+  const info = { ...parent };
+  info.namespaces = namespacesOf(element, parent.namespaces);
+  const own = (name) => standardAttr(element, name);
+  const xmlBase = element.getAttributeNS(XML_NS, "base");
+  const moduleUri = moduleUris.get(element);
+  if (moduleUri !== undefined) info.baseUri = moduleUri;
+  if (xmlBase) info.baseUri = resolveUri(xmlBase, info.baseUri);
+  const version = own("version");
+  if (version !== undefined) info.version = parseVersion(version);
+  const xpathNs = own("xpath-default-namespace");
+  if (xpathNs !== undefined) info.xpathDefaultNs = xpathNs.trim();
+  const collation = own("default-collation");
+  if (collation !== undefined) {
+    info.defaultCollation = chooseCollation(collation, info.baseUri);
+  }
+  const excluded = own("exclude-result-prefixes");
+  const extension = own("extension-element-prefixes");
+  if (excluded !== undefined || extension !== undefined) {
+    info.excluded = new Set(parent.excluded);
+    addPrefixUris(excluded, info.namespaces, info.excluded, "XTSE0808");
+  }
+  if (extension !== undefined) {
+    info.extension = new Set(parent.extension);
+    addPrefixUris(extension, info.namespaces, info.extension, "XTSE1430");
+    for (const uri of info.extension) {
+      if (RESERVED_NAMESPACES.has(uri)) {
+        throw xsltError("XTSE0085", `${uri} cannot be an extension namespace`);
+      }
+    }
+    for (const uri of info.extension) info.excluded.add(uri);
+  }
+  const defaultMode = own("default-mode");
+  if (defaultMode !== undefined) {
+    const text = defaultMode.trim();
+    info.defaultMode =
+      text === "#unnamed"
+        ? ""
+        : clarkOf(resolveQName(text, info.namespaces, { code: "XTSE0545" }));
+  }
+  const expand = own("expand-text");
+  if (expand !== undefined) {
+    const value = expand.trim();
+    if (!["yes", "true", "1", "no", "false", "0"].includes(value)) {
+      throw xsltError("XTSE0020", `Invalid expand-text "${expand}"`);
+    }
+    info.expandText = ["yes", "true", "1"].includes(value);
+  }
+  return info;
+}
+
+/**
+ * The info of a stylesheet element.
+ * @param {Element} element
+ * @returns {ElementInfo}
+ */
+export function infoOf(element) {
+  let info = cache.get(element);
+  if (info) return info;
+  const chain = [];
+  let current = element;
+  while (current && current.nodeType === 1 && !cache.has(current)) {
+    chain.push(current);
+    if (moduleUris.has(current)) break;
+    current = current.parentNode;
+  }
+  info =
+    current && current.nodeType === 1 && cache.has(current)
+      ? cache.get(current)
+      : ROOT_INFO;
+  for (let i = chain.length - 1; i >= 0; i--) {
+    info = computeInfo(chain[i], info);
+    cache.set(chain[i], info);
+  }
+  return info;
+}

package/src/xslt/compiler/expressions.js

@@ -0,0 +1,175 @@
+/**
+ * XPath in a stylesheet: the static context of each stylesheet element
+ * (in-scope namespaces, xpath-default-namespace, base URI, backwards
+ * compatibility, decimal formats, the function library with the
+ * stylesheet functions), and the compilation of expressions, sequence
+ * types and attribute value templates against the variables in scope.
+ *
+ * @module @tradik/xslt3/xslt/compiler/expressions
+ */
+
+import { compileNode, withinLimits } from "../../xpath/eval/compiler.js";
+import { compileSequenceType } from "../../xpath/eval/sequenceType.js";
+import { createStaticContext } from "../../xpath/eval/staticContext.js";
+import { parseXPath } from "../../xpath/syntax/index.js";
+import { TokenStream } from "../../xpath/syntax/tokenStream.js";
+import { parseSequenceType } from "../../xpath/syntax/types.js";
+import { XPathError } from "../../errors.js";
+import { resolveQName } from "../names.js";
+import { parseAvt } from "./avt.js";
+import { infoOf } from "./elementInfo.js";
+
+/**
+ * A compiled XPath expression of the stylesheet.
+ * @typedef {object} Expr
+ * @property {(ctx: object) => Array} run - The evaluator
+ * @property {string} text - Source text
+ * @property {object} sc - Static context
+ * @property {object} ast - Syntax tree
+ */
+
+/** The namespace of the standard functions. */
+const FN_NS = "http://www.w3.org/2005/xpath-functions";
+
+/**
+ * In backwards-compatible mode a call of an unknown extension function
+ * is an error only when evaluated (XSLT 3.0 section 24.1.2, XTDE1425).
+ * @param {Error} error - Raised by the XPath compiler
+ * @param {object} sc - Static context of the expression
+ * @returns {(ctx: object) => Array} an evaluator raising XTDE1425
+ * @throws {Error} the error otherwise
+ */
+function unavailableFunction(error, sc) {
+  const uri = /^XPST0017: Unknown function Q\{([^}]*)\}/.exec(
+    error.message,
+  )?.[1];
+  if (!sc.backwardsCompatible || uri === undefined || uri === FN_NS) {
+    throw error;
+  }
+  return () => {
+    throw new XPathError("XTDE1425", error.message.slice(10));
+  };
+}
+
+/** Compiles the XPath expressions of a stylesheet. */
+export class ExpressionCompiler {
+  /**
+   * @param {object} options
+   * @param {import("../../functions/registry.js").FunctionLibrary} options.library
+   * @param {Array<object>} [options.decimalFormats] - Definitions
+   * @param {object} [options.owner] - Package compiler of the expressions
+   */
+  constructor({ library, decimalFormats = [], owner = null }) {
+    this.library = library;
+    this.decimalFormats = decimalFormats;
+    /** The package compiler whose keys key() reads (null: the stylesheet's) */
+    this.owner = owner;
+    /** @type {WeakMap<Map, Map<string, object>>} */
+    this.cache = new WeakMap();
+  }
+
+  /**
+   * The static context of the expressions of a stylesheet element.
+   * @param {Element} element
+   * @returns {object} an XPath static context
+   */
+  staticContext(element) {
+    const info = infoOf(element);
+    let byKey = this.cache.get(info.namespaces);
+    if (!byKey) {
+      byKey = new Map();
+      this.cache.set(info.namespaces, byKey);
+    }
+    const compatible = info.version < 2;
+    const key = `${info.xpathDefaultNs}|${info.baseUri}|${compatible}`;
+    let sc = byKey.get(key);
+    if (!sc) {
+      const namespaces = new Map(
+        [...info.namespaces].filter(([p]) => p !== ""),
+      );
+      sc = createStaticContext(
+        {
+          namespaces,
+          defaultElementNamespace: info.xpathDefaultNs,
+          baseUri: info.baseUri,
+          backwardsCompatible: compatible,
+          decimalFormats: this.decimalFormats,
+        },
+        this.library,
+      );
+      sc.owner = this.owner;
+      // for element-available(), whose unprefixed names use it
+      sc.defaultNamespace = info.namespaces.get("") ?? "";
+      byKey.set(key, sc);
+    }
+    return sc;
+  }
+
+  /**
+   * Compiles an XPath expression written on a stylesheet element.
+   * @param {string} text
+   * @param {Element} element
+   * @param {object|null} vars - Variables in scope (see eval/scope.js)
+   * @returns {Expr}
+   */
+  xpath(text, element, vars) {
+    const sc = this.staticContext(element);
+    const ast = parseXPath(text);
+    const run = withinLimits(() => {
+      try {
+        return compileNode(ast, { sc, vars });
+      } catch (error) {
+        return unavailableFunction(error, sc);
+      }
+    });
+    return { run, text, sc, ast };
+  }
+
+  /**
+   * Compiles an XPath AST (patterns compile their parts this way).
+   * @param {object} ast
+   * @param {object} sc
+   * @param {object|null} vars
+   * @returns {(ctx: object) => Array}
+   */
+  compileAst(ast, sc, vars) {
+    return withinLimits(() => compileNode(ast, { sc, vars }));
+  }
+
+  /**
+   * Compiles a sequence type (an `as` attribute).
+   * @param {string} text
+   * @param {Element} element
+   * @returns {import("../../xpath/eval/sequenceType.js").SequenceType}
+   */
+  sequenceType(text, element) {
+    const tokens = new TokenStream(text);
+    const node = parseSequenceType(tokens);
+    if (tokens.peek().type !== "eof") tokens.fail("Unexpected token");
+    return compileSequenceType(node, this.staticContext(element));
+  }
+
+  /**
+   * Compiles an attribute value template.
+   * @param {string} text
+   * @param {Element} element
+   * @param {object|null} vars
+   * @returns {Array<string|Expr>} literal parts and expressions
+   */
+  avt(text, element, vars) {
+    return parseAvt(text).map((part) =>
+      typeof part === "string" ? part : this.xpath(part.expr, element, vars),
+    );
+  }
+
+  /**
+   * Resolves a QName attribute value of a stylesheet element.
+   * @param {string} text
+   * @param {Element} element
+   * @param {object} [options] - See names.resolveQName
+   * @returns {import("../names.js").ExpandedName}
+   */
+  qname(text, element, options) {
+    return resolveQName(text, infoOf(element).namespaces, options);
+  }
+}