xslt-processor 4.8.0 → 4.8.2

package/index.js

@@ -5759,7 +5759,7 @@ function getBuiltInFunction(name) {
 function getBuiltInFunctionArity(name) {
   return FUNCTION_ARITY[name];
 }
-var BUILT_IN_FUNCTIONS, FUNCTION_ARITY, XPathFunctionCall;
+var toStringValue, BUILT_IN_FUNCTIONS, FUNCTION_ARITY, XPathFunctionCall;
 var init_function_call_expression = __esm({
   "src/xpath/lib/src/expressions/function-call-expression.ts"() {
     init_expression();
@@ -5778,10 +5778,30 @@ var init_function_call_expression = __esm({
     init_qname_functions();
     init_uri_functions();
     init_node_functions();
+    toStringValue = (arg) => {
+      var _a;
+      if (arg && typeof arg === "object") {
+        if (typeof arg.stringValue === "function") {
+          return arg.stringValue();
+        }
+        if (Array.isArray(arg)) {
+          if (arg.length === 0) return "";
+          const firstNode = arg[0];
+          return (_a = firstNode == null ? void 0 : firstNode.textContent) != null ? _a : String(firstNode);
+        }
+        if (typeof arg.textContent === "string") {
+          return arg.textContent;
+        }
+        if (arg.nodeValue !== void 0 && arg.nodeValue !== null) {
+          return String(arg.nodeValue);
+        }
+      }
+      return String(arg != null ? arg : "");
+    };
     BUILT_IN_FUNCTIONS = {
       // String functions
-      "upper-case": (_ctx, arg) => String(arg).toUpperCase(),
-      "lower-case": (_ctx, arg) => String(arg).toLowerCase(),
+      "upper-case": (_ctx, arg) => toStringValue(arg).toUpperCase(),
+      "lower-case": (_ctx, arg) => toStringValue(arg).toLowerCase(),
       concat: (_ctx, ...args) => args.map((a) => String(a)).join(""),
       "string-join": (_ctx, seq, sep = "") => {
         if (Array.isArray(seq)) {
@@ -6372,6 +6392,10 @@ var init_function_call_expression = __esm({
               return context.functions[this.name](context, ...evaluatedArgs);
             }
             let builtInFunc = BUILT_IN_FUNCTIONS[this.name];
+            if (!builtInFunc && this.name.startsWith("fn:")) {
+              const localName = this.name.substring(3);
+              builtInFunc = BUILT_IN_FUNCTIONS[localName];
+            }
             if (!builtInFunc && this.name.startsWith("Q{")) {
               const { namespace, localName } = this.parseEQName(this.name);
               builtInFunc = BUILT_IN_FUNCTIONS[localName];
@@ -12667,11 +12691,24 @@ function makeComponentKey(component) {
       return `unknown:${component.type}`;
   }
 }
+function isComponentVisible(component, fromPackage) {
+  if (component.visibility === "private") {
+    return fromPackage;
+  }
+  return true;
+}
+function canOverrideComponent(component) {
+  if (component.visibility === "final") {
+    return false;
+  }
+  return component.overridable;
+}
 
 // src/xslt/package-system/package-registry.ts
 var PackageRegistry = class {
   constructor() {
     this.packages = /* @__PURE__ */ new Map();
+    this.loading = /* @__PURE__ */ new Set();
   }
   /**
    * Register a package in the registry.
@@ -12682,10 +12719,97 @@ var PackageRegistry = class {
   }
   /**
    * Retrieve a package from the registry.
+   * Supports version constraints: exact, wildcards (1.*), ranges (>=1.0), and combined (>=1.0,<2.0).
    */
   get(name, version) {
-    const key = this.makePackageKey(name, version);
-    return this.packages.get(key);
+    if (!version) {
+      return this.packages.get(name);
+    }
+    const exactKey = this.makePackageKey(name, version);
+    const exactMatch = this.packages.get(exactKey);
+    if (exactMatch) {
+      return exactMatch;
+    }
+    const hasConstraint = /[*<>=,]/.test(version);
+    if (!hasConstraint) {
+      return void 0;
+    }
+    const matchingPackages = [];
+    this.packages.forEach((pkg, key) => {
+      if (pkg.name === name && pkg.version && this.satisfiesVersion(pkg.version, version)) {
+        matchingPackages.push(pkg);
+      }
+    });
+    if (matchingPackages.length === 0) {
+      return void 0;
+    }
+    matchingPackages.sort((a, b) => this.compareVersions(b.version, a.version));
+    return matchingPackages[0];
+  }
+  /**
+   * Check if a package version satisfies a version constraint.
+   */
+  satisfiesVersion(packageVersion, constraint) {
+    if (constraint.includes(",")) {
+      const constraints = constraint.split(",").map((c) => c.trim());
+      return constraints.every((c) => this.satisfiesSingleConstraint(packageVersion, c));
+    }
+    return this.satisfiesSingleConstraint(packageVersion, constraint);
+  }
+  /**
+   * Evaluate a single version constraint.
+   */
+  satisfiesSingleConstraint(packageVersion, constraint) {
+    if (constraint.includes("*")) {
+      const prefix = constraint.replace(/\*$/, "").replace(/\.$/, "");
+      if (!prefix) {
+        return true;
+      }
+      const pkgParts = packageVersion.split(".");
+      const prefixParts = prefix.split(".");
+      for (let i = 0; i < prefixParts.length; i++) {
+        if (pkgParts[i] !== prefixParts[i]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    const operatorMatch = constraint.match(/^(>=|<=|>|<|=)?(.+)$/);
+    if (!operatorMatch) {
+      return false;
+    }
+    const operator = operatorMatch[1] || "=";
+    const targetVersion = operatorMatch[2].trim();
+    const comparison = this.compareVersions(packageVersion, targetVersion);
+    switch (operator) {
+      case ">=":
+        return comparison >= 0;
+      case ">":
+        return comparison > 0;
+      case "<=":
+        return comparison <= 0;
+      case "<":
+        return comparison < 0;
+      case "=":
+      default:
+        return comparison === 0;
+    }
+  }
+  /**
+   * Compare two semantic versions.
+   * @returns -1 if a < b, 0 if a === b, 1 if a > b
+   */
+  compareVersions(a, b) {
+    const aParts = a.split(".").map((p) => parseInt(p, 10) || 0);
+    const bParts = b.split(".").map((p) => parseInt(p, 10) || 0);
+    const maxLength = Math.max(aParts.length, bParts.length);
+    for (let i = 0; i < maxLength; i++) {
+      const aPart = aParts[i] || 0;
+      const bPart = bParts[i] || 0;
+      if (aPart < bPart) return -1;
+      if (aPart > bPart) return 1;
+    }
+    return 0;
   }
   /**
    * Check if a package exists in the registry.
@@ -12694,6 +12818,31 @@ var PackageRegistry = class {
     const key = this.makePackageKey(name, version);
     return this.packages.has(key);
   }
+  /**
+   * Mark a package as currently being loaded.
+   * Used to detect circular dependencies.
+   * @returns true if the package can be loaded, false if it's already being loaded (circular dependency)
+   */
+  beginLoading(packageKey) {
+    if (this.loading.has(packageKey)) {
+      return false;
+    }
+    this.loading.add(packageKey);
+    return true;
+  }
+  /**
+   * Mark a package as finished loading.
+   */
+  endLoading(packageKey) {
+    this.loading.delete(packageKey);
+  }
+  /**
+   * Check if a package is currently being loaded.
+   * Used to detect circular dependencies when a package tries to use another package that is still loading.
+   */
+  isLoading(packageKey) {
+    return this.loading.has(packageKey);
+  }
   /**
    * Create a unique key for a package based on name and version.
    */
@@ -12705,6 +12854,7 @@ var PackageRegistry = class {
    */
   clear() {
     this.packages.clear();
+    this.loading.clear();
   }
 };
 
@@ -13603,7 +13753,8 @@ function selectBestTemplate(templates, context, matchResolver, xPath, warningsCa
   return {
     selectedTemplate: winner.template,
     hasConflict: conflicts.length > 1,
-    conflictingTemplates: conflicts.length > 1 ? conflicts : []
+    conflictingTemplates: conflicts.length > 1 ? conflicts : [],
+    originalComponent: winner.originalComponent
   };
 }
 function emitConflictWarning(result, node, warningsCallback) {
@@ -13704,6 +13855,11 @@ var Xslt = class {
      * null if processing a non-package stylesheet.
      */
     this.currentPackage = null;
+    /**
+     * Current override context (for XSLT 3.0 xsl:original).
+     * Tracks the original component when executing an override.
+     */
+    this.currentOverrideContext = null;
     /**
      * Accumulator registry for XSLT 3.0 accumulators.
      * Stores accumulator definitions and current state during processing.
@@ -13945,6 +14101,12 @@ var Xslt = class {
           case "accept":
             this.xsltAccept(context, template);
             break;
+          case "override":
+            yield this.xsltOverride(context, template, output);
+            break;
+          case "original":
+            yield this.xsltOriginal(context, template, output);
+            break;
           case "param":
             yield this.xsltVariable(context, template, false);
             break;
@@ -13982,6 +14144,11 @@ var Xslt = class {
           case "merge":
             yield this.xsltMerge(context, template, output);
             break;
+          case "mode":
+            if (this.currentPackage) {
+              this.xsltMode(context, template);
+            }
+            break;
           case "template":
             yield this.xsltTemplate(context, template, output);
             break;
@@ -14063,8 +14230,10 @@ var Xslt = class {
         return;
       }
       const mode = xmlGetAttribute(template, "mode");
+      const effectiveMode = mode || null;
       const top = template.ownerDocument.documentElement;
-      const expandedTemplates = collectAndExpandTemplates(top, mode, this.xPath, this.templateSourceMap);
+      let expandedTemplates = collectAndExpandTemplates(top, effectiveMode, this.xPath, this.templateSourceMap);
+      expandedTemplates = expandedTemplates.concat(this.collectAcceptedTemplates(effectiveMode));
       const paramContext = context.clone();
       yield this.xsltWithParam(paramContext, template);
       const modifiedContext = paramContext.clone(nodes);
@@ -14090,13 +14259,19 @@ var Xslt = class {
             this.currentTemplateStack.push({
               template: textSelection.selectedTemplate,
               stylesheetDepth: (_a = metadata == null ? void 0 : metadata.importDepth) != null ? _a : 0,
-              mode: modeAttr || mode,
+              mode: modeAttr || effectiveMode,
               match: matchPattern
             });
+            const previousOverrideContext = this.currentOverrideContext;
+            const overrideContext = textSelection.originalComponent || textSelection.selectedTemplate.__originalComponent;
+            if (overrideContext) {
+              this.currentOverrideContext = overrideContext;
+            }
             try {
               yield this.xsltChildNodes(textNodeContext, textSelection.selectedTemplate, output);
             } finally {
               this.currentTemplateStack.pop();
+              this.currentOverrideContext = previousOverrideContext;
             }
           } else {
             const oldTextNodeContext = context.clone([currentNode], 0);
@@ -14125,13 +14300,19 @@ var Xslt = class {
             this.currentTemplateStack.push({
               template: selection.selectedTemplate,
               stylesheetDepth: (_b = metadata == null ? void 0 : metadata.importDepth) != null ? _b : 0,
-              mode: modeAttr || mode,
+              mode: modeAttr || effectiveMode,
               match: matchPattern
             });
+            const previousOverrideContext = this.currentOverrideContext;
+            const overrideContext = selection.originalComponent || selection.selectedTemplate.__originalComponent;
+            if (overrideContext) {
+              this.currentOverrideContext = overrideContext;
+            }
             try {
               yield this.xsltChildNodes(clonedContext, selection.selectedTemplate, output);
             } finally {
               this.currentTemplateStack.pop();
+              this.currentOverrideContext = previousOverrideContext;
             }
           } else {
             if (currentNode.nodeType === DOM_ELEMENT_NODE && currentNode.childNodes && currentNode.childNodes.length > 0) {
@@ -14172,7 +14353,7 @@ var Xslt = class {
                     this.currentTemplateStack.push({
                       template: childSelection.selectedTemplate,
                       stylesheetDepth: (_c = childMetadata == null ? void 0 : childMetadata.importDepth) != null ? _c : 0,
-                      mode: childModeAttr || mode,
+                      mode: childModeAttr || effectiveMode,
                       match: childMatchPattern
                     });
                     try {
@@ -14181,7 +14362,7 @@ var Xslt = class {
                       this.currentTemplateStack.pop();
                     }
                   } else if (childNode.nodeType === DOM_ELEMENT_NODE) {
-                    yield this.applyBuiltInTemplate(childNode, expandedTemplates, mode, paramContext, output);
+                    yield this.applyBuiltInTemplate(childNode, expandedTemplates, effectiveMode, paramContext, output);
                   }
                 }
               }
@@ -14218,7 +14399,16 @@ var Xslt = class {
             this.warningsCallback
           );
           if (textSelection.selectedTemplate) {
-            yield this.xsltChildNodes(textContext, textSelection.selectedTemplate, output);
+            const previousOverrideContext = this.currentOverrideContext;
+            const overrideContext = textSelection.originalComponent || textSelection.selectedTemplate.__originalComponent;
+            if (overrideContext) {
+              this.currentOverrideContext = overrideContext;
+            }
+            try {
+              yield this.xsltChildNodes(textContext, textSelection.selectedTemplate, output);
+            } finally {
+              this.currentOverrideContext = previousOverrideContext;
+            }
           } else {
             this.commonLogicTextNode(textContext, childNode, output);
           }
@@ -14242,10 +14432,16 @@ var Xslt = class {
               mode: childModeAttr || mode,
               match: childMatchPattern
             });
+            const previousOverrideContext = this.currentOverrideContext;
+            const overrideContext = childSelection.originalComponent || childSelection.selectedTemplate.__originalComponent;
+            if (overrideContext) {
+              this.currentOverrideContext = overrideContext;
+            }
             try {
               yield this.xsltChildNodes(childContext, childSelection.selectedTemplate, output);
             } finally {
               this.currentTemplateStack.pop();
+              this.currentOverrideContext = previousOverrideContext;
             }
           } else if (childNode.nodeType === DOM_ELEMENT_NODE) {
             yield this.applyBuiltInTemplate(childNode, expandedTemplates, mode, paramContext, output);
@@ -14284,23 +14480,39 @@ var Xslt = class {
         return;
       }
       const nodeContext = context.clone([currentNode], 0);
-      const selection = selectBestTemplate(importedTemplates, nodeContext, this.matchResolver, this.xPath, this.warningsCallback);
+      const selection = selectBestTemplate(
+        importedTemplates,
+        nodeContext,
+        this.matchResolver,
+        this.xPath,
+        this.warningsCallback
+      );
       if (!selection.selectedTemplate) {
         return;
       }
       const importedContext = context.clone();
-      const expandedTemplates = collectAndExpandTemplates(top, currentMode, this.xPath, this.templateSourceMap);
+      yield this.xsltWithParam(importedContext, template);
       const metadata = this.templateSourceMap.get(selection.selectedTemplate);
       if (metadata) {
         const matchPattern = xmlGetAttribute(selection.selectedTemplate, "match");
+        const modeAttr = xmlGetAttribute(selection.selectedTemplate, "mode");
         this.currentTemplateStack.push({
           template: selection.selectedTemplate,
           stylesheetDepth: metadata.importDepth,
-          mode: currentMode,
+          mode: modeAttr || currentMode,
           match: matchPattern
         });
-        yield this.xsltChildNodes(importedContext, selection.selectedTemplate, output);
-        this.currentTemplateStack.pop();
+        const previousOverrideContext = this.currentOverrideContext;
+        const overrideContext = selection.originalComponent || selection.selectedTemplate.__originalComponent;
+        if (overrideContext) {
+          this.currentOverrideContext = overrideContext;
+        }
+        try {
+          yield this.xsltChildNodes(importedContext, selection.selectedTemplate, output);
+        } finally {
+          this.currentTemplateStack.pop();
+          this.currentOverrideContext = previousOverrideContext;
+        }
       }
     });
   }
@@ -14335,6 +14547,21 @@ var Xslt = class {
       const top = template.ownerDocument.documentElement;
       const paramContext = context.clone();
       yield this.xsltWithParam(paramContext, template);
+      let foundTemplate = null;
+      if (this.currentPackage) {
+        this.currentPackage.usedPackages.forEach((usedPkg) => {
+          usedPkg.acceptedComponents.forEach((component) => {
+            if (component.type === "template" && component.name === name && component.isAccepted) {
+              const effectiveComponent = this.getEffectiveComponent(component);
+              foundTemplate = effectiveComponent.node;
+            }
+          });
+        });
+      }
+      if (foundTemplate) {
+        yield this.xsltChildNodes(paramContext, foundTemplate, output);
+        return;
+      }
       for (let i = 0; i < top.childNodes.length; ++i) {
         let childNode = top.childNodes[i];
         if (childNode.nodeType === DOM_ELEMENT_NODE && this.isXsltElement(childNode, "template") && domGetAttributeValue(childNode, "name") === name) {
@@ -15146,16 +15373,27 @@ var Xslt = class {
       }
       const name = xmlGetAttribute(template, "name");
       const packageVersion = xmlGetAttribute(template, "package-version");
+      const declaredModes = xmlGetAttribute(template, "declared-modes") || "yes";
+      const inputTypeAnnotations = xmlGetAttribute(template, "input-type-annotations") || "unspecified";
       if (!name) {
         throw new Error('<xsl:package> requires a "name" attribute.');
       }
+      const packageKey = packageVersion ? `${name}@${packageVersion}` : name;
+      const wasAlreadyLoading = this.packageRegistry.isLoading(packageKey);
+      if (!wasAlreadyLoading) {
+        this.packageRegistry.beginLoading(packageKey);
+      }
       const pkg = {
         name,
         version: packageVersion,
         root: template,
         components: /* @__PURE__ */ new Map(),
         usedPackages: /* @__PURE__ */ new Map(),
-        isTopLevel: this.currentPackage === null
+        isTopLevel: this.currentPackage === null,
+        overrides: /* @__PURE__ */ new Map(),
+        modes: /* @__PURE__ */ new Map(),
+        declaredModes,
+        inputTypeAnnotations
       };
       const previousPackage = this.currentPackage;
       this.currentPackage = pkg;
@@ -15163,10 +15401,54 @@ var Xslt = class {
         this.packageRegistry.register(pkg);
         yield this.xsltTransformOrStylesheet(context, template, output);
       } finally {
+        if (!wasAlreadyLoading) {
+          this.packageRegistry.endLoading(packageKey);
+        }
         this.currentPackage = previousPackage;
       }
     });
   }
+  /**
+   * Loads and registers an external package.
+   * Creates a temporary context and processes the package document.
+   * 
+   * @param name The package name/URI.
+   * @param packageDoc The parsed package document.
+   * @param version Optional semantic version string.
+   */
+  loadAndRegisterPackage(name, packageDoc, version) {
+    return __async(this, null, function* () {
+      const packageKey = version ? `${name}@${version}` : name;
+      if (!this.packageRegistry.beginLoading(packageKey)) {
+        throw new Error(`Circular package dependency detected: "${packageKey}".`);
+      }
+      try {
+        let packageRoot = packageDoc;
+        if (packageDoc.nodeType === DOM_DOCUMENT_NODE) {
+          for (const child of packageDoc.childNodes) {
+            if (child.nodeType === DOM_ELEMENT_NODE && this.isXsltElement(child, "package")) {
+              packageRoot = child;
+              break;
+            }
+          }
+        }
+        if (packageRoot && this.isXsltElement(packageRoot, "package")) {
+          if (name && !xmlGetAttribute(packageRoot, "name")) {
+            domSetAttribute(packageRoot, "name", name);
+          }
+          if (version && !xmlGetAttribute(packageRoot, "package-version")) {
+            domSetAttribute(packageRoot, "package-version", version);
+          }
+          const tempContext = new ExprContext([packageRoot]);
+          yield this.xsltPackage(tempContext, packageRoot);
+        } else {
+          throw new Error("Package document does not contain an xsl:package root element.");
+        }
+      } finally {
+        this.packageRegistry.endLoading(packageKey);
+      }
+    });
+  }
   /**
    * Implements `<xsl:use-package>` (XSLT 3.0 Section 3.7).
    * Imports another package and makes its public components available.
@@ -15184,10 +15466,27 @@ var Xslt = class {
       if (!name) {
         throw new Error('<xsl:use-package> requires a "name" attribute.');
       }
-      const usedPackage = this.packageRegistry.get(name, packageVersion);
+      const packageKey = packageVersion ? `${name}@${packageVersion}` : name;
+      if (this.packageRegistry.isLoading(packageKey)) {
+        throw new Error(`Circular package dependency detected: "${packageKey}".`);
+      }
+      let usedPackage = this.packageRegistry.get(name, packageVersion);
+      if (!usedPackage && this.packageLoader) {
+        try {
+          const packageDoc = yield this.packageLoader(name, packageVersion);
+          if (packageDoc) {
+            yield this.loadAndRegisterPackage(name, packageDoc, packageVersion);
+            usedPackage = this.packageRegistry.get(name, packageVersion);
+          }
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("Circular package dependency")) {
+            throw error;
+          }
+        }
+      }
       if (!usedPackage) {
         throw new Error(
-          `Package "${name}"${packageVersion ? `@${packageVersion}` : ""} not found. Packages must be loaded before they can be used.`
+          `Package "${name}"${packageVersion ? `@${packageVersion}` : ""} not found. ` + (this.packageLoader ? "Package loader failed to load the package." : "Packages must be loaded before they can be used.")
         );
       }
       const usedPkg = {
@@ -15199,8 +15498,22 @@ var Xslt = class {
       for (const child of template.childNodes) {
         if (this.isXsltElement(child, "accept")) {
           this.xsltAccept(context, child);
+        } else if (this.isXsltElement(child, "override")) {
+          yield this.xsltOverride(context, child, output);
         }
       }
+      yield this.registerAcceptedVariables(context);
+      this.registerUserDefinedFunctionsInContext(context);
+      usedPackage.components.forEach((component, key2) => {
+        if (component.visibility === "abstract") {
+          const hasOverride = this.currentPackage.overrides.has(key2);
+          if (!hasOverride) {
+            throw new Error(
+              `Abstract component "${component.name || component.match || key2}" from package "${name}" must be overridden.`
+            );
+          }
+        }
+      });
     });
   }
   /**
@@ -15224,16 +15537,69 @@ var Xslt = class {
       throw new Error('<xsl:expose> requires a "names" attribute.');
     }
     for (const name of nameList) {
-      const component = {
-        type: componentType,
-        name: name === "*" ? void 0 : name,
-        visibility,
-        overridable: visibility !== "final",
-        node: template
-      };
-      const key = makeComponentKey(component);
-      this.currentPackage.components.set(key, component);
+      const actualComponent = this.findComponentInPackageRoot(
+        this.currentPackage.root,
+        componentType,
+        name === "*" ? null : name
+      );
+      if (actualComponent) {
+        const component = {
+          type: componentType,
+          name: actualComponent.name || (name !== "*" ? name : void 0),
+          match: actualComponent.match,
+          mode: actualComponent.mode,
+          visibility,
+          overridable: visibility !== "final",
+          node: actualComponent.node,
+          priority: actualComponent.priority
+        };
+        const key = makeComponentKey(component);
+        this.currentPackage.components.set(key, component);
+      } else if (name !== "*") {
+      }
+    }
+  }
+  /**
+   * Find a component definition in the package root.
+   * @param packageRoot The package root element
+   * @param type The component type to find
+   * @param name The component name (null for all matching type)
+   * @returns Component information or null if not found
+   */
+  findComponentInPackageRoot(packageRoot, type, name) {
+    for (const child of packageRoot.childNodes) {
+      if (child.nodeType !== DOM_ELEMENT_NODE) {
+        continue;
+      }
+      if (type === "template" && this.isXsltElement(child, "template")) {
+        const templateName = xmlGetAttribute(child, "name");
+        const match = xmlGetAttribute(child, "match");
+        const mode = xmlGetAttribute(child, "mode");
+        if (name) {
+          if (templateName === name) {
+            return { node: child, name: templateName, match, mode };
+          }
+        } else {
+          return { node: child, name: templateName, match, mode };
+        }
+      } else if (type === "function" && this.isXsltElement(child, "function")) {
+        const functionName2 = xmlGetAttribute(child, "name");
+        if (!name || functionName2 === name) {
+          return { node: child, name: functionName2 };
+        }
+      } else if (type === "variable" && this.isXsltElement(child, "variable")) {
+        const varName = xmlGetAttribute(child, "name");
+        if (!name || varName === name) {
+          return { node: child, name: varName };
+        }
+      } else if (type === "attribute-set" && this.isXsltElement(child, "attribute-set")) {
+        const setName = xmlGetAttribute(child, "name");
+        if (!name || setName === name) {
+          return { node: child, name: setName };
+        }
+      }
     }
+    return null;
   }
   /**
    * Implements `<xsl:accept>` (XSLT 3.0 Section 3.9).
@@ -15247,6 +15613,7 @@ var Xslt = class {
     }
     const componentType = xmlGetAttribute(template, "component");
     const names = xmlGetAttribute(template, "names");
+    const visibilityOverride = xmlGetAttribute(template, "visibility");
     if (!componentType) {
       throw new Error('<xsl:accept> requires a "component" attribute.');
     }
@@ -15265,17 +15632,325 @@ var Xslt = class {
     if (!usedPkg) {
       throw new Error(`Internal error: used package "${key}" not found.`);
     }
-    for (const name of nameList) {
-      const component = {
-        type: componentType,
-        name: name === "*" ? void 0 : name,
-        visibility: "public",
-        overridable: true,
+    const componentsToAccept = this.findComponentsInPackage(
+      usedPkg.package,
+      componentType,
+      nameList
+    );
+    for (const component of componentsToAccept) {
+      if (!isComponentVisible(component, false)) {
+        const componentName = component.name || component.match || "unnamed";
+        throw new Error(
+          `Cannot accept private component "${componentName}" of type "${componentType}" from package "${usedPkg.package.name}".`
+        );
+      }
+      const acceptedComponent = __spreadProps(__spreadValues({}, component), {
+        sourcePackage: usedPkg.package.name,
+        isAccepted: true,
+        effectiveVisibility: visibilityOverride || component.visibility
+      });
+      const componentKey = makeComponentKey(acceptedComponent);
+      usedPkg.acceptedComponents.set(componentKey, acceptedComponent);
+    }
+  }
+  /**
+   * Implements <xsl:override> (XSLT 3.0 Section 3.7.2).
+   * Overrides components from a used package.
+   */
+  xsltOverride(context, template, output) {
+    return __async(this, null, function* () {
+      if (!this.currentPackage) {
+        throw new Error("<xsl:override> can only appear as a child of <xsl:use-package>.");
+      }
+      const parentUsePackage = template.parentNode;
+      if (!parentUsePackage || !this.isXsltElement(parentUsePackage, "use-package")) {
+        throw new Error("<xsl:override> must be a child of <xsl:use-package>.");
+      }
+      const packageName = xmlGetAttribute(parentUsePackage, "name");
+      const packageVersion = xmlGetAttribute(parentUsePackage, "package-version");
+      const key = packageVersion ? `${packageName}@${packageVersion}` : packageName;
+      const usedPkg = this.currentPackage.usedPackages.get(key);
+      if (!usedPkg) {
+        throw new Error(`Internal error: used package "${key}" not found.`);
+      }
+      for (let i = 0; i < template.childNodes.length; i++) {
+        const child = template.childNodes[i];
+        if (child.nodeType !== DOM_ELEMENT_NODE) {
+          continue;
+        }
+        const localName = child.localName;
+        let componentType = null;
+        let componentName = null;
+        let componentMatch = null;
+        switch (localName) {
+          case "template":
+            componentType = "template";
+            componentName = xmlGetAttribute(child, "name");
+            componentMatch = xmlGetAttribute(child, "match");
+            break;
+          case "function":
+            componentType = "function";
+            componentName = xmlGetAttribute(child, "name");
+            break;
+          case "variable":
+            componentType = "variable";
+            componentName = xmlGetAttribute(child, "name");
+            break;
+          case "attribute-set":
+            componentType = "attribute-set";
+            componentName = xmlGetAttribute(child, "name");
+            break;
+          default:
+            throw new Error(`<xsl:override> does not support <xsl:${localName}> elements.`);
+        }
+        if (!componentType) {
+          continue;
+        }
+        let originalComponent;
+        usedPkg.acceptedComponents.forEach((component) => {
+          if (component.type !== componentType) {
+            return;
+          }
+          if (componentName && component.name === componentName) {
+            originalComponent = component;
+          } else if (componentMatch && component.match === componentMatch) {
+            originalComponent = component;
+          }
+        });
+        if (!originalComponent) {
+          usedPkg.package.components.forEach((component) => {
+            if (component.type !== componentType) {
+              return;
+            }
+            if (componentName && component.name === componentName) {
+              originalComponent = component;
+            } else if (componentMatch && component.match === componentMatch) {
+              originalComponent = component;
+            }
+          });
+        }
+        if (!originalComponent) {
+          const identifier = componentName || componentMatch || "unnamed";
+          throw new Error(
+            `Cannot override component "${identifier}" of type "${componentType}": component not found in package "${usedPkg.package.name}".`
+          );
+        }
+        if (!canOverrideComponent(originalComponent)) {
+          const identifier = componentName || componentMatch || "unnamed";
+          throw new Error(
+            `Cannot override component "${identifier}" of type "${componentType}": component is marked as "final" in package "${usedPkg.package.name}".`
+          );
+        }
+        const overridingComponent = {
+          type: componentType,
+          name: componentName || void 0,
+          match: componentMatch || void 0,
+          mode: xmlGetAttribute(child, "mode") || void 0,
+          visibility: originalComponent.visibility,
+          // Inherit visibility from original
+          overridable: false,
+          // Overrides cannot themselves be overridden (unless explicitly marked)
+          node: child,
+          sourcePackage: this.currentPackage.name,
+          isAccepted: false,
+          effectiveVisibility: originalComponent.visibility
+        };
+        overridingComponent.originalComponent = originalComponent;
+        overridingComponent.node.__originalComponent = originalComponent;
+        const componentKey = makeComponentKey(originalComponent);
+        this.currentPackage.overrides.set(componentKey, overridingComponent);
+        if (componentType === "function") {
+          this.xsltFunction(context, child);
+        }
+      }
+    });
+  }
+  /**
+   * Find components in a package matching the given criteria.
+   * Used by xsl:accept to locate components from used packages.
+   * 
+   * @param pkg The package to search in
+   * @param componentType The type of component to find
+   * @param namePatterns Array of name patterns ('*' for all, or specific names)
+   * @returns Array of matching components
+   */
+  findComponentsInPackage(pkg, componentType, namePatterns) {
+    const results = [];
+    const isWildcard = namePatterns.includes("*");
+    pkg.components.forEach((component, key) => {
+      if (component.type !== componentType) {
+        return;
+      }
+      if (isWildcard) {
+        results.push(component);
+        return;
+      }
+      const componentName = this.getComponentNameForMatching(component);
+      if (componentName && namePatterns.includes(componentName)) {
+        results.push(component);
+      }
+    });
+    return results;
+  }
+  /**
+   * Get the name to use when matching components.
+   * For named components (functions, variables, attribute-sets), returns the name.
+   * For templates, returns the name if present, otherwise returns null (match-based templates).
+   * 
+   * @param component The component to get the name from
+   * @returns The component name for matching, or null if unnamed
+   */
+  getComponentNameForMatching(component) {
+    switch (component.type) {
+      case "function":
+      case "variable":
+      case "attribute-set":
+      case "mode":
+        return component.name || null;
+      case "template":
+        return component.name || null;
+      default:
+        return null;
+    }
+  }
+  /**
+   * Implements <xsl:original> (XSLT 3.0 Section 3.7.2).
+   * Calls the original component from within an override.
+   */
+  xsltOriginal(context, template, output) {
+    return __async(this, null, function* () {
+      if (!this.currentOverrideContext && this.currentTemplateStack.length > 0) {
+        const currentTemplate = this.currentTemplateStack[this.currentTemplateStack.length - 1].template;
+        const templateOverrideContext = currentTemplate.__originalComponent;
+        if (templateOverrideContext) {
+          this.currentOverrideContext = templateOverrideContext;
+        }
+      }
+      if (!this.currentOverrideContext) {
+        throw new Error("<xsl:original> can only be used within an overriding component.");
+      }
+      const originalComponent = this.currentOverrideContext;
+      const originalNode = originalComponent.node;
+      switch (originalComponent.type) {
+        case "template":
+          yield this.xsltChildNodes(context, originalNode, output);
+          break;
+        case "function":
+          throw new Error("<xsl:original> for functions should be called as a function, not as an element.");
+        case "variable":
+          yield this.xsltVariable(context, originalNode, true);
+          break;
+        case "attribute-set":
+          if (originalComponent.name && output) {
+            yield this.applyAttributeSets(context, output, originalComponent.name);
+          }
+          break;
+        default:
+          throw new Error(`<xsl:original> does not support component type "${originalComponent.type}".`);
+      }
+    });
+  }
+  /**
+   * Implements `<xsl:mode>` (XSLT 3.0 Section 3.5).
+   * Declares a mode with visibility and other properties.
+   * Only valid within an xsl:package.
+   */
+  xsltMode(context, template) {
+    if (!this.currentPackage) {
+      throw new Error("<xsl:mode> can only appear as a child of <xsl:package>.");
+    }
+    const name = xmlGetAttribute(template, "name");
+    if (!name) {
+      throw new Error('<xsl:mode> requires a "name" attribute.');
+    }
+    const visibility = xmlGetAttribute(template, "visibility") || "public";
+    const streamableAttr = xmlGetAttribute(template, "streamable");
+    const onNoMatch = xmlGetAttribute(template, "on-no-match");
+    const onMultipleMatch = xmlGetAttribute(template, "on-multiple-match");
+    const streamable = streamableAttr === "yes";
+    if (!this.currentPackage.modes) {
+      this.currentPackage.modes = /* @__PURE__ */ new Map();
+    }
+    const modeProperties = {
+      name,
+      visibility,
+      streamable,
+      onNoMatch,
+      onMultipleMatch
+    };
+    this.currentPackage.modes.set(name, modeProperties);
+    const componentKey = makeComponentKey({ type: "mode", name, visibility });
+    if (!this.currentPackage.components.has(componentKey)) {
+      this.currentPackage.components.set(componentKey, {
+        type: "mode",
+        name,
+        visibility,
+        overridable: false,
         node: template
-      };
-      const componentKey = makeComponentKey(component);
-      usedPkg.acceptedComponents.set(componentKey, component);
+      });
+    }
+  }
+  /**
+   * Get the effective component, checking for overrides first.
+   * If the component has been overridden in the current package, returns the override.
+   * Otherwise, returns the original component.
+   * @param component The original component
+   * @returns The effective component (override or original)
+   */
+  getEffectiveComponent(component) {
+    if (!this.currentPackage) {
+      return component;
     }
+    const componentKey = makeComponentKey(component);
+    const override = this.currentPackage.overrides.get(componentKey);
+    return override || component;
+  }
+  /**
+   * Collect templates from accepted components in used packages.
+   * @param mode The mode to match (null for default mode)
+   * @returns Array of template priority interfaces
+   */
+  collectAcceptedTemplates(mode) {
+    const templates = [];
+    if (!this.currentPackage) {
+      return templates;
+    }
+    this.currentPackage.usedPackages.forEach((usedPkg, packageKey) => {
+      usedPkg.acceptedComponents.forEach((component, componentKey) => {
+        if (component.type === "template" && component.isAccepted) {
+          const effectiveComponent = this.getEffectiveComponent(component);
+          const templateNode = effectiveComponent.node;
+          const isOverride = effectiveComponent !== component;
+          const originalForContext = isOverride ? component : void 0;
+          const templateMode = xmlGetAttribute(templateNode, "mode") || null;
+          const effectiveMode = mode || null;
+          if (effectiveMode !== templateMode) {
+            return;
+          }
+          const match = xmlGetAttribute(templateNode, "match");
+          if (!match) {
+            return;
+          }
+          const priorityAttr = xmlGetAttribute(templateNode, "priority");
+          const explicitPriority = priorityAttr ? parseFloat(priorityAttr) : null;
+          const defaultPriority = component.priority || 0;
+          const effectivePriority = explicitPriority !== null && !isNaN(explicitPriority) ? explicitPriority : defaultPriority;
+          templates.push({
+            template: templateNode,
+            explicitPriority: explicitPriority !== null && !isNaN(explicitPriority) ? explicitPriority : null,
+            defaultPriority,
+            effectivePriority,
+            importPrecedence: 0,
+            // Accepted templates have neutral precedence
+            documentOrder: 0,
+            matchPattern: match,
+            originalComponent: originalForContext
+            // Store original for xsl:original support
+          });
+        }
+      });
+    });
+    return templates;
   }
   /**
    * Implements `<xsl:stream>` (XSLT 3.0 Section 16).
@@ -16364,6 +17039,30 @@ var Xslt = class {
     }
     this.userDefinedFunctions.set(name, template);
   }
+  /**
+   * Coerce a NodeValue to a specific type based on the 'as' attribute.
+   * 
+   * @param value The value to coerce.
+   * @param type The target type (e.g., "xs:integer", "xs:string", "xs:boolean").
+   * @returns The coerced value.
+   */
+  coerceToType(value, type) {
+    const normalizedType = type.replace(/^xs:/, "").toLowerCase();
+    switch (normalizedType) {
+      case "integer":
+      case "int":
+      case "double":
+      case "decimal":
+      case "number":
+        return new NumberValue(value.numberValue());
+      case "string":
+        return new StringValue(value.stringValue());
+      case "boolean":
+        return new BooleanValue(value.booleanValue());
+      default:
+        return value;
+    }
+  }
   /**
    * Execute a user-defined xsl:function.
    * Called when a function from userDefinedFunctions is invoked from XPath.
@@ -16401,18 +17100,32 @@ var Xslt = class {
       const paramName = xmlGetAttribute(params[i], "name");
       if (paramName) {
         if (i < args.length) {
-          const argValue = args[i];
+          let argValue = args[i];
+          const paramType = xmlGetAttribute(params[i], "as");
+          let paramValue;
           if (argValue && typeof argValue === "object" && "stringValue" in argValue) {
-            functionContext.setVariable(paramName, argValue);
+            paramValue = argValue;
+            if (paramType) {
+              paramValue = this.coerceToType(paramValue, paramType);
+            }
+          } else if (argValue && typeof argValue === "object" && "nodeType" in argValue) {
+            paramValue = new NodeSetValue([argValue]);
+            if (paramType) {
+              paramValue = this.coerceToType(paramValue, paramType);
+            }
           } else if (Array.isArray(argValue)) {
-            functionContext.setVariable(paramName, new NodeSetValue(argValue));
+            paramValue = new NodeSetValue(argValue);
+            if (paramType) {
+              paramValue = this.coerceToType(paramValue, paramType);
+            }
           } else if (typeof argValue === "number") {
-            functionContext.setVariable(paramName, new NumberValue(argValue));
+            paramValue = new NumberValue(argValue);
           } else if (typeof argValue === "boolean") {
-            functionContext.setVariable(paramName, new BooleanValue(argValue));
+            paramValue = new BooleanValue(argValue);
           } else {
-            functionContext.setVariable(paramName, new StringValue(String(argValue != null ? argValue : "")));
+            paramValue = new StringValue(String(argValue != null ? argValue : ""));
           }
+          functionContext.setVariable(paramName, paramValue);
         } else {
           const selectExpr = xmlGetAttribute(params[i], "select");
           if (selectExpr) {
@@ -16491,6 +17204,30 @@ var Xslt = class {
   getResultDocuments() {
     return this.resultDocuments;
   }
+  /**
+   * Sets the package loader callback.
+   * The callback is called when a package is referenced via xsl:use-package
+   * but is not found in the registry.
+   * 
+   * @param loader A function that loads package documents by URI and optional version.
+   *               Returns the parsed package document, or null if not found.
+   */
+  setPackageLoader(loader) {
+    this.packageLoader = loader;
+  }
+  /**
+   * Pre-registers a package for use in transformations.
+   * The package is parsed and stored in the internal registry.
+   * 
+   * @param name The package name/URI.
+   * @param packageDoc The parsed package document.
+   * @param version Optional semantic version string.
+   */
+  registerPackage(name, packageDoc, version) {
+    return __async(this, null, function* () {
+      yield this.loadAndRegisterPackage(name, packageDoc, version);
+    });
+  }
   /**
    * Implements `xsl:perform-sort` (XSLT 2.0).
    *
@@ -16605,6 +17342,25 @@ var Xslt = class {
       }
     });
   }
+  /**
+   * Register accepted variables from used packages into the context.
+   * Called after processing package use-package declarations.
+   * @param context The expression context.
+   */
+  registerAcceptedVariables(context) {
+    return __async(this, null, function* () {
+      if (!this.currentPackage) {
+        return;
+      }
+      this.currentPackage.usedPackages.forEach((usedPkg, packageKey) => {
+        usedPkg.acceptedComponents.forEach((component, componentKey) => {
+          if (component.type === "variable" && component.name && component.isAccepted) {
+            this.xsltVariable(context, component.node, false);
+          }
+        });
+      });
+    });
+  }
   /**
    * Traverses the template node tree. Calls the main processing
    * function with the current input context for every child node of the
@@ -16699,13 +17455,7 @@ var Xslt = class {
           node = context.nodeList[context.position];
           let newNode;
           newNode = domCreateElement(this.outputDocument, template.nodeName);
-          if (node && node.siblingPosition !== void 0) {
-            newNode.siblingPosition = node.siblingPosition;
-          } else if (node === void 0 && context.nodeList.length === 0) {
-            newNode.siblingPosition = (output || this.outputDocument).childNodes.length;
-          } else {
-            newNode.siblingPosition = 0;
-          }
+          newNode.siblingPosition = (output || this.outputDocument).childNodes.length;
           domAppendChild(output || this.outputDocument, newNode);
           const useAttributeSetsAttr = template.childNodes.find(
             (a) => (a == null ? void 0 : a.nodeType) === DOM_ATTRIBUTE_NODE && a.nodeName === "use-attribute-sets"
@@ -16944,7 +17694,7 @@ var Xslt = class {
    * @param context The expression context.
    */
   registerUserDefinedFunctionsInContext(context) {
-    if (this.userDefinedFunctions.size === 0) {
+    if (this.userDefinedFunctions.size === 0 && !this.hasAcceptedFunctions()) {
       return;
     }
     const functionsMap = /* @__PURE__ */ new Map();
@@ -16956,8 +17706,48 @@ var Xslt = class {
         }
       });
     });
+    this.registerAcceptedFunctions(functionsMap);
     context.userDefinedFunctions = functionsMap;
   }
+  /**
+   * Check if there are any accepted functions in used packages.
+   */
+  hasAcceptedFunctions() {
+    if (!this.currentPackage) {
+      return false;
+    }
+    let hasAccepted = false;
+    this.currentPackage.usedPackages.forEach((usedPkg) => {
+      usedPkg.acceptedComponents.forEach((component) => {
+        if (component.type === "function" && component.isAccepted) {
+          hasAccepted = true;
+        }
+      });
+    });
+    return hasAccepted;
+  }
+  /**
+   * Register accepted functions from used packages.
+   * @param functionsMap The map to register functions into.
+   */
+  registerAcceptedFunctions(functionsMap) {
+    if (!this.currentPackage) {
+      return;
+    }
+    this.currentPackage.usedPackages.forEach((usedPkg, packageKey) => {
+      usedPkg.acceptedComponents.forEach((component, componentKey) => {
+        if (component.type === "function" && component.name && component.isAccepted) {
+          const effectiveComponent = this.getEffectiveComponent(component);
+          functionsMap.set(component.name, {
+            functionDef: effectiveComponent.node,
+            executor: (ctx, funcDef, args) => {
+              return this.executeUserDefinedFunctionSync(ctx, funcDef, args);
+            }
+          });
+        }
+      });
+    });
+  }
   /**
    * Apply one or more attribute sets to an element.
    * Parses space-separated attribute set names and applies them.