xslt-processor 5.0.7 → 5.0.9

package/dist/index.mjs

@@ -11130,7 +11130,7 @@ function xmlElementLogicTrivial(node, buffer, options) {
   }
   childNodes = childNodes.sort((a, b) => a.siblingPosition - b.siblingPosition);
   if (childNodes.length === 0) {
-    if (options.outputMethod === "html" && ["hr", "link", "meta"].includes(node.nodeName)) {
+    if (options.outputMethod === "html" && ["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"].includes(node.nodeName)) {
       buffer.push(">");
     } else if (options.selfClosingTags) {
       buffer.push("/>");
@@ -11831,7 +11831,9 @@ var NodeConverter = class {
    * We add missing properties but keep the original XNode reference.
    */
   adaptXNode(node) {
-    if (!node) return null;
+    if (!node) {
+      throw new Error("Cannot adapt undefined XPath node.");
+    }
     const adapted = node;
     if (!("textContent" in adapted)) {
       Object.defineProperty(adapted, "textContent", {
@@ -11917,7 +11919,12 @@ var NodeConverter = class {
     }
     for (let i = contexts.length - 1; i >= 0; i--) {
       const current = contexts[i];
-      for (const [name, value] of Object.entries(current.variables || {})) {
+      const currentVariables = current.variables || {};
+      for (const name in currentVariables) {
+        if (!Object.prototype.hasOwnProperty.call(currentVariables, name)) {
+          continue;
+        }
+        const value = currentVariables[name];
         if (value && typeof value === "object" && "stringValue" in value) {
           const nodeValue = value;
           if (nodeValue.type === "node-set") {
@@ -11966,7 +11973,7 @@ var NodeConverter = class {
     };
     functions["format-number"] = (_context, number, format, decimalFormatName) => {
       const settings = exprContext.decimalFormatSettings;
-      return number.toLocaleString();
+      return this.formatXsltNumberPicture(Number(number), String(format), settings);
     };
     functions["xml-to-json"] = (_context, nodes) => {
       if (exprContext.xsltVersion !== "3.0") {
@@ -12047,7 +12054,7 @@ var NodeConverter = class {
         "xsl:with-param"
       ];
       const normalizedName = name.startsWith("xsl:") ? name : `xsl:${name}`;
-      return xsltElements.includes(normalizedName) || xsltElements.includes(name);
+      return xsltElements.indexOf(normalizedName) >= 0 || xsltElements.indexOf(name) >= 0;
     };
     functions["function-available"] = (_context, functionName2) => {
       const name = String(functionName2);
@@ -12098,7 +12105,7 @@ var NodeConverter = class {
         "json-to-xml"
       ];
       const allFunctions = [...xpathCoreFunctions, ...xsltFunctions, ...additionalFunctions];
-      return allFunctions.includes(name);
+      return allFunctions.indexOf(name) >= 0;
     };
     functions["document"] = (_context, uriOrNodeSet, _baseNode) => {
       var _a, _b;
@@ -12142,6 +12149,95 @@ var NodeConverter = class {
     }
     return functions;
   }
+  /**
+   * Minimal XSLT/XPath format-number() picture formatter.
+   * Supports grouping, decimal precision, percent/per-mille scaling and positive/negative subpictures.
+   */
+  formatXsltNumberPicture(value, picture, settings) {
+    if (Number.isNaN(value)) {
+      return settings.naN;
+    }
+    if (!Number.isFinite(value)) {
+      return value < 0 ? `${settings.minusSign}${settings.infinity}` : settings.infinity;
+    }
+    const subPictures = picture.split(settings.patternSeparator);
+    const isNegative = value < 0;
+    const activePicture = (isNegative && subPictures.length > 1 ? subPictures[1] : subPictures[0]) || "";
+    const absValue = Math.abs(value);
+    const placeholders = /* @__PURE__ */ new Set([settings.digit, settings.zeroDigit, settings.groupingSeparator, settings.decimalSeparator]);
+    let firstPatternIndex = -1;
+    let lastPatternIndex = -1;
+    for (let i = 0; i < activePicture.length; i++) {
+      if (placeholders.has(activePicture[i])) {
+        if (firstPatternIndex === -1) {
+          firstPatternIndex = i;
+        }
+        lastPatternIndex = i;
+      }
+    }
+    if (firstPatternIndex === -1) {
+      return activePicture;
+    }
+    const prefix = activePicture.slice(0, firstPatternIndex);
+    const suffix = activePicture.slice(lastPatternIndex + 1);
+    const numericPicture = activePicture.slice(firstPatternIndex, lastPatternIndex + 1);
+    let scaledValue = absValue;
+    if (activePicture.includes(settings.percent)) {
+      scaledValue *= 100;
+    }
+    if (activePicture.includes(settings.perMille)) {
+      scaledValue *= 1e3;
+    }
+    const decimalIndex = numericPicture.indexOf(settings.decimalSeparator);
+    const integerPattern = decimalIndex >= 0 ? numericPicture.slice(0, decimalIndex) : numericPicture;
+    const fractionPattern = decimalIndex >= 0 ? numericPicture.slice(decimalIndex + 1) : "";
+    const minIntegerDigits = integerPattern.split("").filter((c) => c === settings.zeroDigit).length;
+    const minFractionDigits = fractionPattern.split("").filter((c) => c === settings.zeroDigit).length;
+    const maxFractionDigits = fractionPattern.split("").filter((c) => c === settings.zeroDigit || c === settings.digit).length;
+    const rounded = maxFractionDigits > 0 ? scaledValue.toFixed(maxFractionDigits) : Math.round(scaledValue).toString();
+    let [integerPart, fractionPart = ""] = rounded.split(".");
+    if (integerPart.length < minIntegerDigits) {
+      integerPart = this.leftPad(integerPart, minIntegerDigits, settings.zeroDigit);
+    }
+    while (fractionPart.length > minFractionDigits && fractionPart.endsWith(settings.zeroDigit)) {
+      fractionPart = fractionPart.slice(0, -1);
+    }
+    const lastGroupingPos = integerPattern.lastIndexOf(settings.groupingSeparator);
+    if (lastGroupingPos >= 0) {
+      const groupSize = integerPattern.slice(lastGroupingPos + 1).split("").filter((c) => c === settings.zeroDigit || c === settings.digit).length;
+      if (groupSize > 0) {
+        integerPart = this.applyGrouping(integerPart, settings.groupingSeparator, groupSize);
+      }
+    }
+    const numberText = fractionPart.length > 0 ? `${integerPart}${settings.decimalSeparator}${fractionPart}` : integerPart;
+    if (isNegative && subPictures.length < 2) {
+      return `${settings.minusSign}${prefix}${numberText}${suffix}`;
+    }
+    return `${prefix}${numberText}${suffix}`;
+  }
+  applyGrouping(numberText, separator, groupSize) {
+    if (groupSize <= 0 || numberText.length <= groupSize) {
+      return numberText;
+    }
+    const chunks = [];
+    for (let i = numberText.length; i > 0; i -= groupSize) {
+      const start = Math.max(0, i - groupSize);
+      chunks.unshift(numberText.slice(start, i));
+    }
+    return chunks.join(separator);
+  }
+  leftPad(value, width, fillChar) {
+    if (value.length >= width) {
+      return value;
+    }
+    const padChar = fillChar && fillChar.length > 0 ? fillChar.charAt(0) : "0";
+    const missing = width - value.length;
+    let padding = "";
+    for (let i = 0; i < missing; i++) {
+      padding += padChar;
+    }
+    return padding + value;
+  }
   /**
    * Convert an XPathNode interface tree to actual XNode objects.
    * This is needed to convert json-to-xml() output to XSLT-compatible nodes.
@@ -12154,7 +12250,11 @@ var NodeConverter = class {
     if (xpathNode.nodeType === DOM_DOCUMENT_NODE) {
       if (xpathNode.childNodes && xpathNode.childNodes.length > 0) {
         const rootChild = xpathNode.childNodes[0];
-        node = this.convertXPathNodeToXNode(rootChild, ownerDoc);
+        const convertedNode = this.convertXPathNodeToXNode(rootChild, ownerDoc);
+        if (!convertedNode) {
+          return null;
+        }
+        node = convertedNode;
         return node;
       }
       return null;