xslt-processor 4.1.0 → 4.2.1

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

@@ -3446,24 +3446,31 @@ function nodeMatchesSinglePattern(node, pattern, context, matchResolver, xPath)
     const patternLocalName = attrPattern.includes(":") ? attrPattern.substring(attrPattern.indexOf(":") + 1) : attrPattern;
     return attrName === patternLocalName || node.nodeName === attrPattern;
   }
-  const nodeContext = context.clone([node], 0);
-  try {
-    const expr = xPath.xPathParse(pattern, "self-and-siblings");
-    const nodes = matchResolver.expressionMatch(expr, nodeContext);
-    if (nodes.some((n) => n.id === node.id)) {
-      return true;
-    }
-  } catch (e) {
-  }
   if (pattern === "*" && node.nodeType === DOM_ELEMENT_NODE) {
     return true;
   }
-  if (pattern.includes("[") || pattern.includes("/")) {
+  if (!pattern.includes("/") && !pattern.includes("[") && !pattern.startsWith("@")) {
+    if (pattern === node.nodeName || pattern === node.localName) {
+      return true;
+    }
+  }
+  if (pattern.includes("/") || pattern.includes("[")) {
     try {
+      const evaluationPattern = pattern.startsWith("/") ? pattern : "//" + pattern;
       const rootContext = context.clone([context.root], 0);
-      const descendantPattern = pattern.startsWith("/") ? pattern : "//" + pattern;
-      const expr = xPath.xPathParse(descendantPattern);
-      const nodes = matchResolver.expressionMatch(expr, rootContext);
+      const evalResult = xPath.xPathEval(evaluationPattern, rootContext);
+      const nodes = evalResult.nodeSetValue();
+      if (nodes.some((n) => n.id === node.id)) {
+        return true;
+      }
+    } catch (e) {
+    }
+  }
+  if (!pattern.includes("/") && !pattern.includes("[") && !pattern.startsWith("@")) {
+    try {
+      const nodeContext = context.clone([node], 0);
+      const expr = xPath.xPathParse(pattern, "self-and-siblings");
+      const nodes = matchResolver.expressionMatch(expr, nodeContext);
       if (nodes.some((n) => n.id === node.id)) {
         return true;
       }
@@ -3550,6 +3557,7 @@ var Xslt = class {
     this.outputOmitXmlDeclaration = "no";
     this.stripSpacePatterns = [];
     this.preserveSpacePatterns = [];
+    this.namespaceAliases = /* @__PURE__ */ new Map();
     this.decimalFormatSettings = {
       decimalSeparator: ".",
       groupingSeparator: ",",
@@ -3667,13 +3675,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 +3720,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}`);
         }
@@ -3737,7 +3748,9 @@ var Xslt = class {
       const mode = xmlGetAttribute(template, "mode");
       const top = template.ownerDocument.documentElement;
       const expandedTemplates = collectAndExpandTemplates(top, mode, this.xPath);
-      const modifiedContext = context.clone(nodes);
+      const paramContext = context.clone();
+      yield this.xsltWithParam(paramContext, template);
+      const modifiedContext = paramContext.clone(nodes);
       for (let j = 0; j < modifiedContext.contextSize(); ++j) {
         const currentNode = modifiedContext.nodeList[j];
         if (currentNode.nodeType === DOM_TEXT_NODE) {
@@ -4087,6 +4100,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
@@ -4333,13 +4621,76 @@ var Xslt = class {
           contextClone.baseTemplateMatched = true;
           const templateContext = contextClone.clone(winner.matchedNodes, 0);
           yield this.xsltChildNodes(templateContext, winner.priority.template, output);
+        } else {
+          const rootNode = context.nodeList[context.position];
+          if (rootNode && rootNode.childNodes && rootNode.childNodes.length > 0) {
+            const childNodes = rootNode.childNodes.filter((n) => n.nodeName !== "#dtd-section");
+            if (childNodes.length > 0) {
+              const childContext = context.clone(childNodes);
+              for (let j = 0; j < childContext.contextSize(); ++j) {
+                const currentNode = childContext.nodeList[j];
+                if (currentNode.nodeType === DOM_TEXT_NODE) {
+                  const textNodeContext = context.clone([currentNode], 0);
+                  this.commonLogicTextNode(textNodeContext, currentNode, output);
+                } else {
+                  const clonedContext = childContext.clone([currentNode], 0);
+                  const selection = selectBestTemplate(
+                    expandedTemplates,
+                    clonedContext,
+                    this.matchResolver,
+                    this.xPath
+                  );
+                  if (selection.selectedTemplate) {
+                    const templateContext = clonedContext.clone([currentNode], 0);
+                    templateContext.inApplyTemplates = true;
+                    yield this.xsltChildNodes(templateContext, selection.selectedTemplate, output);
+                  } else {
+                    if (currentNode.childNodes && currentNode.childNodes.length > 0) {
+                      const grandchildNodes = currentNode.childNodes.filter((n) => n.nodeName !== "#dtd-section");
+                      if (grandchildNodes.length > 0) {
+                        const grandchildContext = context.clone(grandchildNodes);
+                        for (let k = 0; k < grandchildContext.contextSize(); ++k) {
+                          const grandchildNode = grandchildContext.nodeList[k];
+                          if (grandchildNode.nodeType === DOM_TEXT_NODE) {
+                            const textNodeContext = context.clone([grandchildNode], 0);
+                            this.commonLogicTextNode(textNodeContext, grandchildNode, output);
+                          } else {
+                            const grandchildClonedContext = grandchildContext.clone([grandchildNode], 0);
+                            const grandchildSelection = selectBestTemplate(
+                              expandedTemplates,
+                              grandchildClonedContext,
+                              this.matchResolver,
+                              this.xPath
+                            );
+                            if (grandchildSelection.selectedTemplate) {
+                              const grandchildTemplateContext = grandchildClonedContext.clone([grandchildNode], 0);
+                              grandchildTemplateContext.inApplyTemplates = true;
+                              yield this.xsltChildNodes(grandchildTemplateContext, grandchildSelection.selectedTemplate, output);
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
         }
       }
     });
   }
   xsltValueOf(context, template, output) {
     const select = xmlGetAttribute(template, "select");
-    const attribute = this.xPath.xPathEval(select, context);
+    const current = context.nodeList[context.position];
+    let attribute = this.xPath.xPathEval(select, context);
+    if (current && current.nodeName === "#document" && (attribute.stringValue() === "" || attribute instanceof NodeSetValue && attribute.nodeSetValue().length === 0)) {
+      const docChild = current.childNodes.find((c) => c.nodeName !== "#dtd-section");
+      if (docChild) {
+        const fallbackContext = context.clone([docChild], 0);
+        attribute = this.xPath.xPathEval(select, fallbackContext);
+      }
+    }
     const value = attribute.stringValue();
     const node = domCreateTextNode(this.outputDocument, value);
     const targetOutput = output || this.outputDocument;