@tradik/xslt-processor 1.0.3 → 1.3.0

package/src/xpath/tokenizer.js

@@ -82,6 +82,14 @@ const NODE_TYPES = new Set([
 
 const OPERATORS = new Set(["and", "or", "mod", "div"]);
 
+/** Token type of each OperatorName. */
+const OPERATOR_TOKEN_TYPES = Object.freeze({
+  and: TokenType.AND,
+  or: TokenType.OR,
+  mod: TokenType.MOD,
+  div: TokenType.DIV,
+});
+
 export class Token {
   constructor(type, value, position) {
     this.type = type;
@@ -145,6 +153,8 @@ export class XPathTokenizer {
     const lastToken = this.getLastToken();
     // No preceding token means we're at the start - not an operator context
     if (!lastToken) return false;
+    // The local part of a QName (`html:div`) is a name, never an operator
+    if (lastToken.type === TokenType.COLON) return false;
     // If preceding token is a "blocker", it's not an operator context
     if (OPERATOR_CONTEXT_BLOCKERS.has(lastToken.type)) return false;
     // Otherwise, it IS an operator context (after names, numbers, closing brackets, etc.)
@@ -296,9 +306,9 @@ export class XPathTokenizer {
       value += this.consume();
     }
 
-    // Decimal part (handles both 1.5 and .5 style numbers)
-    // For .5 style: entry condition ensures digit follows, so this branch handles it
-    if (this.peek() === "." && /[0-9]/.test(this.peek(1))) {
+    // Decimal part: Number ::= Digits ('.' Digits?)? | '.' Digits, so `5.`
+    // is a number too. A `..` after digits is left alone (never valid there).
+    if (this.peek() === "." && this.peek(1) !== ".") {
       value += this.consume(); // .
       while (
         this.position < this.expression.length &&
@@ -311,6 +321,20 @@ export class XPathTokenizer {
     return new Token(TokenType.NUMBER, parseFloat(value), startPos);
   }
 
+  /**
+   * Read an NCName and classify it using the XPath 1.0 lexical
+   * disambiguation rules (section 3.7), applied in the order the
+   * specification lists them:
+   *
+   * 1. After an operand (the preceding token is not `@`, `::`, `(`, `[`, `,`
+   *    or an operator) `and`, `or`, `div` and `mod` are OperatorNames, even
+   *    when a `(` follows, as in `(a) or (b)`.
+   * 2. A name followed by `(` is a NodeType or a FunctionName.
+   * 3. A name followed by `::` is an AxisName.
+   * 4. Anything else is a NameTest.
+   *
+   * @returns {Token} The classified token
+   */
   readName() {
     const startPos = this.position;
     let value = "";
@@ -322,35 +346,25 @@ export class XPathTokenizer {
       value += this.consume();
     }
 
-    // Check for axis name followed by ::
-    this.skipWhitespace();
-    if (AXIS_NAMES.has(value) && this.peek() === ":" && this.peek(1) === ":") {
-      return new Token(TokenType.AXIS, value, startPos);
+    if (OPERATORS.has(value) && this.isOperatorContext()) {
+      return new Token(OPERATOR_TOKEN_TYPES[value], value, startPos);
     }
 
-    // Check for function call (followed by '(')
     const savedPos = this.position;
     this.skipWhitespace();
+
     if (this.peek() === "(") {
-      // Check if it's a node type test
-      if (NODE_TYPES.has(value)) {
-        return new Token(TokenType.NODE_TYPE, value, startPos);
-      }
-      return new Token(TokenType.FUNCTION, value, startPos);
+      const type = NODE_TYPES.has(value)
+        ? TokenType.NODE_TYPE
+        : TokenType.FUNCTION;
+      return new Token(type, value, startPos);
     }
-    this.position = savedPos;
 
-    // Check for operators - only in operator context per XPath 1.0 disambiguation rules
-    if (OPERATORS.has(value) && this.isOperatorContext()) {
-      const opTokens = {
-        and: TokenType.AND,
-        or: TokenType.OR,
-        mod: TokenType.MOD,
-        div: TokenType.DIV,
-      };
-      return new Token(opTokens[value], value, startPos);
+    if (AXIS_NAMES.has(value) && this.peek() === ":" && this.peek(1) === ":") {
+      return new Token(TokenType.AXIS, value, startPos);
     }
 
+    this.position = savedPos;
     return new Token(TokenType.NAME, value, startPos);
   }
 

package/src/xslt/attributeSets.js

@@ -0,0 +1,95 @@
+/**
+ * Named attribute sets (XSLT 1.0 section 7.1.4).
+ *
+ * Every `xsl:attribute-set` declaration is kept: declarations with the same
+ * expanded name are merged into one set. Applying a set applies its
+ * declarations from the lowest import precedence to the highest (stylesheet
+ * order within one precedence), each one its `use-attribute-sets` first and
+ * then its own `xsl:attribute` children. A later attribute of the same name
+ * replaces an earlier one, so attributes of a higher import precedence win
+ * over imported ones and a declaration's own attributes win over the sets it
+ * uses, as in libxslt.
+ *
+ * @module xslt/attributeSets
+ */
+
+"use strict";
+
+import {
+  requireExpandedName,
+  requireExpandedNames,
+} from "./declarationNames.js";
+
+/**
+ * @typedef {Object} AttributeSetDeclaration
+ * @property {Element} node - The xsl:attribute-set element
+ * @property {string[]} uses - Expanded names of its use-attribute-sets
+ * @property {number} importPrecedence - Import precedence of its stylesheet
+ */
+
+/**
+ * Register an `xsl:attribute-set` declaration.
+ *
+ * @param {Object<string, AttributeSetDeclaration[]>} sets - Declarations by
+ *   expanded name; updated in place
+ * @param {Element} node - The xsl:attribute-set element
+ * @param {number} importPrecedence - Import precedence of its stylesheet
+ * @returns {void}
+ * @throws {Error} When the name or a used name is not a QName with a
+ *   declared prefix (libxslt rejects such a stylesheet)
+ */
+export function registerAttributeSet(sets, node, importPrecedence) {
+  const key = requireExpandedName(
+    node.getAttribute("name") ?? "",
+    node,
+    "xsl:attribute-set name",
+  );
+  const uses = requireExpandedNames(
+    node.getAttribute("use-attribute-sets"),
+    node,
+    "xsl:attribute-set use-attribute-sets",
+  );
+  const declarations = Object.hasOwn(sets, key) ? sets[key] : [];
+  declarations.push({ node, uses, importPrecedence });
+  // Stable sort: stylesheet order is kept within one import precedence
+  declarations.sort((a, b) => a.importPrecedence - b.importPrecedence);
+  sets[key] = declarations;
+}
+
+/**
+ * Apply attribute sets to a result element.
+ *
+ * @param {Object<string, AttributeSetDeclaration[]>} sets - Declarations by expanded name
+ * @param {string[]} keys - Expanded names of the sets to apply, in order
+ * @param {(node: Element) => void} applyDeclaration - Instantiates the
+ *   xsl:attribute children of one declaration
+ * @param {Set<string>} [active] - Sets being applied (recursion guard)
+ * @returns {void}
+ * @throws {Error} When a set uses itself, directly or indirectly (an error
+ *   in XSLT 1.0 section 7.1.4)
+ *
+ * @example
+ * applyAttributeSets(engine.attributeSets, ["common"], (node) =>
+ *   engine.processChildren(node, context, element));
+ */
+export function applyAttributeSets(
+  sets,
+  keys,
+  applyDeclaration,
+  active = new Set(),
+) {
+  for (const key of keys) {
+    if (!Object.hasOwn(sets, key)) continue;
+    if (active.has(key)) {
+      throw new Error(
+        `xsl:attribute-set ${key} uses itself (XSLT 1.0 section 7.1.4)`,
+      );
+    }
+    active.add(key);
+    for (const declaration of sets[key]) {
+      applyAttributeSets(sets, declaration.uses, applyDeclaration, active);
+      applyDeclaration(declaration.node);
+    }
+    active.delete(key);
+  }
+}

package/src/xslt/avt.js

@@ -0,0 +1,103 @@
+/**
+ * Attribute value templates (XSLT 1.0 section 7.6.2).
+ *
+ * An AVT is literal text with XPath expressions in curly braces. A brace
+ * inside a string literal of an expression is part of the literal, so the
+ * template is split with a small scanner that knows '...' and "..." literals;
+ * `{{` and `}}` outside expressions stand for single braces. A lone `}` in the
+ * literal text is an error in the recommendation; it is kept as a character
+ * instead, like browsers do. Parsed templates are cached per string.
+ *
+ * @module xslt/avt
+ */
+
+"use strict";
+
+/**
+ * @typedef {string | {expr: string}} AvtPart
+ * A literal text part, or an expression part.
+ */
+
+const cache = new Map();
+
+/**
+ * Find the `}` closing an expression that starts at `start`.
+ *
+ * @param {string} value - The whole template
+ * @param {number} start - Index just after the opening `{`
+ * @returns {number} Index of the closing `}`
+ * @throws {Error} When the expression is not closed
+ */
+function closingBrace(value, start) {
+  let quote = null;
+  for (let i = start; i < value.length; i++) {
+    const char = value[i];
+    if (quote) {
+      if (char === quote) quote = null;
+    } else if (char === "'" || char === '"') {
+      quote = char;
+    } else if (char === "}") {
+      return i;
+    }
+  }
+  throw new Error(`Unclosed expression in attribute value template: ${value}`);
+}
+
+/**
+ * Split an attribute value template into literal and expression parts.
+ *
+ * @param {string} value - The attribute value
+ * @returns {AvtPart[]} The parts, adjacent literals merged
+ * @throws {Error} When an expression is not closed
+ *
+ * @example
+ * parseAvt("a{@b}c"); // ["a", { expr: "@b" }, "c"]
+ */
+export function parseAvt(value) {
+  let parts = cache.get(value);
+  if (parts) return parts;
+
+  parts = [];
+  let text = "";
+  let i = 0;
+  while (i < value.length) {
+    const char = value[i];
+    if ((char === "{" || char === "}") && value[i + 1] === char) {
+      text += char;
+      i += 2;
+    } else if (char === "{") {
+      const end = closingBrace(value, i + 1);
+      if (text) parts.push(text);
+      text = "";
+      parts.push({ expr: value.slice(i + 1, end) });
+      i = end + 1;
+    } else {
+      text += char;
+      i++;
+    }
+  }
+  if (text) parts.push(text);
+
+  cache.set(value, parts);
+  return parts;
+}
+
+/**
+ * Evaluate an attribute value template.
+ *
+ * @param {string} value - The attribute value
+ * @param {(expr: string) => string} evaluate - Evaluates one expression to a string
+ * @returns {string} The resulting text
+ *
+ * @example
+ * evaluateAvt("{1+1}px", (e) => String(eval(e))); // "2px"
+ */
+export function evaluateAvt(value, evaluate) {
+  if (!value.includes("{") && !value.includes("}")) return value;
+
+  let result = "";
+  for (const part of parseAvt(value)) {
+    result += typeof part === "string" ? part : evaluate(part.expr);
+  }
+  return result;
+}

package/src/xslt/computedNames.js

@@ -0,0 +1,91 @@
+/**
+ * Validation of the names computed by `xsl:element` and `xsl:attribute`
+ * (XSLT 1.0 sections 7.1.2 and 7.1.3).
+ *
+ * The `name` attribute is an attribute value template, so its value is only
+ * known at run time. It must be a QName whose prefix (when there is no
+ * `namespace` attribute) is declared in scope on the instruction, and an
+ * attribute may not be called `xmlns` (nor use the `xmlns` prefix). Like
+ * libxslt, the processor recovers from these errors by reporting them and not
+ * creating the element (with its content) or the attribute.
+ *
+ * @module xslt/computedNames
+ */
+
+"use strict";
+
+import { isQName } from "./qname.js";
+import { attributeName, elementName, splitQName } from "./resultNamespaces.js";
+import { resolvePrefix } from "./stylesheetNamespaces.js";
+
+/**
+ * @typedef {object} ComputedName
+ * @property {{namespaceUri: (string|null), qname: string}} [name] - The
+ *   expanded name, when valid
+ * @property {string} [error] - Why no node can be created, when invalid
+ */
+
+/**
+ * Check the parts shared by element and attribute names.
+ *
+ * @param {string} kind - "element" or "attribute", used in messages
+ * @param {string} qname - The evaluated `name` attribute
+ * @param {string|null} namespace - The evaluated `namespace` attribute, null when absent
+ * @param {Object<string, string>} scope - Namespaces in scope on the instruction
+ * @returns {string|null} The error message, or null when the name is usable
+ */
+function nameError(kind, qname, namespace, scope) {
+  if (!isQName(qname)) {
+    return `xsl:${kind}: "${qname}" is not a valid ${kind} name (QName), the ${kind} is not created`;
+  }
+  const { prefix } = splitQName(qname);
+  if (namespace === null && prefix && !resolvePrefix(scope, prefix)) {
+    return `xsl:${kind}: undefined namespace prefix "${prefix}" in "${qname}", the ${kind} is not created`;
+  }
+  return null;
+}
+
+/**
+ * Resolve the name computed by `xsl:element`.
+ *
+ * @param {string} qname - The evaluated `name` attribute
+ * @param {string|null} namespace - The evaluated `namespace` attribute, null when absent
+ * @param {Object<string, string>} scope - Namespaces in scope on the instruction
+ * @returns {ComputedName} The expanded name, or the error to report
+ *
+ * @example
+ * computedElementName("p:e", null, { p: "urn:p" }).name;
+ * // { namespaceUri: "urn:p", qname: "p:e" }
+ * computedElementName("x{", null, {}).error; // 'xsl:element: "x{" is not ...'
+ */
+export function computedElementName(qname, namespace, scope) {
+  const error = nameError("element", qname, namespace, scope);
+  return error ? { error } : { name: elementName(qname, namespace, scope) };
+}
+
+/**
+ * Resolve the name computed by `xsl:attribute`; `xmlns` and `xmlns:*` are
+ * rejected because namespace declarations are not attributes.
+ *
+ * @param {string} qname - The evaluated `name` attribute
+ * @param {string|null} namespace - The evaluated `namespace` attribute, null when absent
+ * @param {Object<string, string>} scope - Namespaces in scope on the instruction
+ * @returns {ComputedName} The expanded name, or the error to report
+ *
+ * @example
+ * computedAttributeName("xmlns", null, {}).error;
+ * // 'xsl:attribute: "xmlns" cannot be used as an attribute name ...'
+ */
+export function computedAttributeName(qname, namespace, scope) {
+  // With a namespace attribute, the prefix of `xmlns:a` is only a hint and
+  // is replaced (libxslt REC/test-7.1.3)
+  const xmlnsName =
+    qname === "xmlns" || (namespace === null && qname.startsWith("xmlns:"));
+  if (xmlnsName) {
+    return {
+      error: `xsl:attribute: "${qname}" cannot be used as an attribute name (XSLT 1.0 section 7.1.3), the attribute is not created`,
+    };
+  }
+  const error = nameError("attribute", qname, namespace, scope);
+  return error ? { error } : { name: attributeName(qname, namespace, scope) };
+}

package/src/xslt/copying.js

@@ -0,0 +1,212 @@
+/**
+ * Copying source nodes to the result tree: `xsl:copy-of` (XSLT 1.0 section
+ * 11.3) and the node kinds of `xsl:copy` (section 7.5).
+ *
+ * Copies follow the XPath data model rather than the raw DOM: a run of
+ * adjacent Text/CDATA nodes is one text node (its first DOM node stands for
+ * the run), copying a root node copies its children, and copying an attribute
+ * or a namespace node adds it to the result element being built. Names keep their namespace and
+ * elements keep their namespace declarations.
+ *
+ * @module xslt/copying
+ */
+
+"use strict";
+
+import { childAxis } from "../xpath/axes.js";
+import { NAMESPACE_NODE, inScopeBindings } from "../xpath/namespaceNodes.js";
+import { copyNamespaceDeclarations } from "./resultNamespaces.js";
+import { XMLNS_NAMESPACE } from "./stylesheetNamespaces.js";
+
+/**
+ * Copy an attribute node onto a result element. A namespace declaration or a
+ * target that is not an element is ignored; so is an attribute added after
+ * the element got children (see {@link canAddAttribute}).
+ *
+ * @param {Attr} attribute - The source attribute
+ * @param {Node} target - The result node receiving it
+ * @param {(element: Node) => boolean} canAddAttribute - Guard for late attributes
+ * @returns {void}
+ */
+export function copyAttribute(attribute, target, canAddAttribute) {
+  if (attribute.namespaceURI === XMLNS_NAMESPACE) return;
+  if (!canAddAttribute(target)) return;
+  if (attribute.namespaceURI) {
+    target.setAttributeNS(
+      attribute.namespaceURI,
+      attribute.name,
+      attribute.value,
+    );
+  } else {
+    target.setAttribute(attribute.name, attribute.value);
+  }
+}
+
+/**
+ * Copy a namespace node onto a result element as a namespace declaration
+ * (XSLT 1.0 sections 7.5 and 11.3). As in libxslt, nothing is declared for
+ * the implicit `xml` binding, for a prefix the element's own name binds to
+ * another namespace, for a prefix the element already declares differently,
+ * or when the element already has children (see `canAddAttribute`).
+ *
+ * @param {import('../xpath/namespaceNodes.js').NamespaceNode} namespace - The namespace node
+ * @param {Node} target - The result node receiving it
+ * @param {(element: Node) => boolean} canAddNamespace - Guard for late nodes
+ * @returns {void}
+ *
+ * @example
+ * copyNamespaceNode(nsNode, resultElement, () => true); // xmlns:a="urn:a"
+ */
+export function copyNamespaceNode(namespace, target, canAddNamespace) {
+  const prefix = namespace.localName;
+  if (prefix === "xml" || !canAddNamespace(target)) return;
+  const uri = namespace.nodeValue;
+  if ((target.prefix ?? "") === prefix && (target.namespaceURI ?? "") !== uri) {
+    return;
+  }
+  const declared = target.getAttributeNS(XMLNS_NAMESPACE, prefix || "xmlns");
+  if (declared !== null && declared !== uri) return;
+  target.setAttributeNS(
+    XMLNS_NAMESPACE,
+    prefix ? `xmlns:${prefix}` : "xmlns",
+    uri,
+  );
+}
+
+/**
+ * Create a shallow copy of an element: same expanded name and prefix, and the
+ * same namespace declarations.
+ *
+ * @param {Element} element - The source element
+ * @param {Document} doc - The result document
+ * @returns {Element} The empty copy
+ */
+export function shallowCopyElement(element, doc) {
+  const copy = element.namespaceURI
+    ? doc.createElementNS(element.namespaceURI, element.nodeName)
+    : doc.createElement(element.nodeName);
+  copyNamespaceDeclarations(element, copy);
+  return copy;
+}
+
+/**
+ * Deep copy of a node that can be a child in the result tree.
+ *
+ * @param {Node} node - Element, text, CDATA, comment, PI or document fragment
+ * @param {Document} doc - The result document
+ * @param {(node: Node) => string} stringValue - XPath string value (text runs)
+ * @returns {Node|null} The copy, or null for nodes that cannot be children
+ *
+ * @example
+ * cloneNode(sourceElement, resultDocument, (n) => evaluator.getStringValue(n));
+ */
+export function cloneNode(node, doc, stringValue) {
+  switch (node.nodeType) {
+    case 1: {
+      const copy = shallowCopyElement(node, doc);
+      for (const attribute of node.attributes) {
+        copyAttribute(attribute, copy, () => true);
+      }
+      appendChildCopies(node, copy, doc, stringValue);
+      return copy;
+    }
+    case 3:
+    case 4:
+      return doc.createTextNode(stringValue(node));
+    case 7:
+      return doc.createProcessingInstruction(node.target, node.data);
+    case 8:
+      return doc.createComment(node.nodeValue);
+    case 11: {
+      const fragment = doc.createDocumentFragment();
+      appendChildCopies(node, fragment, doc, stringValue);
+      return fragment;
+    }
+    default:
+      return null;
+  }
+}
+
+/**
+ * Append deep copies of the (XPath) children of a node.
+ *
+ * @param {Node} node - The source parent
+ * @param {Node} target - The result parent
+ * @param {Document} doc - The result document
+ * @param {(node: Node) => string} stringValue - XPath string value
+ * @returns {void}
+ */
+function appendChildCopies(node, target, doc, stringValue) {
+  for (const child of childAxis(node)) {
+    const copy = cloneNode(child, doc, stringValue);
+    if (copy) target.appendChild(copy);
+  }
+}
+
+/**
+ * Declare on the copy of an element every namespace in scope on the source
+ * element that is not in scope on the result parent already: `xsl:copy-of`
+ * copies the namespace nodes of an element (XSLT 1.0 section 11.3), those
+ * declared on its ancestors included, as libxslt does for the top element of
+ * a copied tree (its descendants inherit them in the result).
+ *
+ * @param {Element} source - The copied source element
+ * @param {Element} copy - Its copy, not yet attached
+ * @param {Node} output - The result node receiving the copy
+ * @returns {void}
+ */
+function copyInScopeNamespaces(source, copy, output) {
+  const inOutput = (prefix, uri) =>
+    output.nodeType === 1 && output.lookupNamespaceURI(prefix || null) === uri;
+  for (const [prefix, uri] of inScopeBindings(source)) {
+    if (!inOutput(prefix, uri)) {
+      copyNamespaceNode(
+        { localName: prefix, nodeValue: uri },
+        copy,
+        () => true,
+      );
+    }
+  }
+}
+
+/**
+ * Copy the result of an `xsl:copy-of` select expression to the result tree.
+ *
+ * Node-sets are copied node by node (roots as their children, attributes onto
+ * the current result element); any other value is written as text.
+ *
+ * @param {*} value - The evaluated expression
+ * @param {Node} output - The result node receiving the copy
+ * @param {object} host - Engine services
+ * @param {Document} host.doc - The result document
+ * @param {(node: Node) => string} host.stringValue - XPath string value
+ * @param {(value: *) => string} host.toString - XPath string() conversion
+ * @param {(element: Node) => boolean} host.canAddAttribute - Guard for attributes
+ * @returns {void}
+ */
+export function copyOf(value, output, host) {
+  if (Array.isArray(value)) {
+    for (const item of value) copyOf(item, output, host);
+    return;
+  }
+
+  if (value === null || value === undefined) return;
+  if (!value.nodeType) {
+    const text = host.toString(value);
+    if (text) output.appendChild(host.doc.createTextNode(text));
+    return;
+  }
+
+  if (value.nodeType === 2) {
+    copyAttribute(value, output, host.canAddAttribute);
+  } else if (value.nodeType === NAMESPACE_NODE) {
+    copyNamespaceNode(value, output, host.canAddAttribute);
+  } else if (value.nodeType === 9 || value.nodeType === 11) {
+    // Children one by one: xmldom mishandles appending a DocumentFragment
+    appendChildCopies(value, output, host.doc, host.stringValue);
+  } else {
+    const copy = cloneNode(value, host.doc, host.stringValue);
+    if (value.nodeType === 1) copyInScopeNamespaces(value, copy, output);
+    if (copy) output.appendChild(copy);
+  }
+}

package/src/xslt/declarationNames.js

@@ -0,0 +1,80 @@
+/**
+ * Names of named stylesheet objects (XSLT 1.0 section 2.4).
+ *
+ * Named templates, attribute sets and decimal formats are named by QNames
+ * that are expanded with the namespace declarations in scope on the element
+ * carrying the name; the default namespace is not used for unprefixed names.
+ * Two names are the same when their expanded names are, whatever prefixes
+ * they use, so every table of such objects is keyed by the expanded name in
+ * Clark notation (`{uri}local`, or the bare local name in no namespace).
+ *
+ * @module xslt/declarationNames
+ */
+
+"use strict";
+
+import { isQName } from "./qname.js";
+import { splitQName } from "./resultNamespaces.js";
+import { inScopeNamespaces, resolvePrefix } from "./stylesheetNamespaces.js";
+import { expandedNameKey } from "./serializer/settings.js";
+
+/**
+ * Expand a QName-valued attribute of a stylesheet element.
+ *
+ * @param {string} qname - The QName, e.g. `p:format` or `common`
+ * @param {Element} element - The element in whose scope the prefix resolves
+ * @returns {{key: string}|{error: string}} The expanded name key, or why the
+ *   value is not a QName with a declared prefix
+ *
+ * @example
+ * // <xsl:decimal-format xmlns:p="urn:p" name="p:f"/>
+ * expandName("p:f", element); // { key: "{urn:p}f" }
+ * expandName("q:f", element); // { error: 'undeclared namespace prefix "q" in "q:f"' }
+ */
+export function expandName(qname, element) {
+  if (!isQName(qname)) return { error: `invalid QName "${qname}"` };
+  const { prefix, localName } = splitQName(qname);
+  if (!prefix) return { key: localName };
+  const namespaceUri = resolvePrefix(inScopeNamespaces(element), prefix);
+  if (!namespaceUri) {
+    return { error: `undeclared namespace prefix "${prefix}" in "${qname}"` };
+  }
+  return { key: expandedNameKey(namespaceUri, localName) };
+}
+
+/**
+ * Expand a QName that must be valid, failing with a message naming where it
+ * comes from.
+ *
+ * @param {string} qname - The QName
+ * @param {Element} element - The element in whose scope the prefix resolves
+ * @param {string} where - The attribute holding it, e.g. "xsl:template name"
+ * @returns {string} The expanded name key
+ * @throws {Error} When the value is not a QName or its prefix is undeclared
+ *
+ * @example
+ * requireExpandedName("p:t", templateElement, "xsl:template name"); // "{urn:p}t"
+ */
+export function requireExpandedName(qname, element, where) {
+  const expanded = expandName(qname, element);
+  if (expanded.error) throw new Error(`${where}: ${expanded.error}`);
+  return expanded.key;
+}
+
+/**
+ * Expand the whitespace separated QNames of an attribute such as
+ * `use-attribute-sets`.
+ *
+ * @param {string|null} value - The attribute value
+ * @param {Element} element - The element carrying the attribute
+ * @param {string} where - Attribute description for error messages
+ * @returns {string[]} The expanded name keys, in order
+ * @throws {Error} When one of the names is not a QName with a declared prefix
+ */
+export function requireExpandedNames(value, element, where) {
+  if (!value) return [];
+  return value
+    .split(/[ \t\r\n]+/)
+    .filter(Boolean)
+    .map((qname) => requireExpandedName(qname, element, where));
+}