@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/compiler/visibility.js

@@ -0,0 +1,160 @@
+/**
+ * xsl:expose and xsl:accept (XSLT 3.0 sections 3.5.3.1 and 3.5.3.2): the
+ * rules that give components their visibility, chosen by how precisely
+ * a token of `names` matches a component (an explicit name beats a
+ * namespace or local-name wildcard, which beats `*`; the last such rule
+ * in document order wins).
+ *
+ * @module @tradik/xslt3/xslt/compiler/visibility
+ */
+
+import { attr, resolveQName, tokens, xsltError } from "../names.js";
+import { required } from "./attributes.js";
+import { infoOf } from "./elementInfo.js";
+
+/** Component kinds that xsl:expose and xsl:accept name. */
+const KINDS = new Set([
+  "template",
+  "function",
+  "attribute-set",
+  "variable",
+  "mode",
+]);
+
+/** How precisely a token matches: higher wins. */
+export const EXPLICIT = 3;
+const PARTIAL = 2;
+const ANY = 1;
+
+/**
+ * Parses a token of a names attribute.
+ * @param {string} token
+ * @param {Element} element
+ * @returns {object} `{precision, uri, local, arity}` (null for wildcards)
+ */
+function parseToken(token, element) {
+  const namespaces = infoOf(element).namespaces;
+  if (token === "*") return { precision: ANY };
+  if (token.startsWith("*:")) {
+    return { precision: PARTIAL, uri: null, local: token.slice(2) };
+  }
+  const eqWildcard = /^Q\{([^{}]*)\}\*$/.exec(token);
+  if (eqWildcard) {
+    return { precision: PARTIAL, uri: eqWildcard[1], local: null };
+  }
+  if (token.endsWith(":*")) {
+    const { uri } = resolveQName(`${token.slice(0, -2)}:x`, namespaces, {
+      code: "XTSE0020",
+    });
+    return { precision: PARTIAL, uri, local: null };
+  }
+  const hash = token.lastIndexOf("#");
+  const arity = hash < 0 ? null : token.slice(hash + 1);
+  if (arity !== null && !/^\d+$/.test(arity)) {
+    throw xsltError("XTSE0020", `Invalid name ${token}`);
+  }
+  const name = resolveQName(
+    hash < 0 ? token : token.slice(0, hash),
+    namespaces,
+    { code: "XTSE0020" },
+  );
+  return {
+    precision: EXPLICIT,
+    uri: name.uri,
+    local: name.local,
+    arity: arity === null ? null : Number(arity),
+  };
+}
+
+/**
+ * Parses xsl:expose or xsl:accept elements.
+ * @param {Element[]} elements - In document order
+ * @param {object} cx - Stylesheet compiler
+ * @param {object} options
+ * @param {Set<string>} options.allowed - Allowed visibility values
+ * @param {string} options.anyCode - Error of component="*" with a
+ *   non-wildcard name (XTSE3022, XTSE3032)
+ * @returns {object[]} rules `{kind, visibility, tokens, element}`
+ */
+export function parseVisibilityRules(elements, cx, { allowed, anyCode }) {
+  return elements.map((element) => {
+    if (cx.children(element).length > 0) {
+      throw xsltError("XTSE0260", `xsl:${element.localName} must be empty`);
+    }
+    const kind = required(element, "component").trim();
+    if (kind !== "*" && !KINDS.has(kind)) {
+      throw xsltError("XTSE0020", `Invalid component ${kind}`);
+    }
+    const visibility = required(element, "visibility").trim();
+    if (!allowed.has(visibility)) {
+      throw xsltError("XTSE0020", `Invalid visibility ${visibility}`);
+    }
+    const parsed = tokens(required(element, "names")).map((token) =>
+      parseToken(token, element),
+    );
+    if (kind === "*" && parsed.some((t) => t.precision === EXPLICIT)) {
+      throw xsltError(anyCode, 'component="*" needs wildcard names');
+    }
+    return { kind, visibility, tokens: parsed, element };
+  });
+}
+
+/**
+ * How precisely a token matches a component.
+ * @param {object} token
+ * @param {object} component - `{kind, uri, local, arity}`
+ * @returns {number} 0 when it does not match
+ */
+function tokenMatch(token, component) {
+  if (token.precision === ANY) return ANY;
+  if (token.precision === PARTIAL) {
+    const matches =
+      token.uri === null
+        ? token.local === component.local
+        : token.uri === component.uri;
+    return matches ? PARTIAL : 0;
+  }
+  if (token.uri !== component.uri || token.local !== component.local) return 0;
+  if (token.arity !== null && component.kind !== "function") return 0;
+  // a function is named with its arity
+  if (component.kind === "function") {
+    return token.arity === component.arity ? EXPLICIT : 0;
+  }
+  return EXPLICIT;
+}
+
+/**
+ * The matches of the rules for a component, best first.
+ * @param {object[]} rules
+ * @param {object} component
+ * @returns {Array<{rule: object, token: object, precision: number}>}
+ */
+export function matchesOf(rules, component) {
+  const found = [];
+  rules.forEach((rule, order) => {
+    if (rule.kind !== "*" && rule.kind !== component.kind) return;
+    for (const token of rule.tokens) {
+      const precision = tokenMatch(token, component);
+      if (precision > 0) {
+        token.used = true;
+        found.push({ rule, token, precision, order });
+      }
+    }
+  });
+  return found.sort((a, b) => b.precision - a.precision || b.order - a.order);
+}
+
+/**
+ * Checks that every explicit token matched a component.
+ * @param {object[]} rules
+ * @param {string} code - XTSE3020 (expose) or XTSE3030 (accept)
+ */
+export function checkUnmatched(rules, code) {
+  for (const rule of rules) {
+    for (const token of rule.tokens) {
+      if (token.precision === EXPLICIT && !token.used) {
+        throw xsltError(code, `${attr(rule.element, "names")} matches nothing`);
+      }
+    }
+  }
+}

package/src/xslt/index.js

@@ -0,0 +1,11 @@
+/**
+ * XSLT 3.0 and 2.0 (and 1.0 in backwards-compatible mode): the public
+ * API of the transformation engine.
+ *
+ * @module @tradik/xslt3/xslt
+ */
+
+export { CompiledStylesheet, compileStylesheet } from "./api.js";
+export { XSLTProcessor } from "./processor.js";
+export { versionMatches } from "./compiler/packageVersions.js";
+export { untypedAtomic } from "./runtime/params.js";

package/src/xslt/instructions/analyzeString.js

@@ -0,0 +1,137 @@
+/**
+ * xsl:analyze-string (XSLT 3.0 section 17.1): the matching and
+ * non-matching substrings of a string, each processed with the substring
+ * as context item; regex-group() gives the captured groups.
+ *
+ * @module @tradik/xslt3/xslt/instructions/analyzeString
+ */
+
+import { allMatches, compileRegex } from "../../functions/regex/compile.js";
+import { stringItem } from "../../xpath/eval/atomics.js";
+import { atomize } from "../../xdm/nodes.js";
+import { canonicalString } from "../../xdm/lexical.js";
+import { compileBody } from "../compiler/body.js";
+import { checkAttributes, required } from "../compiler/attributes.js";
+import { derive, evaluate } from "../runtime/context.js";
+import { BodyFrame, LoopFrame } from "../runtime/machine.js";
+import { avtEvaluator } from "../runtime/values.js";
+import { attr, isXsl, xsltError } from "../names.js";
+
+/** Types accepted as the string of xsl:analyze-string. */
+const STRING_LIKE = new Set(["string", "untypedAtomic", "anyURI"]);
+
+/**
+ * Compiles the regular expression, mapping its errors to XSLT codes.
+ * @param {string} regex
+ * @param {string} flags
+ * @returns {object}
+ */
+function regexOf(regex, flags) {
+  let compiled;
+  try {
+    compiled = compileRegex(regex, flags);
+  } catch (error) {
+    const code = error.code === "FORX0001" ? "XTDE1145" : "XTDE1140";
+    throw xsltError(code, error.message);
+  }
+  compiled.regex.lastIndex = 0;
+  if (compiled.regex.test("")) {
+    throw xsltError("XTDE1150", 'The regular expression matches ""');
+  }
+  return compiled;
+}
+
+/**
+ * Splits a string into matching and non-matching substrings.
+ * @param {string} input
+ * @param {object} compiled
+ * @returns {Array<{text: string, groups: string[]|null}>}
+ */
+function segmentsOf(input, compiled) {
+  const segments = [];
+  let last = 0;
+  for (const match of allMatches(compiled, input)) {
+    if (match.index > last) {
+      segments.push({ text: input.slice(last, match.index), groups: null });
+    }
+    const groups = [];
+    for (let i = 0; i <= compiled.groups; i++) groups.push(match[i] ?? "");
+    segments.push({ text: match[0], groups });
+    last = match.index + match[0].length;
+  }
+  if (last < input.length) {
+    segments.push({ text: input.slice(last), groups: null });
+  }
+  return segments;
+}
+
+/**
+ * xsl:analyze-string.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileAnalyzeString(element, cx, scope) {
+  const select = cx.exprs.xpath(
+    required(element, "select"),
+    element,
+    scope.vars,
+  );
+  const regex = avtEvaluator(
+    cx.exprs.avt(required(element, "regex"), element, scope.vars),
+  );
+  const flagsText = attr(element, "flags");
+  const flags = flagsText
+    ? avtEvaluator(cx.exprs.avt(flagsText, element, scope.vars))
+    : () => "";
+  let matching = null;
+  let nonMatching = null;
+  let fallback = false;
+  for (const child of cx.children(element)) {
+    if (fallback && !isXsl(child, "fallback")) {
+      throw xsltError("XTSE0010", "xsl:fallback must come last");
+    }
+    if (isXsl(child, "matching-substring") && !matching && !nonMatching) {
+      checkAttributes(child);
+      matching = compileBody(child, cx, scope);
+    } else if (isXsl(child, "non-matching-substring") && !nonMatching) {
+      checkAttributes(child);
+      nonMatching = compileBody(child, cx, scope);
+    } else if (isXsl(child, "fallback")) fallback = true;
+    else throw xsltError("XTSE0010", "Invalid content of xsl:analyze-string");
+  }
+  if (!matching && !nonMatching) {
+    throw xsltError("XTSE1130", "xsl:analyze-string needs a substring child");
+  }
+  return (xc, out, machine) => {
+    const values = atomize(evaluate(select, xc));
+    if (values.length > 1) {
+      throw xsltError("XPTY0004", "xsl:analyze-string selects one string");
+    }
+    const primitive = values[0]?.type.primitive.localName;
+    if (values.length && !STRING_LIKE.has(primitive)) {
+      throw xsltError("XPTY0004", "xsl:analyze-string selects a string");
+    }
+    const input = values.length ? canonicalString(values[0]) : "";
+    const compiled = regexOf(regex(xc), flags(xc));
+    const segments = segmentsOf(input, compiled);
+    const size = segments.length;
+    if (size === 0) return;
+    const base = derive(xc, { rule: null });
+    machine.push(
+      new LoopFrame(size, (i) => {
+        const { text, groups } = segments[i];
+        const body = groups ? matching : nonMatching;
+        if (!body || body.length === 0) return;
+        const context = derive(base, {
+          item: stringItem(text),
+          position: i + 1,
+          size,
+          regex: groups ?? undefined,
+        });
+        machine.push(new BodyFrame(body, context, out));
+      }),
+    );
+  };
+}

package/src/xslt/instructions/assert.js

@@ -0,0 +1,72 @@
+/**
+ * xsl:assert (XSLT 3.0 section 23.2): when its test is false, or fails,
+ * the transformation fails as with xsl:message terminate="yes", with the
+ * error code of the error-code attribute (default XTMM9001). Assertions
+ * are checked unless the transform() option `assertions` is false.
+ *
+ * @module @tradik/xslt3/xslt/instructions/assert
+ */
+
+import { effectiveBooleanValue } from "../../xdm/nodes.js";
+import { required } from "../compiler/attributes.js";
+import { compileBody } from "../compiler/body.js";
+import { infoOf } from "../compiler/elementInfo.js";
+import { evaluate } from "../runtime/context.js";
+import { avtEvaluator, bodySequence } from "../runtime/values.js";
+import { attr, isXsl, resolveQName, xsltError } from "../names.js";
+
+/** Namespace of the standard error codes. */
+const ERR = "http://www.w3.org/2005/xqt-errors";
+
+/**
+ * Whether the test of an assertion holds; an error counts as false.
+ * @param {object} test
+ * @param {object} xc
+ * @returns {boolean}
+ */
+function holds(test, xc) {
+  try {
+    return effectiveBooleanValue(evaluate(test, xc));
+  } catch (error) {
+    if (typeof error?.code !== "string") throw error;
+    return false;
+  }
+}
+
+/**
+ * xsl:assert.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileAssert(element, cx, scope) {
+  const test = cx.exprs.xpath(required(element, "test"), element, scope.vars);
+  const selectText = attr(element, "select");
+  const select =
+    selectText === undefined
+      ? null
+      : cx.exprs.xpath(selectText, element, scope.vars);
+  const children = cx.children(element).filter((c) => !isXsl(c, "fallback"));
+  if (select && children.length > 0) {
+    throw xsltError("XTSE3185", "xsl:assert cannot have select and content");
+  }
+  const body = compileBody(element, cx, scope, children);
+  const codeText = attr(element, "error-code");
+  const errorCode = codeText
+    ? avtEvaluator(cx.exprs.avt(codeText, element, scope.vars))
+    : () => `Q{${ERR}}XTMM9001`;
+  const namespaces = infoOf(element).namespaces;
+  return (xc, out, machine) => {
+    if (!xc.tx.assertions || holds(test, xc)) return;
+    const value = select
+      ? evaluate(select, xc)
+      : bodySequence(body, xc, machine);
+    xc.tx.messages.push(value);
+    const name = resolveQName(errorCode(xc), namespaces, { code: "XTDE0030" });
+    const code = name.uri === ERR ? name.local : `Q{${name.uri}}${name.local}`;
+    const error = xsltError(code, "Assertion failed");
+    error.value = value;
+    throw error;
+  };
+}

package/src/xslt/instructions/attributeSets.js

@@ -0,0 +1,115 @@
+/**
+ * Attribute sets (XSLT 3.0 section 10.2): named groups of xsl:attribute
+ * instructions, applied by use-attribute-sets on literal result elements,
+ * xsl:element, xsl:copy and other attribute sets.
+ *
+ * @module @tradik/xslt3/xslt/instructions/attributeSets
+ */
+
+import { compileBody } from "../compiler/body.js";
+import { required } from "../compiler/attributes.js";
+import { derive } from "../runtime/context.js";
+import { clarkOf, isXsl, tokens, xsltError } from "../names.js";
+
+/**
+ * Resolves the names of a use-attribute-sets attribute; their existence
+ * is checked once the stylesheet is compiled (XTSE0710).
+ * @param {string|undefined} text
+ * @param {Element} element
+ * @param {object} cx - Stylesheet compiler
+ * @returns {string[]} Clark names
+ */
+export function attributeSetNames(text, element, cx) {
+  const names = tokens(text).map((token) => {
+    const name = clarkOf(cx.exprs.qname(token, element, { code: "XTSE0710" }));
+    return cx.originalName("attribute-set", name) ?? name;
+  });
+  for (const name of names) {
+    cx.deferred.push(() => {
+      if (!cx.attributeSets.has(name)) {
+        throw xsltError("XTSE0710", `No attribute set ${name}`);
+      }
+    });
+  }
+  return names;
+}
+
+/**
+ * Compiles an xsl:attribute-set declaration into the registry.
+ * @param {Element} element
+ * @param {object} cx
+ */
+export function declareAttributeSet(element, cx) {
+  const name = clarkOf(cx.exprs.qname(required(element, "name"), element));
+  const children = cx.children(element);
+  for (const child of children) {
+    if (child.nodeType !== 1 || !isXsl(child, "attribute")) {
+      throw xsltError(
+        "XTSE0010",
+        "An attribute set may only contain xsl:attribute",
+      );
+    }
+  }
+  const part = {
+    uses: attributeSetNames(
+      element.getAttribute("use-attribute-sets") || undefined,
+      element,
+      cx,
+    ),
+    body: compileBody(element, cx, cx.globalScope()),
+    precedence: cx.precedenceOf(element),
+    cx,
+  };
+  const parts = cx.attributeSets.get(name) ?? [];
+  parts.push(part);
+  parts.sort((a, b) => a.precedence - b.precedence);
+  cx.attributeSets.set(name, parts);
+}
+
+/**
+ * Adds the attributes of attribute sets to an element under construction.
+ * @param {string[]} names - Clark names
+ * @param {object} xc - XSLT context
+ * @param {object} out - Receiver of the element's content
+ * @param {import("../runtime/machine.js").Machine} machine
+ * @param {object} cx - Stylesheet compiler
+ * @param {Set<string>} [active] - Sets being applied (cycle detection)
+ * @param {boolean} [crossed] - The chain went through another package
+ */
+export function applyAttributeSets(
+  names,
+  xc,
+  out,
+  machine,
+  cx,
+  active,
+  crossed = false,
+) {
+  const applying = active ?? new Set();
+  const context = derive(xc, { env: xc.tx.globalEnv });
+  for (const name of names) {
+    if (applying.has(name)) {
+      // a cycle made by overriding in another package shows only when
+      // the components are bound: a dynamic error (XSLT 3.0 10.2)
+      throw xsltError(
+        crossed ? "XTDE0640" : "XTSE0720",
+        `The attribute set ${name} uses itself`,
+      );
+    }
+    applying.add(name);
+    for (const part of cx.attributeSets.get(name)) {
+      const across = crossed || part.cx !== cx;
+      applyAttributeSets(
+        part.uses,
+        xc,
+        out,
+        machine,
+        part.cx,
+        applying,
+        across,
+      );
+      machine.runBody(part.body, context, out);
+    }
+    applying.delete(name);
+  }
+}

package/src/xslt/instructions/conditional.js

@@ -0,0 +1,99 @@
+/**
+ * xsl:on-empty, xsl:on-non-empty and xsl:where-populated (XSLT 3.0
+ * section 8.4). The first two mark their step (`conditional`); the
+ * sequence constructor that holds them is run by
+ * runtime/conditional.js (see compileBody).
+ *
+ * @module @tradik/xslt3/xslt/instructions/conditional
+ */
+
+import { compileBody } from "../compiler/body.js";
+import { isWhitespaceText } from "../compiler/children.js";
+import { evaluate } from "../runtime/context.js";
+import { isDeemedEmpty, stepItems } from "../runtime/conditional.js";
+import { attr, isXsl, xsltError } from "../names.js";
+
+/**
+ * Compiles the content of xsl:on-empty or xsl:on-non-empty, which is
+ * that of xsl:sequence.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+function compileContent(element, cx, scope) {
+  const select = attr(element, "select");
+  const children = cx.children(element).filter((c) => !isXsl(c, "fallback"));
+  if (select === undefined) {
+    const body = compileBody(element, cx, scope, children);
+    return (xc, out, machine) => machine.runBody(body, xc, out);
+  }
+  if (children.length > 0) {
+    throw xsltError(
+      "XTSE3185",
+      `xsl:${element.localName} cannot have select and content`,
+    );
+  }
+  const expr = cx.exprs.xpath(select, element, scope.vars);
+  return (xc, out) => {
+    for (const item of evaluate(expr, xc)) out.item(item);
+  };
+}
+
+/**
+ * xsl:on-empty: the last instruction of its sequence constructor.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileOnEmpty(element, cx, scope) {
+  const siblings = cx.children(element.parentNode);
+  const after = siblings.slice(siblings.indexOf(element) + 1);
+  const misplaced = after.some(
+    (next) =>
+      !isWhitespaceText(next) &&
+      !isXsl(next, "fallback") &&
+      !isXsl(next, "catch"),
+  );
+  if (misplaced) {
+    throw xsltError(
+      "XTSE0010",
+      "xsl:on-empty must be the last instruction of a sequence constructor",
+    );
+  }
+  const step = compileContent(element, cx, scope);
+  step.conditional = "empty";
+  return step;
+}
+
+/**
+ * xsl:on-non-empty.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileOnNonEmpty(element, cx, scope) {
+  const step = compileContent(element, cx, scope);
+  step.conditional = "non-empty";
+  return step;
+}
+
+/**
+ * xsl:where-populated: the result of the content without the items
+ * deemed empty.
+ * @param {Element} element
+ * @param {object} cx
+ * @param {object} scope
+ * @returns {Function}
+ */
+export function compileWherePopulated(element, cx, scope) {
+  const body = compileBody(element, cx, scope);
+  const run = (xc, out, machine) => machine.runBody(body, xc, out);
+  return (xc, out, machine) => {
+    for (const item of stepItems(run, xc, machine)) {
+      if (!isDeemedEmpty(item)) out.item(item);
+    }
+  };
+}