xslt-processor 4.2.0 → 4.2.1

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;
       }
@@ -3741,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) {
@@ -4612,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;