xslt-processor 4.7.0 → 4.8.0

package/index.d.mts

@@ -278,6 +278,14 @@ declare class ExprContext {
      * Contains the key value of the current group being processed.
      */
     currentGroupingKey?: any;
+    /**
+     * User-defined XSLT functions from xsl:function declarations.
+     * Maps QName (namespace:localname) to function definition info.
+     */
+    userDefinedFunctions?: Map<string, {
+        functionDef: XNode;
+        executor: (context: ExprContext, functionDef: XNode, args: any[]) => any;
+    }>;
     /**
      * Constructor -- gets the node, its position, the node set it
      * belongs to, and a parent context as arguments. The parent context
@@ -790,6 +798,16 @@ declare class Xslt {
      * Keys are attribute set names, values are arrays of xsl:attribute nodes.
      */
     attributeSets: Map<string, XNode[]>;
+    /**
+     * Map of user-defined functions from xsl:function declarations.
+     * Keys are QNames (namespace:localname), values are the function definition nodes.
+     */
+    userDefinedFunctions: Map<string, XNode>;
+    /**
+     * Result documents created by xsl:result-document.
+     * Keys are the href URIs, values are the serialized output strings.
+     */
+    resultDocuments: Map<string, string>;
     /**
      * Stack of stylesheet metadata for tracking import hierarchy.
      * Used by apply-imports to find templates from imported stylesheets.
@@ -1343,6 +1361,74 @@ declare class Xslt {
      * Sets up the context with the current text and regex groups.
      */
     private processAnalyzeStringContent;
+    /**
+     * Implements `xsl:function` (XSLT 2.0).
+     *
+     * Declares a stylesheet function that can be called from XPath expressions.
+     * Functions are collected during stylesheet initialization and made available
+     * to the XPath evaluator.
+     *
+     * @param context The expression context.
+     * @param template The xsl:function element.
+     */
+    protected xsltFunction(context: ExprContext, template: XNode): void;
+    /**
+     * Execute a user-defined xsl:function.
+     * Called when a function from userDefinedFunctions is invoked from XPath.
+     *
+     * @param context The expression context.
+     * @param functionDef The xsl:function node.
+     * @param args The evaluated arguments passed to the function.
+     * @returns The result of the function execution.
+     */
+    protected executeUserDefinedFunction(context: ExprContext, functionDef: XNode, args: any[]): Promise<any>;
+    /**
+     * Synchronously execute a user-defined xsl:function.
+     * This is used when functions are called from XPath expressions.
+     * Limited to functions that don't require async operations in their body.
+     *
+     * @param context The expression context.
+     * @param functionDef The xsl:function node.
+     * @param args The evaluated arguments passed to the function.
+     * @returns The result of the function execution.
+     */
+    executeUserDefinedFunctionSync(context: ExprContext, functionDef: XNode, args: any[]): any;
+    /**
+     * Implements `xsl:result-document` (XSLT 2.0).
+     *
+     * Creates a secondary output document. The output is stored in the
+     * resultDocuments map, accessible via getResultDocuments().
+     *
+     * @param context The expression context.
+     * @param template The xsl:result-document element.
+     */
+    protected xsltResultDocument(context: ExprContext, template: XNode): Promise<void>;
+    /**
+     * Get all result documents created by xsl:result-document.
+     * @returns A map of href URIs to serialized output strings.
+     */
+    getResultDocuments(): Map<string, string>;
+    /**
+     * Implements `xsl:perform-sort` (XSLT 2.0).
+     *
+     * Sorts a sequence of items without iteration. The sorted sequence
+     * is available via xsl:sequence or other sequence-consuming instructions.
+     *
+     * @param context The expression context.
+     * @param template The xsl:perform-sort element.
+     * @param output The output node.
+     */
+    protected xsltPerformSort(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:namespace` (XSLT 2.0).
+     *
+     * Creates a namespace node in the result tree.
+     *
+     * @param context The expression context.
+     * @param template The xsl:namespace element.
+     * @param output The output node.
+     */
+    protected xsltNamespace(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
     /**
      * Evaluates a variable or parameter and set it in the current input
      * context. Implements `xsl:variable`, `xsl:param`, and `xsl:with-param`.
@@ -1454,6 +1540,19 @@ declare class Xslt {
      * @param stylesheetElement The stylesheet or transform element.
      */
     private collectAttributeSets;
+    /**
+     * Collect all user-defined function definitions from the stylesheet.
+     * Called at stylesheet initialization time.
+     * @param stylesheetElement The stylesheet or transform element.
+     * @param context The expression context.
+     */
+    private collectUserDefinedFunctions;
+    /**
+     * Register user-defined functions in the expression context.
+     * This makes them available to XPath expressions.
+     * @param context The expression context.
+     */
+    private registerUserDefinedFunctionsInContext;
     /**
      * Apply one or more attribute sets to an element.
      * Parses space-separated attribute set names and applies them.

package/index.d.ts

@@ -278,6 +278,14 @@ declare class ExprContext {
      * Contains the key value of the current group being processed.
      */
     currentGroupingKey?: any;
+    /**
+     * User-defined XSLT functions from xsl:function declarations.
+     * Maps QName (namespace:localname) to function definition info.
+     */
+    userDefinedFunctions?: Map<string, {
+        functionDef: XNode;
+        executor: (context: ExprContext, functionDef: XNode, args: any[]) => any;
+    }>;
     /**
      * Constructor -- gets the node, its position, the node set it
      * belongs to, and a parent context as arguments. The parent context
@@ -790,6 +798,16 @@ declare class Xslt {
      * Keys are attribute set names, values are arrays of xsl:attribute nodes.
      */
     attributeSets: Map<string, XNode[]>;
+    /**
+     * Map of user-defined functions from xsl:function declarations.
+     * Keys are QNames (namespace:localname), values are the function definition nodes.
+     */
+    userDefinedFunctions: Map<string, XNode>;
+    /**
+     * Result documents created by xsl:result-document.
+     * Keys are the href URIs, values are the serialized output strings.
+     */
+    resultDocuments: Map<string, string>;
     /**
      * Stack of stylesheet metadata for tracking import hierarchy.
      * Used by apply-imports to find templates from imported stylesheets.
@@ -1343,6 +1361,74 @@ declare class Xslt {
      * Sets up the context with the current text and regex groups.
      */
     private processAnalyzeStringContent;
+    /**
+     * Implements `xsl:function` (XSLT 2.0).
+     *
+     * Declares a stylesheet function that can be called from XPath expressions.
+     * Functions are collected during stylesheet initialization and made available
+     * to the XPath evaluator.
+     *
+     * @param context The expression context.
+     * @param template The xsl:function element.
+     */
+    protected xsltFunction(context: ExprContext, template: XNode): void;
+    /**
+     * Execute a user-defined xsl:function.
+     * Called when a function from userDefinedFunctions is invoked from XPath.
+     *
+     * @param context The expression context.
+     * @param functionDef The xsl:function node.
+     * @param args The evaluated arguments passed to the function.
+     * @returns The result of the function execution.
+     */
+    protected executeUserDefinedFunction(context: ExprContext, functionDef: XNode, args: any[]): Promise<any>;
+    /**
+     * Synchronously execute a user-defined xsl:function.
+     * This is used when functions are called from XPath expressions.
+     * Limited to functions that don't require async operations in their body.
+     *
+     * @param context The expression context.
+     * @param functionDef The xsl:function node.
+     * @param args The evaluated arguments passed to the function.
+     * @returns The result of the function execution.
+     */
+    executeUserDefinedFunctionSync(context: ExprContext, functionDef: XNode, args: any[]): any;
+    /**
+     * Implements `xsl:result-document` (XSLT 2.0).
+     *
+     * Creates a secondary output document. The output is stored in the
+     * resultDocuments map, accessible via getResultDocuments().
+     *
+     * @param context The expression context.
+     * @param template The xsl:result-document element.
+     */
+    protected xsltResultDocument(context: ExprContext, template: XNode): Promise<void>;
+    /**
+     * Get all result documents created by xsl:result-document.
+     * @returns A map of href URIs to serialized output strings.
+     */
+    getResultDocuments(): Map<string, string>;
+    /**
+     * Implements `xsl:perform-sort` (XSLT 2.0).
+     *
+     * Sorts a sequence of items without iteration. The sorted sequence
+     * is available via xsl:sequence or other sequence-consuming instructions.
+     *
+     * @param context The expression context.
+     * @param template The xsl:perform-sort element.
+     * @param output The output node.
+     */
+    protected xsltPerformSort(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:namespace` (XSLT 2.0).
+     *
+     * Creates a namespace node in the result tree.
+     *
+     * @param context The expression context.
+     * @param template The xsl:namespace element.
+     * @param output The output node.
+     */
+    protected xsltNamespace(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
     /**
      * Evaluates a variable or parameter and set it in the current input
      * context. Implements `xsl:variable`, `xsl:param`, and `xsl:with-param`.
@@ -1454,6 +1540,19 @@ declare class Xslt {
      * @param stylesheetElement The stylesheet or transform element.
      */
     private collectAttributeSets;
+    /**
+     * Collect all user-defined function definitions from the stylesheet.
+     * Called at stylesheet initialization time.
+     * @param stylesheetElement The stylesheet or transform element.
+     * @param context The expression context.
+     */
+    private collectUserDefinedFunctions;
+    /**
+     * Register user-defined functions in the expression context.
+     * This makes them available to XPath expressions.
+     * @param context The expression context.
+     */
+    private registerUserDefinedFunctionsInContext;
     /**
      * Apply one or more attribute sets to an element.
      * Parses space-separated attribute set names and applies them.

package/index.js

@@ -6402,10 +6402,13 @@ var init_function_call_expression = __esm({
         if (!this.name.includes(":")) {
           return void 0;
         }
-        const [, localName] = this.name.split(":");
+        const [prefix, localName] = this.name.split(":");
         if (!localName) {
           return void 0;
         }
+        if (prefix !== "xs") {
+          return void 0;
+        }
         return getAtomicType(localName);
       }
       castConstructorValue(constructorType, value) {
@@ -9211,9 +9214,18 @@ var XPath20Parser = class extends XPathBaseParser {
     return left;
   }
   parsePrimaryExpr() {
+    var _a, _b;
     if (this.check("RESERVED_WORD") && this.peek().lexeme === "if") {
       return this.parseIfExpr();
     }
+    if (this.check("DOLLAR")) {
+      this.advance();
+      if (!this.isNameToken()) {
+        throw new Error(`Expected variable name after $. Got: ${(_b = (_a = this.peek()) == null ? void 0 : _a.lexeme) != null ? _b : "EOF"}`);
+      }
+      const name = this.advance().lexeme;
+      return new XPathVariableReference(name);
+    }
     return super.parsePrimaryExpr();
   }
   parseInstanceOfExpr() {
@@ -11935,6 +11947,20 @@ var NodeConverter = class {
       }
       return "";
     };
+    let ctx = exprContext;
+    while (ctx) {
+      if (ctx.userDefinedFunctions) {
+        ctx.userDefinedFunctions.forEach((funcInfo, funcName) => {
+          if (!functions[funcName]) {
+            functions[funcName] = (_context, ...args) => {
+              return funcInfo.executor(exprContext, funcInfo.functionDef, args);
+            };
+          }
+        });
+        break;
+      }
+      ctx = ctx.parent;
+    }
     return functions;
   }
   /**
@@ -13702,6 +13728,8 @@ var Xslt = class {
     this.namespaceAliases = /* @__PURE__ */ new Map();
     this.supportedExtensions = /* @__PURE__ */ new Set(["http://www.w3.org/1999/XSL/Transform"]);
     this.attributeSets = /* @__PURE__ */ new Map();
+    this.userDefinedFunctions = /* @__PURE__ */ new Map();
+    this.resultDocuments = /* @__PURE__ */ new Map();
     this.decimalFormatSettings = {
       decimalSeparator: ".",
       groupingSeparator: ",",
@@ -13856,6 +13884,9 @@ var Xslt = class {
           case "for-each-group":
             yield this.xsltForEachGroup(context, template, output);
             break;
+          case "function":
+            this.xsltFunction(context, template);
+            break;
           case "iterate":
             yield this.xsltIterate(context, template, output);
             break;
@@ -13879,6 +13910,9 @@ var Xslt = class {
           case "message":
             yield this.xsltMessage(context, template);
             break;
+          case "namespace":
+            yield this.xsltNamespace(context, template, output);
+            break;
           case "namespace-alias":
             this.xsltNamespaceAlias(template);
             break;
@@ -13917,9 +13951,15 @@ var Xslt = class {
           case "preserve-space":
             this.xsltPreserveSpace(template);
             break;
+          case "perform-sort":
+            yield this.xsltPerformSort(context, template, output);
+            break;
           case "processing-instruction":
             yield this.xsltProcessingInstruction(context, template, output);
             break;
+          case "result-document":
+            yield this.xsltResultDocument(context, template);
+            break;
           case "sequence":
             yield this.xsltSequence(context, template, output);
             break;
@@ -15993,6 +16033,8 @@ var Xslt = class {
       };
       this.mapTemplatesFromStylesheet(template, mainStylesheetMetadata);
       this.collectAttributeSets(template);
+      this.collectUserDefinedFunctions(template, context);
+      this.registerUserDefinedFunctionsInContext(context);
       this.validateStylesheetAttributes(template, context);
       let importsDone = false;
       for (const child of template.childNodes) {
@@ -16296,6 +16338,237 @@ var Xslt = class {
       yield this.xsltChildNodes(childContext, template, output);
     });
   }
+  /**
+   * Implements `xsl:function` (XSLT 2.0).
+   * 
+   * Declares a stylesheet function that can be called from XPath expressions.
+   * Functions are collected during stylesheet initialization and made available
+   * to the XPath evaluator.
+   *
+   * @param context The expression context.
+   * @param template The xsl:function element.
+   */
+  xsltFunction(context, template) {
+    const name = xmlGetAttribute(template, "name");
+    const asAttr = xmlGetAttribute(template, "as");
+    const overrideAttr = xmlGetAttribute(template, "override");
+    if (!name) {
+      throw new Error('<xsl:function> requires a "name" attribute.');
+    }
+    if (!name.includes(":")) {
+      throw new Error(`<xsl:function> name "${name}" must be in a namespace (use a prefixed name like "my:functionName").`);
+    }
+    const override = overrideAttr === "yes" || overrideAttr === "true";
+    if (this.userDefinedFunctions.has(name) && !override) {
+      return;
+    }
+    this.userDefinedFunctions.set(name, template);
+  }
+  /**
+   * Execute a user-defined xsl:function.
+   * Called when a function from userDefinedFunctions is invoked from XPath.
+   *
+   * @param context The expression context.
+   * @param functionDef The xsl:function node.
+   * @param args The evaluated arguments passed to the function.
+   * @returns The result of the function execution.
+   */
+  executeUserDefinedFunction(context, functionDef, args) {
+    return __async(this, null, function* () {
+      return this.executeUserDefinedFunctionSync(context, functionDef, args);
+    });
+  }
+  /**
+   * Synchronously execute a user-defined xsl:function.
+   * This is used when functions are called from XPath expressions.
+   * Limited to functions that don't require async operations in their body.
+   *
+   * @param context The expression context.
+   * @param functionDef The xsl:function node.
+   * @param args The evaluated arguments passed to the function.
+   * @returns The result of the function execution.
+   */
+  executeUserDefinedFunctionSync(context, functionDef, args) {
+    const functionContext = context.clone();
+    functionContext.variables = __spreadValues({}, context.variables);
+    const params = [];
+    for (const child of functionDef.childNodes) {
+      if (child.nodeType === DOM_ELEMENT_NODE && this.isXsltElement(child, "param")) {
+        params.push(child);
+      }
+    }
+    for (let i = 0; i < params.length; i++) {
+      const paramName = xmlGetAttribute(params[i], "name");
+      if (paramName) {
+        if (i < args.length) {
+          const argValue = args[i];
+          if (argValue && typeof argValue === "object" && "stringValue" in argValue) {
+            functionContext.setVariable(paramName, argValue);
+          } else if (Array.isArray(argValue)) {
+            functionContext.setVariable(paramName, new NodeSetValue(argValue));
+          } else if (typeof argValue === "number") {
+            functionContext.setVariable(paramName, new NumberValue(argValue));
+          } else if (typeof argValue === "boolean") {
+            functionContext.setVariable(paramName, new BooleanValue(argValue));
+          } else {
+            functionContext.setVariable(paramName, new StringValue(String(argValue != null ? argValue : "")));
+          }
+        } else {
+          const selectExpr = xmlGetAttribute(params[i], "select");
+          if (selectExpr) {
+            const defaultValue = this.xPath.xPathEval(selectExpr, functionContext);
+            functionContext.setVariable(paramName, defaultValue);
+          } else {
+            functionContext.setVariable(paramName, new StringValue(""));
+          }
+        }
+      }
+    }
+    for (const child of functionDef.childNodes) {
+      if (child.nodeType === DOM_ELEMENT_NODE) {
+        if (this.isXsltElement(child, "sequence")) {
+          const select = xmlGetAttribute(child, "select");
+          if (select) {
+            const result = this.xPath.xPathEval(select, functionContext);
+            if (result.type === "number") {
+              return result.numberValue();
+            } else if (result.type === "boolean") {
+              return result.booleanValue();
+            } else if (result.type === "node-set") {
+              return result.nodeSetValue();
+            } else {
+              return result.stringValue();
+            }
+          }
+        } else if (this.isXsltElement(child, "value-of")) {
+          const select = xmlGetAttribute(child, "select");
+          if (select) {
+            return this.xPath.xPathEval(select, functionContext).stringValue();
+          }
+        }
+      }
+    }
+    return "";
+  }
+  /**
+   * Implements `xsl:result-document` (XSLT 2.0).
+   *
+   * Creates a secondary output document. The output is stored in the
+   * resultDocuments map, accessible via getResultDocuments().
+   *
+   * @param context The expression context.
+   * @param template The xsl:result-document element.
+   */
+  xsltResultDocument(context, template) {
+    return __async(this, null, function* () {
+      const hrefExpr = xmlGetAttribute(template, "href") || "";
+      const methodAttr = xmlGetAttribute(template, "method") || this.outputMethod || "xml";
+      const omitXmlDeclaration = xmlGetAttribute(template, "omit-xml-declaration") || this.outputOmitXmlDeclaration;
+      const href = this.xsltAttributeValue(hrefExpr, context);
+      if (!href) {
+        throw new Error('<xsl:result-document> requires a non-empty "href" attribute.');
+      }
+      if (this.resultDocuments.has(href)) {
+        throw new Error(`<xsl:result-document>: A document has already been created with href="${href}".`);
+      }
+      const resultDocument = new XDocument();
+      yield this.xsltChildNodes(context, template, resultDocument);
+      const serialized = xmlTransformedText(resultDocument, {
+        cData: this.options.cData,
+        escape: this.options.escape,
+        selfClosingTags: this.options.selfClosingTags,
+        outputMethod: methodAttr,
+        outputVersion: this.outputVersion,
+        itemSeparator: this.itemSeparator
+      });
+      this.resultDocuments.set(href, serialized);
+    });
+  }
+  /**
+   * Get all result documents created by xsl:result-document.
+   * @returns A map of href URIs to serialized output strings.
+   */
+  getResultDocuments() {
+    return this.resultDocuments;
+  }
+  /**
+   * Implements `xsl:perform-sort` (XSLT 2.0).
+   *
+   * Sorts a sequence of items without iteration. The sorted sequence
+   * is available via xsl:sequence or other sequence-consuming instructions.
+   *
+   * @param context The expression context.
+   * @param template The xsl:perform-sort element.
+   * @param output The output node.
+   */
+  xsltPerformSort(context, template, output) {
+    return __async(this, null, function* () {
+      const select = xmlGetAttribute(template, "select");
+      let items;
+      if (select) {
+        items = this.xPath.xPathEval(select, context).nodeSetValue();
+      } else {
+        const sequenceChildren = [];
+        for (const child of template.childNodes) {
+          if (child.nodeType === DOM_ELEMENT_NODE && !this.isXsltElement(child, "sort")) {
+            sequenceChildren.push(child);
+          }
+        }
+        const fragment = domCreateDocumentFragment(this.outputDocument);
+        for (const child of sequenceChildren) {
+          yield this.xsltProcessContext(context, child, fragment);
+        }
+        items = Array.from(fragment.childNodes);
+      }
+      if (items.length === 0) {
+        return;
+      }
+      const sortContext = context.clone(items);
+      this.xsltSort(sortContext, template);
+      const destinationNode = output || this.outputDocument;
+      for (const node of sortContext.nodeList) {
+        this.xsltCopyOf(destinationNode, node);
+      }
+    });
+  }
+  /**
+   * Implements `xsl:namespace` (XSLT 2.0).
+   *
+   * Creates a namespace node in the result tree.
+   *
+   * @param context The expression context.
+   * @param template The xsl:namespace element.
+   * @param output The output node.
+   */
+  xsltNamespace(context, template, output) {
+    return __async(this, null, function* () {
+      const nameExpr = xmlGetAttribute(template, "name");
+      const selectExpr = xmlGetAttribute(template, "select");
+      if (!nameExpr && nameExpr !== "") {
+        throw new Error('<xsl:namespace> requires a "name" attribute.');
+      }
+      const prefix = this.xsltAttributeValue(nameExpr, context);
+      let namespaceUri;
+      if (selectExpr) {
+        namespaceUri = this.xPath.xPathEval(selectExpr, context).stringValue();
+      } else {
+        const fragment = domCreateDocumentFragment(this.outputDocument);
+        yield this.xsltChildNodes(context, template, fragment);
+        namespaceUri = xmlValue(fragment);
+      }
+      if (!namespaceUri) {
+        throw new Error("<xsl:namespace> requires a non-empty namespace URI.");
+      }
+      const destinationNode = output || this.outputDocument;
+      if (destinationNode.nodeType === DOM_ELEMENT_NODE) {
+        if (prefix) {
+          domSetAttribute(destinationNode, `xmlns:${prefix}`, namespaceUri);
+        } else {
+          domSetAttribute(destinationNode, "xmlns", namespaceUri);
+        }
+      }
+    });
+  }
   /**
    * Evaluates a variable or parameter and set it in the current input
    * context. Implements `xsl:variable`, `xsl:param`, and `xsl:with-param`.
@@ -16652,6 +16925,39 @@ var Xslt = class {
       }
     }
   }
+  /**
+   * Collect all user-defined function definitions from the stylesheet.
+   * Called at stylesheet initialization time.
+   * @param stylesheetElement The stylesheet or transform element.
+   * @param context The expression context.
+   */
+  collectUserDefinedFunctions(stylesheetElement, context) {
+    for (const child of stylesheetElement.childNodes) {
+      if (child.nodeType === DOM_ELEMENT_NODE && this.isXsltElement(child, "function")) {
+        this.xsltFunction(context, child);
+      }
+    }
+  }
+  /**
+   * Register user-defined functions in the expression context.
+   * This makes them available to XPath expressions.
+   * @param context The expression context.
+   */
+  registerUserDefinedFunctionsInContext(context) {
+    if (this.userDefinedFunctions.size === 0) {
+      return;
+    }
+    const functionsMap = /* @__PURE__ */ new Map();
+    this.userDefinedFunctions.forEach((functionDef, name) => {
+      functionsMap.set(name, {
+        functionDef,
+        executor: (ctx, funcDef, args) => {
+          return this.executeUserDefinedFunctionSync(ctx, funcDef, args);
+        }
+      });
+    });
+    context.userDefinedFunctions = functionsMap;
+  }
   /**
    * Apply one or more attribute sets to an element.
    * Parses space-separated attribute set names and applies them.