xslt-processor 4.1.0 → 4.2.0

package/index.d.mts

@@ -581,6 +581,11 @@ declare class Xslt {
      * preserve-space takes precedence over strip-space for conflicting patterns.
      */
     preserveSpacePatterns: string[];
+    /**
+     * Namespace aliases from xsl:namespace-alias declarations.
+     * Maps stylesheet namespace prefixes to result namespace prefixes.
+     */
+    namespaceAliases: Map<string, string>;
     constructor(options?: Partial<XsltOptions>);
     /**
      * The exported entry point of the XSL-T processor.
@@ -705,6 +710,86 @@ declare class Xslt {
      * @param template The template.
      */
     protected xsltKey(context: ExprContext, template: XNode): void;
+    /**
+     * Implements `xsl:message`.
+     * Outputs a message to the console. If terminate="yes", throws an error to stop processing.
+     * @param context The Expression Context.
+     * @param template The `<xsl:message>` node.
+     */
+    protected xsltMessage(context: ExprContext, template: XNode): Promise<void>;
+    /**
+     * Implements `xsl:namespace-alias`.
+     * Declares that a namespace URI in the stylesheet should be replaced by a different
+     * namespace URI in the output.
+     * @param template The `<xsl:namespace-alias>` node.
+     */
+    protected xsltNamespaceAlias(template: XNode): void;
+    /**
+     * Implements `xsl:number`.
+     * Inserts a formatted number into the result tree.
+     * @param context The Expression Context.
+     * @param template The `<xsl:number>` node.
+     * @param output The output node.
+     */
+    protected xsltNumber(context: ExprContext, template: XNode, output?: XNode): void;
+    /**
+     * Counts nodes for xsl:number based on level, count, and from attributes.
+     * @param context The Expression Context.
+     * @param level The counting level: 'single', 'multiple', or 'any'.
+     * @param count Pattern to match nodes to count.
+     * @param from Pattern to start counting from.
+     * @returns The count value.
+     */
+    protected xsltNumberCount(context: ExprContext, level: string, count: string | null, from: string | null): number;
+    /**
+     * Checks if a node matches a simple name pattern.
+     * @param node The node to check.
+     * @param pattern The pattern (node name) to match.
+     * @returns True if the node matches.
+     */
+    protected nodeMatchesPattern(node: XNode, pattern: string): boolean;
+    /**
+     * Gets all nodes preceding the given node in document order.
+     * @param node The reference node.
+     * @returns Array of preceding nodes.
+     */
+    protected getAllPrecedingNodes(node: XNode): XNode[];
+    /**
+     * Collects all descendant nodes of a given node.
+     * @param node The parent node.
+     * @param result The array to collect into.
+     */
+    protected collectDescendants(node: XNode, result: XNode[]): void;
+    /**
+     * Formats a number according to the format string.
+     * @param number The number to format.
+     * @param format The format string (e.g., "1", "01", "a", "A", "i", "I").
+     * @param groupingSeparator Optional grouping separator.
+     * @param groupingSize Optional grouping size.
+     * @returns The formatted number string.
+     */
+    protected xsltFormatNumber(number: number, format: string, groupingSeparator: string | null, groupingSize: string | null): string;
+    /**
+     * Converts a number to alphabetic representation.
+     * @param number The number to convert.
+     * @param uppercase Whether to use uppercase letters.
+     * @returns The alphabetic representation.
+     */
+    protected numberToAlpha(number: number, uppercase: boolean): string;
+    /**
+     * Converts a number to Roman numeral representation.
+     * @param number The number to convert.
+     * @returns The Roman numeral string.
+     */
+    protected numberToRoman(number: number): string;
+    /**
+     * Applies grouping separators to a numeric string.
+     * @param numStr The numeric string.
+     * @param separator The grouping separator.
+     * @param size The grouping size.
+     * @returns The grouped string.
+     */
+    protected applyGrouping(numStr: string, separator: string, size: number): string;
     /**
      * Orders the current node list in the input context according to the
      * sort order specified by xsl:sort child nodes of the current

package/index.d.ts

@@ -581,6 +581,11 @@ declare class Xslt {
      * preserve-space takes precedence over strip-space for conflicting patterns.
      */
     preserveSpacePatterns: string[];
+    /**
+     * Namespace aliases from xsl:namespace-alias declarations.
+     * Maps stylesheet namespace prefixes to result namespace prefixes.
+     */
+    namespaceAliases: Map<string, string>;
     constructor(options?: Partial<XsltOptions>);
     /**
      * The exported entry point of the XSL-T processor.
@@ -705,6 +710,86 @@ declare class Xslt {
      * @param template The template.
      */
     protected xsltKey(context: ExprContext, template: XNode): void;
+    /**
+     * Implements `xsl:message`.
+     * Outputs a message to the console. If terminate="yes", throws an error to stop processing.
+     * @param context The Expression Context.
+     * @param template The `<xsl:message>` node.
+     */
+    protected xsltMessage(context: ExprContext, template: XNode): Promise<void>;
+    /**
+     * Implements `xsl:namespace-alias`.
+     * Declares that a namespace URI in the stylesheet should be replaced by a different
+     * namespace URI in the output.
+     * @param template The `<xsl:namespace-alias>` node.
+     */
+    protected xsltNamespaceAlias(template: XNode): void;
+    /**
+     * Implements `xsl:number`.
+     * Inserts a formatted number into the result tree.
+     * @param context The Expression Context.
+     * @param template The `<xsl:number>` node.
+     * @param output The output node.
+     */
+    protected xsltNumber(context: ExprContext, template: XNode, output?: XNode): void;
+    /**
+     * Counts nodes for xsl:number based on level, count, and from attributes.
+     * @param context The Expression Context.
+     * @param level The counting level: 'single', 'multiple', or 'any'.
+     * @param count Pattern to match nodes to count.
+     * @param from Pattern to start counting from.
+     * @returns The count value.
+     */
+    protected xsltNumberCount(context: ExprContext, level: string, count: string | null, from: string | null): number;
+    /**
+     * Checks if a node matches a simple name pattern.
+     * @param node The node to check.
+     * @param pattern The pattern (node name) to match.
+     * @returns True if the node matches.
+     */
+    protected nodeMatchesPattern(node: XNode, pattern: string): boolean;
+    /**
+     * Gets all nodes preceding the given node in document order.
+     * @param node The reference node.
+     * @returns Array of preceding nodes.
+     */
+    protected getAllPrecedingNodes(node: XNode): XNode[];
+    /**
+     * Collects all descendant nodes of a given node.
+     * @param node The parent node.
+     * @param result The array to collect into.
+     */
+    protected collectDescendants(node: XNode, result: XNode[]): void;
+    /**
+     * Formats a number according to the format string.
+     * @param number The number to format.
+     * @param format The format string (e.g., "1", "01", "a", "A", "i", "I").
+     * @param groupingSeparator Optional grouping separator.
+     * @param groupingSize Optional grouping size.
+     * @returns The formatted number string.
+     */
+    protected xsltFormatNumber(number: number, format: string, groupingSeparator: string | null, groupingSize: string | null): string;
+    /**
+     * Converts a number to alphabetic representation.
+     * @param number The number to convert.
+     * @param uppercase Whether to use uppercase letters.
+     * @returns The alphabetic representation.
+     */
+    protected numberToAlpha(number: number, uppercase: boolean): string;
+    /**
+     * Converts a number to Roman numeral representation.
+     * @param number The number to convert.
+     * @returns The Roman numeral string.
+     */
+    protected numberToRoman(number: number): string;
+    /**
+     * Applies grouping separators to a numeric string.
+     * @param numStr The numeric string.
+     * @param separator The grouping separator.
+     * @param size The grouping size.
+     * @returns The grouped string.
+     */
+    protected applyGrouping(numStr: string, separator: string, size: number): string;
     /**
      * Orders the current node list in the input context according to the
      * sort order specified by xsl:sort child nodes of the current

package/index.js

@@ -3550,6 +3550,7 @@ var Xslt = class {
     this.outputOmitXmlDeclaration = "no";
     this.stripSpacePatterns = [];
     this.preserveSpacePatterns = [];
+    this.namespaceAliases = /* @__PURE__ */ new Map();
     this.decimalFormatSettings = {
       decimalSeparator: ".",
       groupingSeparator: ",",
@@ -3667,13 +3668,16 @@ var Xslt = class {
             this.xsltKey(context, template);
             break;
           case "message":
-            throw new Error(`not implemented: ${template.localName}`);
+            yield this.xsltMessage(context, template);
+            break;
           case "namespace-alias":
-            throw new Error(`not implemented: ${template.localName}`);
+            this.xsltNamespaceAlias(template);
+            break;
           case "number":
-            throw new Error(`not implemented: ${template.localName}`);
+            this.xsltNumber(context, template, output);
+            break;
           case "otherwise":
-            throw new Error(`xsl:otherwise can't be used outside of xsl:choose.`);
+            throw new Error(`<xsl:otherwise> must be a child of <xsl:choose>.`);
           case "output":
             this.outputMethod = xmlGetAttribute(template, "method");
             this.outputOmitXmlDeclaration = xmlGetAttribute(template, "omit-xml-declaration");
@@ -3709,9 +3713,9 @@ var Xslt = class {
             yield this.xsltVariable(context, template, true);
             break;
           case "when":
-            throw new Error(`xsl:when can't be used outside of xsl:choose.`);
+            throw new Error(`<xsl:when> must be a child of <xsl:choose>.`);
           case "with-param":
-            throw new Error(`error if here: ${template.localName}`);
+            throw new Error(`<xsl:with-param> must be a child of <xsl:call-template> or <xsl:apply-templates>.`);
           default:
             throw new Error(`error if here: ${template.localName}`);
         }
@@ -4087,6 +4091,281 @@ var Xslt = class {
       context.keys[name][attributeValue] = new NodeSetValue([node]);
     }
   }
+  /**
+   * Implements `xsl:message`.
+   * Outputs a message to the console. If terminate="yes", throws an error to stop processing.
+   * @param context The Expression Context.
+   * @param template The `<xsl:message>` node.
+   */
+  xsltMessage(context, template) {
+    return __async(this, null, function* () {
+      const documentFragment = domCreateDocumentFragment(this.outputDocument);
+      yield this.xsltChildNodes(context, template, documentFragment);
+      const messageText = xmlValue(documentFragment);
+      const terminate = xmlGetAttribute(template, "terminate") || "no";
+      console.log(`[xsl:message] ${messageText}`);
+      if (terminate === "yes") {
+        throw new Error(`xsl:message terminated: ${messageText}`);
+      }
+    });
+  }
+  /**
+   * Implements `xsl:namespace-alias`.
+   * Declares that a namespace URI in the stylesheet should be replaced by a different
+   * namespace URI in the output.
+   * @param template The `<xsl:namespace-alias>` node.
+   */
+  xsltNamespaceAlias(template) {
+    const stylesheetPrefix = xmlGetAttribute(template, "stylesheet-prefix");
+    const resultPrefix = xmlGetAttribute(template, "result-prefix");
+    if (!stylesheetPrefix || !resultPrefix) {
+      throw new Error("<xsl:namespace-alias> requires both stylesheet-prefix and result-prefix attributes.");
+    }
+    this.namespaceAliases.set(stylesheetPrefix, resultPrefix);
+  }
+  /**
+   * Implements `xsl:number`.
+   * Inserts a formatted number into the result tree.
+   * @param context The Expression Context.
+   * @param template The `<xsl:number>` node.
+   * @param output The output node.
+   */
+  xsltNumber(context, template, output) {
+    const value = xmlGetAttribute(template, "value");
+    const level = xmlGetAttribute(template, "level") || "single";
+    const count = xmlGetAttribute(template, "count");
+    const from = xmlGetAttribute(template, "from");
+    const format = xmlGetAttribute(template, "format") || "1";
+    const lang = xmlGetAttribute(template, "lang");
+    const letterValue = xmlGetAttribute(template, "letter-value");
+    const groupingSeparator = xmlGetAttribute(template, "grouping-separator");
+    const groupingSize = xmlGetAttribute(template, "grouping-size");
+    let number;
+    if (value) {
+      const result = this.xPath.xPathEval(value, context);
+      number = Math.round(result.numberValue());
+    } else {
+      number = this.xsltNumberCount(context, level, count, from);
+    }
+    const formattedNumber = this.xsltFormatNumber(number, format, groupingSeparator, groupingSize);
+    const textNode = domCreateTextNode(this.outputDocument, formattedNumber);
+    const targetOutput = output || this.outputDocument;
+    textNode.siblingPosition = targetOutput.childNodes.length;
+    domAppendChild(targetOutput, textNode);
+  }
+  /**
+   * Counts nodes for xsl:number based on level, count, and from attributes.
+   * @param context The Expression Context.
+   * @param level The counting level: 'single', 'multiple', or 'any'.
+   * @param count Pattern to match nodes to count.
+   * @param from Pattern to start counting from.
+   * @returns The count value.
+   */
+  xsltNumberCount(context, level, count, from) {
+    const currentNode = context.nodeList[context.position];
+    const countPattern = count || currentNode.nodeName;
+    switch (level) {
+      case "single": {
+        let num = 1;
+        let sibling = currentNode.previousSibling;
+        while (sibling) {
+          if (sibling.nodeType === currentNode.nodeType) {
+            if (this.nodeMatchesPattern(sibling, countPattern)) {
+              num++;
+            }
+          }
+          sibling = sibling.previousSibling;
+        }
+        return num;
+      }
+      case "multiple": {
+        let num = 1;
+        let sibling = currentNode.previousSibling;
+        while (sibling) {
+          if (sibling.nodeType === currentNode.nodeType) {
+            if (this.nodeMatchesPattern(sibling, countPattern)) {
+              num++;
+            }
+          }
+          sibling = sibling.previousSibling;
+        }
+        return num;
+      }
+      case "any": {
+        let num = 1;
+        const allNodes = this.getAllPrecedingNodes(currentNode);
+        for (const node of allNodes) {
+          if (this.nodeMatchesPattern(node, countPattern)) {
+            num++;
+          }
+        }
+        return num;
+      }
+      default:
+        return 1;
+    }
+  }
+  /**
+   * Checks if a node matches a simple name pattern.
+   * @param node The node to check.
+   * @param pattern The pattern (node name) to match.
+   * @returns True if the node matches.
+   */
+  nodeMatchesPattern(node, pattern) {
+    if (pattern === "*") {
+      return node.nodeType === DOM_ELEMENT_NODE;
+    }
+    return node.nodeName === pattern || node.localName === pattern;
+  }
+  /**
+   * Gets all nodes preceding the given node in document order.
+   * @param node The reference node.
+   * @returns Array of preceding nodes.
+   */
+  getAllPrecedingNodes(node) {
+    const result = [];
+    let sibling = node.previousSibling;
+    while (sibling) {
+      result.push(sibling);
+      this.collectDescendants(sibling, result);
+      sibling = sibling.previousSibling;
+    }
+    let parent = node.parentNode;
+    while (parent) {
+      let parentSibling = parent.previousSibling;
+      while (parentSibling) {
+        result.push(parentSibling);
+        this.collectDescendants(parentSibling, result);
+        parentSibling = parentSibling.previousSibling;
+      }
+      parent = parent.parentNode;
+    }
+    return result;
+  }
+  /**
+   * Collects all descendant nodes of a given node.
+   * @param node The parent node.
+   * @param result The array to collect into.
+   */
+  collectDescendants(node, result) {
+    for (const child of node.childNodes) {
+      if (child.nodeType === DOM_ELEMENT_NODE) {
+        result.push(child);
+        this.collectDescendants(child, result);
+      }
+    }
+  }
+  /**
+   * Formats a number according to the format string.
+   * @param number The number to format.
+   * @param format The format string (e.g., "1", "01", "a", "A", "i", "I").
+   * @param groupingSeparator Optional grouping separator.
+   * @param groupingSize Optional grouping size.
+   * @returns The formatted number string.
+   */
+  xsltFormatNumber(number, format, groupingSeparator, groupingSize) {
+    const formatChar = format.charAt(0);
+    let result;
+    switch (formatChar) {
+      case "1":
+        result = number.toString();
+        if (format.length > 1 && format.match(/^0+1$/)) {
+          const width = format.length;
+          result = number.toString().padStart(width, "0");
+        }
+        break;
+      case "a":
+        result = this.numberToAlpha(number, false);
+        break;
+      case "A":
+        result = this.numberToAlpha(number, true);
+        break;
+      case "i":
+        result = this.numberToRoman(number).toLowerCase();
+        break;
+      case "I":
+        result = this.numberToRoman(number);
+        break;
+      default:
+        result = number.toString();
+    }
+    if (groupingSeparator && groupingSize) {
+      const size = parseInt(groupingSize, 10);
+      if (size > 0 && !isNaN(size)) {
+        result = this.applyGrouping(result, groupingSeparator, size);
+      }
+    }
+    return result;
+  }
+  /**
+   * Converts a number to alphabetic representation.
+   * @param number The number to convert.
+   * @param uppercase Whether to use uppercase letters.
+   * @returns The alphabetic representation.
+   */
+  numberToAlpha(number, uppercase) {
+    if (number <= 0) return "";
+    let result = "";
+    while (number > 0) {
+      number--;
+      result = String.fromCharCode(number % 26 + (uppercase ? 65 : 97)) + result;
+      number = Math.floor(number / 26);
+    }
+    return result;
+  }
+  /**
+   * Converts a number to Roman numeral representation.
+   * @param number The number to convert.
+   * @returns The Roman numeral string.
+   */
+  numberToRoman(number) {
+    if (number <= 0 || number > 3999) return number.toString();
+    const romanNumerals = [
+      [1e3, "M"],
+      [900, "CM"],
+      [500, "D"],
+      [400, "CD"],
+      [100, "C"],
+      [90, "XC"],
+      [50, "L"],
+      [40, "XL"],
+      [10, "X"],
+      [9, "IX"],
+      [5, "V"],
+      [4, "IV"],
+      [1, "I"]
+    ];
+    let result = "";
+    for (const [value, numeral] of romanNumerals) {
+      while (number >= value) {
+        result += numeral;
+        number -= value;
+      }
+    }
+    return result;
+  }
+  /**
+   * Applies grouping separators to a numeric string.
+   * @param numStr The numeric string.
+   * @param separator The grouping separator.
+   * @param size The grouping size.
+   * @returns The grouped string.
+   */
+  applyGrouping(numStr, separator, size) {
+    const parts = numStr.split(".");
+    let intPart = parts[0];
+    const decPart = parts[1];
+    let result = "";
+    let count = 0;
+    for (let i = intPart.length - 1; i >= 0; i--) {
+      if (count > 0 && count % size === 0) {
+        result = separator + result;
+      }
+      result = intPart[i] + result;
+      count++;
+    }
+    return decPart ? result + "." + decPart : result;
+  }
   /**
    * Orders the current node list in the input context according to the
    * sort order specified by xsl:sort child nodes of the current