@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/compiler/accumulatorDecl.js

@@ -0,0 +1,146 @@
+/**
+ * xsl:accumulator declarations (XSLT 3.0 section 18.2.1): the initial
+ * value, the rules (pattern, phase, new value computed with `$value`
+ * bound to the old one) and the declared type; and the use-accumulators
+ * attributes of xsl:mode, xsl:global-context-item, xsl:source-document
+ * and xsl:merge-source (section 18.2.2).
+ *
+ * @module @tradik/xslt3/xslt/compiler/accumulatorDecl
+ */
+
+import { typeConverter } from "../instructions/variables.js";
+import { attr, clarkOf, isXsl, xsltError } from "../names.js";
+import { compilePattern } from "../patterns/compile.js";
+import { evaluate } from "../runtime/context.js";
+import { bodySequence } from "../runtime/values.js";
+import { checkAttributes, required, yesNo } from "./attributes.js";
+import { compileBody } from "./body.js";
+import { declareModeAccumulators, useAccumulators } from "./useAccumulators.js";
+
+/** Clark name of the variable of the old value in accumulator rules. */
+export const VALUE_KEY = "{}value";
+
+/**
+ * Compiles a rule of an accumulator.
+ * @param {Element} element - xsl:accumulator-rule
+ * @param {object} cx
+ * @param {(value: Array) => Array} convert
+ * @returns {object} `{pattern, end, value(xc, machine)}`
+ */
+function compileRule(element, cx, convert) {
+  checkAttributes(element);
+  const phase = (attr(element, "phase") ?? "start").trim();
+  if (phase !== "start" && phase !== "end") {
+    throw xsltError("XTSE0020", `Invalid phase "${phase}"`);
+  }
+  const global = cx.globalScope();
+  const scope = { ...global, vars: { key: VALUE_KEY, next: global.vars } };
+  const select = attr(element, "select");
+  const children = cx.children(element);
+  if (select !== undefined && children.length > 0) {
+    throw xsltError("XTSE0010", "xsl:accumulator-rule has select and content");
+  }
+  let value;
+  if (select !== undefined) {
+    const expr = cx.exprs.xpath(select, element, scope.vars);
+    value = (xc) => convert(evaluate(expr, xc));
+  } else {
+    const body = compileBody(element, cx, scope, children);
+    value = (xc, machine) => convert(bodySequence(body, xc, machine));
+  }
+  return {
+    pattern: compilePattern(required(element, "match"), element, cx),
+    end: phase === "end",
+    value,
+  };
+}
+
+/**
+ * Compiles an xsl:accumulator.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {string} key - Its Clark name
+ * @returns {object} the accumulator
+ */
+function compileAccumulator(element, cx, key) {
+  yesNo(element, "streamable", false);
+  const asText = attr(element, "as");
+  const type =
+    asText === undefined ? null : cx.exprs.sequenceType(asText, element);
+  const convert = typeConverter(type, "XPTY0004", `accumulator ${key}`);
+  const initial = cx.exprs.xpath(
+    required(element, "initial-value"),
+    element,
+    cx.globalScope().vars,
+  );
+  const children = cx.children(element).filter((c) => !isXsl(c, "fallback"));
+  if (
+    children.length === 0 ||
+    !children.every((child) => isXsl(child, "accumulator-rule"))
+  ) {
+    throw xsltError(
+      "XTSE0010",
+      "xsl:accumulator contains xsl:accumulator-rule elements",
+    );
+  }
+  return {
+    key,
+    initial: (xc) => convert(evaluate(initial, xc)),
+    rules: children.map((child) => compileRule(child, cx, convert)),
+  };
+}
+
+/**
+ * The declaration of each name with the highest import precedence.
+ * @param {object[]} declarations - `{key, element, precedence}`
+ * @returns {Map<string, object>}
+ * @throws {import("../../errors.js").XPathError} XTSE3350 for two of
+ *   them at that precedence
+ */
+function highestPrecedence(declarations) {
+  const chosen = new Map();
+  const duplicated = new Set();
+  for (const declaration of declarations) {
+    const current = chosen.get(declaration.key);
+    if (current && current.precedence === declaration.precedence) {
+      duplicated.add(declaration.key);
+    } else if (!current || current.precedence < declaration.precedence) {
+      chosen.set(declaration.key, declaration);
+      duplicated.delete(declaration.key);
+    }
+  }
+  const [duplicate] = duplicated;
+  if (duplicate !== undefined) {
+    throw xsltError("XTSE3350", `Two accumulators are named ${duplicate}`);
+  }
+  return chosen;
+}
+
+/**
+ * Compiles the accumulators of a stylesheet into `cx.accumulators`, and
+ * the use-accumulators attributes of its modes and global context item.
+ * @param {(kind: string) => object[]} all - Declarations by kind
+ * @param {object} cx
+ */
+export function declareAccumulators(all, cx) {
+  const chosen = highestPrecedence(
+    all("accumulator").map((declaration) => ({
+      ...declaration,
+      key: clarkOf(
+        cx.exprs.qname(
+          required(declaration.element, "name"),
+          declaration.element,
+        ),
+      ),
+    })),
+  );
+  cx.accumulators = new Map();
+  for (const [key, { element }] of chosen) {
+    cx.accumulators.set(key, compileAccumulator(element, cx, key));
+  }
+  declareModeAccumulators(all("mode"), cx);
+  const contextItem = all("global-context-item")[0]?.element;
+  const text = contextItem && attr(contextItem, "use-accumulators");
+  cx.globalAccumulators =
+    typeof text === "string" ? useAccumulators(text, contextItem, cx) : "all";
+}

package/src/xslt/compiler/attributeValues.js

@@ -0,0 +1,174 @@
+/**
+ * The values of the enumerated attributes of XSLT elements (XSLT 3.0
+ * section 3.5, XTSE0020): yes/no attributes (also true/false/1/0, with
+ * whitespace trimmed) and attributes with a fixed list of values;
+ * validation="strict" needs a schema-aware processor
+ * (XTSE1660).
+ *
+ * @module @tradik/xslt3/xslt/compiler/attributeValues
+ */
+
+import { attr, xsltError } from "../names.js";
+
+const BOOLEAN = ["yes", "no", "true", "false", "1", "0"];
+const DECIMAL = /^[+-]?(\d+(\.\d*)?|\.\d+)$/;
+const INTEGERS = /^[+-]?\d+(\s+[+-]?\d+)*$/;
+const VALIDATION = ["strict", "lax", "preserve", "strip"];
+
+/** Allowed values by element local name and attribute name. */
+const VALUES = {
+  "attribute-set": { streamable: BOOLEAN },
+  attribute: { validation: VALIDATION },
+  copy: {
+    "copy-namespaces": BOOLEAN,
+    "inherit-namespaces": BOOLEAN,
+    validation: VALIDATION,
+  },
+  "copy-of": {
+    "copy-accumulators": BOOLEAN,
+    "copy-namespaces": BOOLEAN,
+    validation: VALIDATION,
+  },
+  document: { validation: VALIDATION },
+  element: { "inherit-namespaces": BOOLEAN, validation: VALIDATION },
+  "for-each-group": { composite: BOOLEAN },
+  number: { "start-at": INTEGERS },
+  output: { "html-version": DECIMAL },
+  "result-document": { "html-version": DECIMAL },
+  sort: { stable: BOOLEAN },
+  function: {
+    override: BOOLEAN,
+    "override-extension-function": BOOLEAN,
+    "new-each-time": [...BOOLEAN, "maybe"],
+    cache: BOOLEAN,
+  },
+  key: { composite: BOOLEAN },
+  mode: {
+    streamable: BOOLEAN,
+    typed: [...BOOLEAN, "strict", "lax", "unspecified"],
+    "warning-on-no-match": BOOLEAN,
+    "warning-on-multiple-match": BOOLEAN,
+    "on-multiple-match": ["use-last", "fail"],
+  },
+  package: { "declared-modes": BOOLEAN },
+  param: { required: BOOLEAN, tunnel: BOOLEAN, static: BOOLEAN },
+  stylesheet: {
+    "input-type-annotations": ["preserve", "strip", "unspecified"],
+  },
+  text: { "disable-output-escaping": BOOLEAN },
+  try: { "rollback-output": BOOLEAN },
+  "value-of": { "disable-output-escaping": BOOLEAN },
+  variable: { static: BOOLEAN },
+  "with-param": { tunnel: BOOLEAN },
+};
+VALUES.transform = VALUES.stylesheet;
+
+/** Elements whose children are top-level declarations. */
+const TOP_LEVEL = new Set(["stylesheet", "transform", "package"]);
+
+/**
+ * Constraints that depend on where an element is or on another
+ * attribute: static only on global variables and parameters, function
+ * parameters neither tunnel nor optional, consistent override flags of
+ * xsl:function.
+ * @param {Element} element
+ */
+function checkPlacement(element) {
+  const yes = (name) =>
+    ["yes", "true", "1"].includes(attr(element, name)?.trim());
+  const parent = element.parentNode;
+  const local = element.localName;
+  const fail = (message) => {
+    throw xsltError("XTSE0020", message);
+  };
+  if (yes("static") && !TOP_LEVEL.has(parent?.localName)) {
+    fail(`A local xsl:${local} cannot be static`);
+  }
+  if (
+    yes("static") &&
+    !["private", undefined].includes(attr(element, "visibility")?.trim())
+  ) {
+    fail("A static variable is private");
+  }
+  if (local === "param" && parent?.localName === "function") {
+    if (yes("tunnel")) {
+      fail("A function parameter cannot be a tunnel parameter");
+    }
+    if (attr(element, "required") !== undefined && !yes("required")) {
+      fail("A function parameter is always required");
+    }
+  }
+  const override = attr(element, "override");
+  const extension = attr(element, "override-extension-function");
+  if (
+    override !== undefined &&
+    extension !== undefined &&
+    yes("override") !== yes("override-extension-function")
+  ) {
+    fail("override and override-extension-function differ");
+  }
+}
+
+/**
+ * XTSE1660: what only a schema-aware processor accepts: a type
+ * attribute, strict validation, typed modes.
+ * @param {Element} element
+ */
+function checkSchemaAware(element) {
+  const defaultValidation = attr(element, "default-validation")?.trim();
+  if (defaultValidation === "strict") {
+    throw xsltError("XTSE1660", "default-validation=strict needs a schema");
+  }
+  if (
+    defaultValidation !== undefined &&
+    defaultValidation !== "preserve" &&
+    defaultValidation !== "strip"
+  ) {
+    throw xsltError(
+      "XTSE0020",
+      `Invalid default-validation ${defaultValidation}`,
+    );
+  }
+  if (
+    VALUES[element.localName]?.validation &&
+    attr(element, "type") !== undefined
+  ) {
+    throw xsltError("XTSE1660", "The type attribute needs a schema");
+  }
+  if (
+    element.localName === "mode" &&
+    ["yes", "true", "1", "strict"].includes(attr(element, "typed")?.trim())
+  ) {
+    throw xsltError("XTSE1660", "A typed mode needs a schema");
+  }
+}
+
+/**
+ * Checks the enumerated attributes of an XSLT element.
+ * @param {Element} element
+ * @throws {import("../../errors.js").XPathError} XTSE0020 for a value
+ *   not allowed, XTSE1660 for validation that needs a schema
+ */
+export function checkAttributeValues(element) {
+  const table = VALUES[element.localName];
+  for (const [name, allowed] of Object.entries(table ?? {})) {
+    const value = attr(element, name)?.trim();
+    // attribute value templates are checked when evaluated
+    if (value === undefined || value.includes("{")) continue;
+    const ok = Array.isArray(allowed)
+      ? allowed.includes(value)
+      : allowed.test(value);
+    if (!ok) {
+      throw xsltError(
+        "XTSE0020",
+        `Invalid value "${value}" for ${name} on xsl:${element.localName}`,
+      );
+    }
+    // XSLT 3.0: lax validation without a schema is allowed
+    if (name === "validation" && value === "strict") {
+      throw xsltError("XTSE1660", `validation="${value}" needs a schema`);
+    }
+  }
+  checkPlacement(element);
+  checkSchemaAware(element);
+}

package/src/xslt/compiler/attributes.js

@@ -0,0 +1,211 @@
+/**
+ * The attributes each XSLT element may have (XSLT 3.0 section 3.5,
+ * XTSE0090) and helpers to read them: required attributes (XTSE0010),
+ * yes/no values (XTSE0020).
+ *
+ * @module @tradik/xslt3/xslt/compiler/attributes
+ */
+
+import { attr, XSL_NS, xsltError } from "../names.js";
+import { checkAttributeValues } from "./attributeValues.js";
+import { infoOf } from "./elementInfo.js";
+
+/** Standard attributes, allowed on every XSLT element. */
+const STANDARD = new Set([
+  "version",
+  "exclude-result-prefixes",
+  "extension-element-prefixes",
+  "xpath-default-namespace",
+  "default-collation",
+  "use-when",
+  "default-mode",
+  "default-validation",
+  "expand-text",
+]);
+
+const SERIALIZATION =
+  "allow-duplicate-names build-tree byte-order-mark cdata-section-elements " +
+  "doctype-public doctype-system encoding escape-uri-attributes " +
+  "html-version include-content-type indent item-separator json-node-output-method " +
+  "media-type method normalization-form omit-xml-declaration parameter-document " +
+  "standalone suppress-indentation undeclare-prefixes use-character-maps";
+
+/** Attributes by element local name. */
+const ALLOWED = {
+  "analyze-string": "select regex flags",
+  "apply-imports": "",
+  "apply-templates": "select mode",
+  attribute: "name namespace select separator type validation",
+  "attribute-set": "name use-attribute-sets visibility streamable",
+  "call-template": "name",
+  "character-map": "name use-character-maps",
+  choose: "",
+  comment: "select",
+  copy: "select copy-namespaces inherit-namespaces use-attribute-sets type validation",
+  "copy-of": "select copy-accumulators copy-namespaces type validation",
+  "decimal-format":
+    "name decimal-separator grouping-separator infinity minus-sign exponent-separator NaN percent per-mille zero-digit digit pattern-separator",
+  document: "validation type",
+  element:
+    "name namespace inherit-namespaces use-attribute-sets type validation",
+  fallback: "",
+  "for-each": "select",
+  "for-each-group":
+    "select group-by group-adjacent group-starting-with group-ending-with composite collation",
+  function:
+    "name as visibility streamability override-extension-function override new-each-time cache",
+  if: "test",
+  import: "href",
+  "import-schema": "namespace schema-location",
+  include: "href",
+  key: "name match use composite collation",
+  "matching-substring": "",
+  map: "",
+  "map-entry": "key select",
+  try: "select rollback-output",
+  catch: "errors select",
+  "context-item": "as use",
+  "global-context-item": "as use use-accumulators",
+  message: "select terminate error-code",
+  "namespace-alias": "stylesheet-prefix result-prefix",
+  namespace: "name select",
+  "next-match": "",
+  "non-matching-substring": "",
+  number:
+    "value select level count from format lang letter-value ordinal start-at grouping-separator grouping-size",
+  otherwise: "",
+  output: `name ${SERIALIZATION}`,
+  "output-character": "character string",
+  param: "name select as required tunnel static",
+  "perform-sort": "select",
+  "preserve-space": "elements",
+  "processing-instruction": "name select",
+  "result-document": `format href type validation output-version ${SERIALIZATION}`,
+  sequence: "select",
+  sort: "select lang order collation stable case-order data-type",
+  "strip-space": "elements",
+  stylesheet: "id input-type-annotations",
+  template: "match name priority mode as visibility",
+  text: "disable-output-escaping",
+  transform: "id input-type-annotations",
+  "value-of": "select separator disable-output-escaping",
+  variable: "name select as visibility static",
+  when: "test",
+  "with-param": "name select as tunnel",
+  // XSLT 3.0 instructions of task 0031
+  break: "select",
+  iterate: "select",
+  "next-iteration": "",
+  "on-completion": "select",
+  "on-empty": "select",
+  "on-non-empty": "select",
+  "where-populated": "",
+  fork: "",
+  accumulator: "name initial-value as streamable",
+  "accumulator-rule": "match phase select",
+  "source-document": "href streamable use-accumulators validation type",
+  assert: "test select error-code",
+  evaluate:
+    "xpath as base-uri with-params context-item namespace-context schema-aware",
+  merge: "",
+  "merge-action": "",
+  "merge-key": "select lang order collation case-order data-type",
+  "merge-source":
+    "name for-each-item for-each-source select streamable use-accumulators sort-before-merge validation type",
+  package: "id name package-version input-type-annotations declared-modes",
+  "use-package": "name package-version",
+  expose: "component names visibility",
+  accept: "component names visibility",
+  override: "",
+  mode: "name streamable use-accumulators on-no-match on-multiple-match warning-on-no-match warning-on-multiple-match typed visibility",
+};
+
+/** @type {Map<string, Set<string>>} */
+const allowedSets = new Map(
+  Object.entries(ALLOWED).map(([name, list]) => [
+    name,
+    new Set(list.split(" ").filter(Boolean)),
+  ]),
+);
+
+/**
+ * Checks the attributes of an XSLT element (unknown attributes are
+ * ignored in forwards-compatible mode).
+ * @param {Element} element
+ * @param {object} [_cx] - Stylesheet compiler (unused)
+ * @throws {import("../../errors.js").XPathError} XTSE0090
+ */
+export function checkAttributes(element, _cx) {
+  const allowed = allowedSets.get(element.localName);
+  if (!allowed) return;
+  const forwards = infoOf(element).version > 3;
+  for (const attribute of element.attributes) {
+    const uri = attribute.namespaceURI;
+    const written = attribute.localName ?? attribute.name;
+    // a shadow attribute _name stands for the attribute name
+    const name = written.startsWith("_") ? written.slice(1) : written;
+    if (uri === XSL_NS) {
+      throw xsltError(
+        "XTSE0090",
+        `xsl:${element.localName} cannot have the attribute ${attribute.name}`,
+      );
+    }
+    if (uri || attribute.name.startsWith("xmlns")) continue;
+    if (allowed.has(name) || STANDARD.has(name) || forwards) continue;
+    throw xsltError(
+      "XTSE0090",
+      `xsl:${element.localName} cannot have the attribute ${name}`,
+    );
+  }
+  if (!forwards) checkAttributeValues(element);
+}
+
+/**
+ * Checks that an element that must be empty is.
+ * @param {Element} element
+ * @param {{children: (element: Element) => Array}} cx
+ * @throws {import("../../errors.js").XPathError} XTSE0260
+ */
+export function checkEmpty(element, cx) {
+  if (cx.children(element).length > 0) {
+    throw xsltError("XTSE0260", `xsl:${element.localName} must be empty`);
+  }
+}
+
+/**
+ * A required attribute.
+ * @param {Element} element
+ * @param {string} name
+ * @returns {string}
+ * @throws {import("../../errors.js").XPathError} XTSE0010 when absent
+ */
+export function required(element, name) {
+  const value = attr(element, name);
+  if (value === undefined) {
+    throw xsltError(
+      "XTSE0010",
+      `xsl:${element.localName} requires the attribute ${name}`,
+    );
+  }
+  return value;
+}
+
+/**
+ * A yes/no attribute (also true/false/1/0 in XSLT 3.0).
+ * @param {Element} element
+ * @param {string} name
+ * @param {boolean} fallback - Value when absent
+ * @returns {boolean}
+ * @throws {import("../../errors.js").XPathError} XTSE0020 for other values
+ */
+export function yesNo(element, name, fallback) {
+  const value = attr(element, name);
+  if (value === undefined) return fallback;
+  const text = value.trim();
+  if (["yes", "true", "1"].includes(text)) return true;
+  if (["no", "false", "0"].includes(text)) return false;
+  throw xsltError(
+    "XTSE0020",
+    `Invalid value "${value}" for ${name} on xsl:${element.localName}`,
+  );
+}

package/src/xslt/compiler/avt.js

@@ -0,0 +1,103 @@
+/**
+ * Attribute value templates (XSLT 3.0 section 5.6.1): literal text with
+ * XPath expressions in curly brackets, `{{` and `}}` standing for single
+ * brackets. Also used for text value templates.
+ *
+ * @module @tradik/xslt3/xslt/compiler/avt
+ */
+
+import { xsltError } from "../names.js";
+
+/**
+ * Finds the end of an expression in curly brackets, skipping string
+ * literals, comments and nested brackets (map constructors).
+ * @param {string} text
+ * @param {number} start - Offset after the opening bracket
+ * @returns {number} offset of the closing bracket
+ * @throws {import("../../errors.js").XPathError} XTSE0350 when unclosed
+ */
+function closingBracket(text, start) {
+  let depth = 0;
+  let i = start;
+  while (i < text.length) {
+    const c = text[i];
+    if (c === "'" || c === '"') {
+      const end = text.indexOf(c, i + 1);
+      if (end < 0) break;
+      i = end + 1;
+      continue;
+    }
+    if (c === "(" && text[i + 1] === ":") {
+      let level = 0;
+      while (i < text.length) {
+        if (text.startsWith("(:", i)) (level++, (i += 2));
+        else if (text.startsWith(":)", i)) {
+          i += 2;
+          if (--level === 0) break;
+        } else i++;
+      }
+      continue;
+    }
+    if (c === "{") depth++;
+    else if (c === "}") {
+      if (depth === 0) return i;
+      depth--;
+    }
+    i++;
+  }
+  throw xsltError("XTSE0350", `Unclosed expression in "${text}"`);
+}
+
+/**
+ * Removes the XPath comments (which nest) from a text.
+ * @param {string} text
+ * @returns {string}
+ */
+export function withoutComments(text) {
+  let result = text;
+  for (let previous = ""; previous !== result;) {
+    previous = result;
+    result = result.replace(/\(:(?:(?!\(:|:\))[^])*:\)/g, "");
+  }
+  return result;
+}
+
+/**
+ * Splits an attribute value template.
+ * @param {string} text
+ * @returns {Array<string|{expr: string}>} literal parts and expressions
+ * @throws {import("../../errors.js").XPathError} XTSE0350 for an unclosed
+ *   expression, XTSE0370 for a lone closing bracket
+ */
+export function parseAvt(text) {
+  const parts = [];
+  let literal = "";
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i];
+    if (c === "{" && text[i + 1] === "{") {
+      literal += "{";
+      i += 2;
+    } else if (c === "}" && text[i + 1] === "}") {
+      literal += "}";
+      i += 2;
+    } else if (c === "}") {
+      throw xsltError("XTSE0370", `Unescaped "}" in "${text}"`);
+    } else if (c === "{") {
+      const end = closingBracket(text, i + 1);
+      const expr = text.slice(i + 1, end);
+      // an empty expression (or only comments) stands for ""
+      if (withoutComments(expr).trim() !== "") {
+        if (literal) parts.push(literal);
+        literal = "";
+        parts.push({ expr });
+      }
+      i = end + 1;
+    } else {
+      literal += c;
+      i++;
+    }
+  }
+  if (literal || parts.length === 0) parts.push(literal);
+  return parts;
+}