xslt-processor 4.6.0 → 4.7.0

package/index.d.mts

@@ -132,6 +132,217 @@ declare class XmlParser {
     private xmlStrictParse;
 }
 
+type XsltParameter = {
+    name: string;
+    namespaceUri?: string;
+    value: any;
+};
+
+/**
+ * According to https://www.w3schools.com/xml/ref_xsl_el_decimal-format.asp:
+ *
+ * @property {string} name: Optional. Specifies a name for this format.
+ * @property {string} decimalSeparator: Optional. Specifies the decimal point character. Default is ".".
+ * @property {string} groupingSeparator: Optional. Specifies the thousands separator character. Default is ",".
+ * @property {string} infinity: Optional. Specifies the string used to represent infinity. Default is "Infinity".
+ * @property {string} minusSign: Optional. Specifies the character to represent negative numbers. Default is "-".
+ * @property {string} naN: Optional. Specifies the string used when the value is not a number". Default is "NaN".
+ * @property {string} percent: Optional. Specifies the percentage sign character. Default is "%".
+ * @property {string} perMille: Optional. Specifies the per thousand sign character. Default is "‰".
+ * @property {string} zeroDigit: Optional. Specifies the digit zero character. Default is "0".
+ * @property {string} digit: Optional. Specifies the character used to indicate a place where a digit is required. Default is #.
+ * @property {string} patternSeparator: Optional. Specifies the character used to separate positive and negative subpatterns in a format pattern. Default is ";".
+ */
+type XsltDecimalFormatSettings = {
+    name?: string;
+    decimalSeparator: string;
+    groupingSeparator: string;
+    infinity: string;
+    minusSign: string;
+    naN: string;
+    percent: string;
+    perMille: string;
+    zeroDigit: string;
+    digit: string;
+    patternSeparator: string;
+};
+type XsltOptions = {
+    cData: boolean;
+    escape: boolean;
+    selfClosingTags: boolean;
+    outputMethod?: 'xml' | 'html' | 'text' | 'xhtml' | 'json' | 'adaptive';
+    parameters?: XsltParameter[];
+};
+
+interface NodeValue {
+    type: string;
+    stringValue(): string;
+    booleanValue(): boolean;
+    numberValue(): number;
+    nodeSetValue(): XNode[];
+}
+
+/**
+ * XPath expression evaluation context. An XPath context consists of a
+ * DOM node, a list of DOM nodes that contains this node, a number
+ * that represents the position of the single node in the list, and a
+ * current set of variable bindings. (See XPath spec.)
+ *
+ *   setVariable(name, expr) -- binds given XPath expression to the
+ *   name.
+ *
+ *   getVariable(name) -- what the name says.
+ *
+ *   setNode(position) -- sets the context to the node at the given
+ *   position. Needed to implement scoping rules for variables in
+ *   XPath. (A variable is visible to all subsequent siblings, not
+ *   only to its children.)
+ *
+ *   set/isCaseInsensitive -- specifies whether node name tests should
+ *   be case sensitive.  If you're executing xpaths against a regular
+ *   HTML DOM, you probably don't want case-sensitivity, because
+ *   browsers tend to disagree about whether elements & attributes
+ *   should be upper/lower case.  If you're running xpaths in an
+ *   XSLT instance, you probably DO want case sensitivity, as per the
+ *   XSL spec.
+ *
+ *   set/isReturnOnFirstMatch -- whether XPath evaluation should quit as soon
+ *   as a result is found. This is an optimization that might make sense if you
+ *   only care about the first result.
+ *
+ *   set/isIgnoreNonElementNodesForNTA -- whether to ignore non-element nodes
+ *   when evaluating the "node()" any node test. While technically this is
+ *   contrary to the XPath spec, practically it can enhance performance
+ *   significantly, and makes sense if you a) use "node()" when you mean "*",
+ *   and b) use "//" when you mean "/descendant::* /".
+ */
+declare class ExprContext {
+    position: number;
+    nodeList: XNode[];
+    xsltVersion: '1.0' | '2.0' | '3.0';
+    variables: {
+        [name: string]: NodeValue;
+    };
+    keys: {
+        [name: string]: {
+            [key: string]: NodeValue;
+        };
+    };
+    knownNamespaces: {
+        [alias: string]: string;
+    };
+    /**
+     * Custom system properties for system-property() function.
+     * Overrides the default properties (xsl:version, xsl:vendor, xsl:vendor-url).
+     */
+    systemProperties?: {
+        [name: string]: string;
+    };
+    /**
+     * Document loader function for the document() function.
+     * Takes a URI and returns an XNode document, or null if loading fails.
+     */
+    documentLoader?: (uri: string) => XNode | null;
+    /**
+     * Unparsed entity URIs for the unparsed-entity-uri() function.
+     * Maps entity names to their URIs (from DTD declarations).
+     */
+    unparsedEntities?: {
+        [name: string]: string;
+    };
+    /**
+     * Warning callback for non-fatal XPath/XSLT warnings.
+     */
+    warningsCallback?: (...args: any[]) => void;
+    caseInsensitive: any;
+    ignoreAttributesWithoutValue: any;
+    returnOnFirstMatch: any;
+    ignoreNonElementNodesForNTA: any;
+    parent: ExprContext;
+    root: XNode;
+    decimalFormatSettings: XsltDecimalFormatSettings;
+    inApplyTemplates: boolean;
+    baseTemplateMatched: boolean;
+    /**
+     * Regex groups from xsl:analyze-string for regex-group() function.
+     * Index 0 is the full match, 1+ are captured groups.
+     */
+    regexGroups?: string[];
+    /**
+     * Current group from xsl:for-each-group for current-group() function.
+     * Contains the nodes/items in the current group being processed.
+     */
+    currentGroup?: XNode[];
+    /**
+     * Current grouping key from xsl:for-each-group for current-grouping-key() function.
+     * Contains the key value of the current group being processed.
+     */
+    currentGroupingKey?: any;
+    /**
+     * Constructor -- gets the node, its position, the node set it
+     * belongs to, and a parent context as arguments. The parent context
+     * is used to implement scoping rules for variables: if a variable
+     * is not found in the current context, it is looked for in the
+     * parent context, recursively. Except for node, all arguments have
+     * default values: default position is 0, default node set is the
+     * set that contains only the node, and the default parent is null.
+     *
+     * Notice that position starts at 0 at the outside interface;
+     * inside XPath expressions this shows up as position()=1.
+     * @param nodeList TODO
+     * @param opt_position TODO
+     * @param opt_parent TODO
+     * @param opt_caseInsensitive TODO
+     * @param opt_ignoreAttributesWithoutValue TODO
+     * @param opt_returnOnFirstMatch TODO
+     * @param opt_ignoreNonElementNodesForNTA TODO
+     */
+    constructor(nodeList: XNode[], xsltVersion?: '1.0' | '2.0' | '3.0', opt_position?: number, opt_decimalFormatSettings?: XsltDecimalFormatSettings, opt_variables?: {
+        [name: string]: any;
+    }, opt_knownNamespaces?: {
+        [alias: string]: string;
+    }, opt_parent?: ExprContext, opt_caseInsensitive?: any, opt_ignoreAttributesWithoutValue?: any, opt_returnOnFirstMatch?: any, opt_ignoreNonElementNodesForNTA?: any, opt_warningsCallback?: (...args: any[]) => void);
+    /**
+     * clone() -- creates a new context with the current context as
+     * parent. If passed as argument to clone(), the new context has a
+     * different node, position, or node set. What is not passed is
+     * inherited from the cloned context.
+     * @param opt_nodeList TODO
+     * @param opt_position TODO
+     * @returns TODO
+     */
+    clone(opt_nodeList?: XNode[], opt_position?: number): ExprContext;
+    setVariable(name?: string, value?: NodeValue | string): void;
+    getVariable(name: string): NodeValue;
+    /**
+     * Gets a regex group from xsl:analyze-string context.
+     * Searches up the parent chain for regexGroups.
+     * @param index Group index (0 = full match, 1+ = captured groups)
+     * @returns The group value or empty string if not found
+     */
+    getRegexGroup(index: number): string;
+    setNode(position: number): void;
+    contextSize(): number;
+    isCaseInsensitive(): any;
+    setCaseInsensitive(caseInsensitive: any): any;
+    isIgnoreAttributesWithoutValue(): any;
+    setIgnoreAttributesWithoutValue(ignore: any): any;
+    isReturnOnFirstMatch(): any;
+    setReturnOnFirstMatch(returnOnFirstMatch: any): any;
+    isIgnoreNonElementNodesForNTA(): any;
+    setIgnoreNonElementNodesForNTA(ignoreNonElementNodesForNTA: any): any;
+}
+
+/**
+ * XPath version support and configuration.
+ *
+ * This module defines version-specific behavior and prepares for future XPath 2.0/3.0 support.
+ */
+/**
+ * Supported XPath specification versions.
+ */
+type XPathVersion = '1.0' | '2.0' | '3.0' | '3.1';
+
 /**
  * Represents a DOM-like node interface for XPath evaluation.
  * This is compatible with browser DOM nodes and can be extended for other implementations.
@@ -278,224 +489,59 @@ interface XPathContext {
      */
     extensions?: Record<string, any>;
     /**
-     * Current dateTime in the dynamic context (XPath 2.0+).
-     * Returned by fn:current-dateTime().
-     * If not provided, defaults to system time when accessed.
-     */
-    currentDateTime?: Date;
-    /**
-     * Available documents mapping for fn:doc() function (XPath 2.0+).
-     * Maps document URIs to their root document nodes.
-     * Example: { "http://example.com/data.xml": rootNode }
-     */
-    availableDocuments?: XPathDocuments;
-    /**
-     * Available collections mapping for fn:collection() function (XPath 2.0+).
-     * Maps collection URIs to sequences of nodes.
-     * Example: { "http://example.com/collection": [node1, node2, ...] }
-     */
-    availableCollections?: XPathCollections;
-    /**
-     * Default collection URI when fn:collection() is called without arguments (XPath 2.0+).
-     * If provided, fn:collection() returns availableCollections[defaultCollection].
-     */
-    defaultCollection?: string;
-    /**
-     * Function implementations registry (XPath 2.0+).
-     * Maps QName function names to their implementations.
-     * Allows defining custom/XSLT functions at evaluation time.
-     * Format: "localName" or "prefix:localName"
-     */
-    functionRegistry?: XPathFunctionRegistry;
-}
-/**
- * Result types that can be returned from XPath evaluation.
- *
- * XPath 1.0: node-set, string, number, boolean
- * XPath 2.0+: sequences (which subsume node-sets), atomic values, functions
- */
-type XPathResult = XPathNode[] | string | number | boolean | any[] | Map<any, any> | null | Function;
-
-declare abstract class XPathExpression {
-    abstract evaluate(context: XPathContext): XPathResult;
-}
-
-/**
- * According to https://www.w3schools.com/xml/ref_xsl_el_decimal-format.asp:
- *
- * @property {string} name: Optional. Specifies a name for this format.
- * @property {string} decimalSeparator: Optional. Specifies the decimal point character. Default is ".".
- * @property {string} groupingSeparator: Optional. Specifies the thousands separator character. Default is ",".
- * @property {string} infinity: Optional. Specifies the string used to represent infinity. Default is "Infinity".
- * @property {string} minusSign: Optional. Specifies the character to represent negative numbers. Default is "-".
- * @property {string} naN: Optional. Specifies the string used when the value is not a number". Default is "NaN".
- * @property {string} percent: Optional. Specifies the percentage sign character. Default is "%".
- * @property {string} perMille: Optional. Specifies the per thousand sign character. Default is "‰".
- * @property {string} zeroDigit: Optional. Specifies the digit zero character. Default is "0".
- * @property {string} digit: Optional. Specifies the character used to indicate a place where a digit is required. Default is #.
- * @property {string} patternSeparator: Optional. Specifies the character used to separate positive and negative subpatterns in a format pattern. Default is ";".
- */
-type XsltDecimalFormatSettings = {
-    name?: string;
-    decimalSeparator: string;
-    groupingSeparator: string;
-    infinity: string;
-    minusSign: string;
-    naN: string;
-    percent: string;
-    perMille: string;
-    zeroDigit: string;
-    digit: string;
-    patternSeparator: string;
-};
-
-interface NodeValue {
-    stringValue(): string;
-    booleanValue(): boolean;
-    numberValue(): number;
-    nodeSetValue(): XNode[];
-}
-
-/**
- * XPath expression evaluation context. An XPath context consists of a
- * DOM node, a list of DOM nodes that contains this node, a number
- * that represents the position of the single node in the list, and a
- * current set of variable bindings. (See XPath spec.)
- *
- *   setVariable(name, expr) -- binds given XPath expression to the
- *   name.
- *
- *   getVariable(name) -- what the name says.
- *
- *   setNode(position) -- sets the context to the node at the given
- *   position. Needed to implement scoping rules for variables in
- *   XPath. (A variable is visible to all subsequent siblings, not
- *   only to its children.)
- *
- *   set/isCaseInsensitive -- specifies whether node name tests should
- *   be case sensitive.  If you're executing xpaths against a regular
- *   HTML DOM, you probably don't want case-sensitivity, because
- *   browsers tend to disagree about whether elements & attributes
- *   should be upper/lower case.  If you're running xpaths in an
- *   XSLT instance, you probably DO want case sensitivity, as per the
- *   XSL spec.
- *
- *   set/isReturnOnFirstMatch -- whether XPath evaluation should quit as soon
- *   as a result is found. This is an optimization that might make sense if you
- *   only care about the first result.
- *
- *   set/isIgnoreNonElementNodesForNTA -- whether to ignore non-element nodes
- *   when evaluating the "node()" any node test. While technically this is
- *   contrary to the XPath spec, practically it can enhance performance
- *   significantly, and makes sense if you a) use "node()" when you mean "*",
- *   and b) use "//" when you mean "/descendant::* /".
- */
-declare class ExprContext {
-    position: number;
-    nodeList: XNode[];
-    xsltVersion: '1.0' | '2.0' | '3.0';
-    variables: {
-        [name: string]: NodeValue;
-    };
-    keys: {
-        [name: string]: {
-            [key: string]: NodeValue;
-        };
-    };
-    knownNamespaces: {
-        [alias: string]: string;
-    };
-    /**
-     * Custom system properties for system-property() function.
-     * Overrides the default properties (xsl:version, xsl:vendor, xsl:vendor-url).
+     * Current dateTime in the dynamic context (XPath 2.0+).
+     * Returned by fn:current-dateTime().
+     * If not provided, defaults to system time when accessed.
      */
-    systemProperties?: {
-        [name: string]: string;
-    };
+    currentDateTime?: Date;
     /**
-     * Document loader function for the document() function.
-     * Takes a URI and returns an XNode document, or null if loading fails.
+     * Available documents mapping for fn:doc() function (XPath 2.0+).
+     * Maps document URIs to their root document nodes.
+     * Example: { "http://example.com/data.xml": rootNode }
      */
-    documentLoader?: (uri: string) => XNode | null;
+    availableDocuments?: XPathDocuments;
     /**
-     * Unparsed entity URIs for the unparsed-entity-uri() function.
-     * Maps entity names to their URIs (from DTD declarations).
+     * Available collections mapping for fn:collection() function (XPath 2.0+).
+     * Maps collection URIs to sequences of nodes.
+     * Example: { "http://example.com/collection": [node1, node2, ...] }
      */
-    unparsedEntities?: {
-        [name: string]: string;
-    };
-    caseInsensitive: any;
-    ignoreAttributesWithoutValue: any;
-    returnOnFirstMatch: any;
-    ignoreNonElementNodesForNTA: any;
-    parent: ExprContext;
-    root: XNode;
-    decimalFormatSettings: XsltDecimalFormatSettings;
-    inApplyTemplates: boolean;
-    baseTemplateMatched: boolean;
+    availableCollections?: XPathCollections;
     /**
-     * Constructor -- gets the node, its position, the node set it
-     * belongs to, and a parent context as arguments. The parent context
-     * is used to implement scoping rules for variables: if a variable
-     * is not found in the current context, it is looked for in the
-     * parent context, recursively. Except for node, all arguments have
-     * default values: default position is 0, default node set is the
-     * set that contains only the node, and the default parent is null.
-     *
-     * Notice that position starts at 0 at the outside interface;
-     * inside XPath expressions this shows up as position()=1.
-     * @param nodeList TODO
-     * @param opt_position TODO
-     * @param opt_parent TODO
-     * @param opt_caseInsensitive TODO
-     * @param opt_ignoreAttributesWithoutValue TODO
-     * @param opt_returnOnFirstMatch TODO
-     * @param opt_ignoreNonElementNodesForNTA TODO
+     * Default collection URI when fn:collection() is called without arguments (XPath 2.0+).
+     * If provided, fn:collection() returns availableCollections[defaultCollection].
      */
-    constructor(nodeList: XNode[], xsltVersion?: '1.0' | '2.0' | '3.0', opt_position?: number, opt_decimalFormatSettings?: XsltDecimalFormatSettings, opt_variables?: {
-        [name: string]: any;
-    }, opt_knownNamespaces?: {
-        [alias: string]: string;
-    }, opt_parent?: ExprContext, opt_caseInsensitive?: any, opt_ignoreAttributesWithoutValue?: any, opt_returnOnFirstMatch?: any, opt_ignoreNonElementNodesForNTA?: any);
+    defaultCollection?: string;
     /**
-     * clone() -- creates a new context with the current context as
-     * parent. If passed as argument to clone(), the new context has a
-     * different node, position, or node set. What is not passed is
-     * inherited from the cloned context.
-     * @param opt_nodeList TODO
-     * @param opt_position TODO
-     * @returns TODO
+     * Function implementations registry (XPath 2.0+).
+     * Maps QName function names to their implementations.
+     * Allows defining custom/XSLT functions at evaluation time.
+     * Format: "localName" or "prefix:localName"
      */
-    clone(opt_nodeList?: XNode[], opt_position?: number): ExprContext;
-    setVariable(name?: string, value?: NodeValue | string): void;
-    getVariable(name: string): NodeValue;
-    setNode(position: number): void;
-    contextSize(): number;
-    isCaseInsensitive(): any;
-    setCaseInsensitive(caseInsensitive: any): any;
-    isIgnoreAttributesWithoutValue(): any;
-    setIgnoreAttributesWithoutValue(ignore: any): any;
-    isReturnOnFirstMatch(): any;
-    setReturnOnFirstMatch(returnOnFirstMatch: any): any;
-    isIgnoreNonElementNodesForNTA(): any;
-    setIgnoreNonElementNodesForNTA(ignoreNonElementNodesForNTA: any): any;
+    functionRegistry?: XPathFunctionRegistry;
 }
-
 /**
- * Expression wrapper that provides backward-compatible interface.
- * Wraps new XPath expressions to work with old ExprContext.
+ * Represents an XPath 3.0 function item.
+ * This is a simplified interface to avoid circular dependencies.
  */
-declare class Expression {
-    protected xpathExpression: XPathExpression;
-    protected nodeConverter: NodeConverter;
-    absolute?: boolean;
-    steps?: any[];
-    constructor(xpathExpression: XPathExpression, nodeConverter: NodeConverter);
-    /**
-     * Evaluate the expression in the given context.
-     */
-    evaluate(context: ExprContext): NodeValue;
+interface XPathFunctionItem {
+    __isFunctionItem: true;
+    implementation: (...args: any[]) => any;
+    arity: number;
+    name?: string;
+    namespace?: string;
+}
+/**
+ * Result types that can be returned from XPath evaluation.
+ *
+ * XPath 1.0: node-set, string, number, boolean
+ * XPath 2.0+: sequences (which subsume node-sets), atomic values, functions
+ */
+type XPathResult = XPathNode[] | string | number | boolean | any[] | Map<any, any> | null | XPathFunctionItem;
+
+declare abstract class XPathExpression {
+    abstract evaluate(context: XPathContext): XPathResult;
 }
+
 /**
  * Handles conversion between ExprContext and XPathContext.
  * Uses XNode directly as XPathNode-compatible objects to preserve node identity.
@@ -549,22 +595,42 @@ declare class NodeConverter {
      */
     clearCache(): void;
 }
+
+/**
+ * Expression wrapper that provides backward-compatible interface.
+ * Wraps new XPath expressions to work with old ExprContext.
+ */
+declare class Expression {
+    protected xpathExpression: XPathExpression;
+    protected nodeConverter: NodeConverter;
+    absolute?: boolean;
+    steps?: any[];
+    constructor(xpathExpression: XPathExpression, nodeConverter: NodeConverter);
+    /**
+     * Evaluate the expression in the given context.
+     */
+    evaluate(context: ExprContext): NodeValue;
+}
+
 /**
  * XPath class that uses the new lexer/parser implementation
  * while maintaining API compatibility with the old implementation.
  */
 declare class XPath {
-    private lexer;
-    private parser;
+    private lexers;
+    private parsers;
     private nodeConverter;
     private parseCache;
     constructor();
+    private getLexer;
+    private getParser;
     /**
      * Parse an XPath expression and return an Expression object.
      * @param expression The XPath expression string.
      * @param axis Optional axis override for relative paths.
+     * @param version Optional XPath version (defaults to 1.0).
      */
-    xPathParse(expression: string, axis?: string): Expression;
+    xPathParse(expression: string, axis?: string, version?: XPathVersion): Expression;
     /**
      * Parse and evaluate an XPath expression.
      * @param select The XPath expression string.
@@ -645,42 +711,33 @@ declare class MatchResolver {
     private relativeXsltMatch;
 }
 
-type XsltParameter = {
-    name: string;
-    namespaceUri?: string;
-    value: any;
-};
-
-type XsltOptions = {
-    cData: boolean;
-    escape: boolean;
-    selfClosingTags: boolean;
-    outputMethod?: 'xml' | 'html' | 'text' | 'xhtml' | 'json' | 'adaptive';
-    parameters?: XsltParameter[];
-};
-
 /**
- * The main class for XSL-T processing. The implementation is NOT
- * complete; some xsl element are left out.
+ * The main class for XSL-T processing.
  *
  * References:
  *
- * [XSLT] XSL-T Specification
- * <http://www.w3.org/TR/1999/REC-xslt-19991116>.
+ * [XSLT 1.0] XSL Transformations (XSLT) Version 1.0
+ * <https://www.w3.org/TR/1999/REC-xslt-19991116>.
+ *
+ * [XSLT 2.0] XSL Transformations (XSLT) Version 2.0
+ * <https://www.w3.org/TR/xslt20/>.
+ *
+ * [XSLT 3.0] XSL Transformations (XSLT) Version 3.0
+ * <https://www.w3.org/TR/xslt-30/>.
  *
  * [ECMA] ECMAScript Language Specification
  * <http://www.ecma-international.org/publications/standards/Ecma-262.htm>.
  *
- * The XSL processor API has one entry point, the function
- * `xsltProcess()`. It receives as arguments the starting point in the
- * input document as an XPath expression context, the DOM root node of
- * the XSL-T stylesheet, and a DOM node that receives the output.
+ * The XSL processor API has one entry point: the async function
+ * `xsltProcess()`. It receives as arguments the input XML document
+ * and the XSL-T stylesheet document (both as `XDocument` instances),
+ * and returns the transformed output as a string (XML, HTML, JSON,
+ * or plain text depending on the output method).
  *
- * NOTE: Actually, XSL-T processing according to the specification is
- * defined as operation on text documents, not as operation on DOM
- * trees. So, strictly speaking, this implementation is not an XSL-T
- * processor, but the processing engine that needs to be complemented
- * by an XML parser and serializer in order to be complete. Those two
+ * NOTE: Strictly speaking, XSL-T processing according to the specification
+ * is defined as operation on text documents, not as operation on DOM
+ * trees. This implementation operates on an internal DOM representation,
+ * complemented by an XML parser and serializer to be complete. Those two
  * are found in the `dom` folder.
  */
 declare class Xslt {
@@ -689,11 +746,23 @@ declare class Xslt {
     matchResolver: MatchResolver;
     options: XsltOptions;
     decimalFormatSettings: XsltDecimalFormatSettings;
+    warningsCallback: (...args: any[]) => void;
     outputDocument: XDocument;
     outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml' | 'json' | 'adaptive';
     outputOmitXmlDeclaration: string;
+    outputVersion: string;
+    itemSeparator: string;
     version: string;
     firstTemplateRan: boolean;
+    /**
+     * Forwards-compatible processing mode (XSLT 1.0 Section 2.5).
+     * When true, the processor is running a stylesheet with version > 1.0.
+     * In this mode:
+     * - Unknown top-level elements are silently ignored
+     * - Unknown XSLT instructions use xsl:fallback if available, otherwise are ignored
+     * - Unknown attributes on XSLT elements are ignored
+     */
+    forwardsCompatible: boolean;
     /**
      * List of element name patterns from xsl:strip-space declarations.
      * Whitespace-only text nodes inside matching elements will be stripped.
@@ -741,6 +810,26 @@ declare class Xslt {
      * Used by apply-imports to determine which template called it.
      */
     private currentTemplateStack;
+    /**
+     * Package registry for XSLT 3.0 package system.
+     * Manages loaded packages and their components.
+     */
+    private packageRegistry;
+    /**
+     * Current package being processed (for XSLT 3.0).
+     * null if processing a non-package stylesheet.
+     */
+    private currentPackage;
+    /**
+     * Accumulator registry for XSLT 3.0 accumulators.
+     * Stores accumulator definitions and current state during processing.
+     */
+    private accumulatorRegistry;
+    /**
+     * Streaming processor for XSLT 3.0 streaming processing.
+     * Encapsulates streaming context, copy management, and merge coordination.
+     */
+    private streamingProcessor;
     constructor(options?: Partial<XsltOptions>);
     /**
      * The exported entry point of the XSL-T processor.
@@ -756,6 +845,21 @@ declare class Xslt {
      * @param output If set, the output where the transformation should occur.
      */
     protected xsltProcessContext(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Handle unknown XSLT instructions per XSLT 1.0 Section 2.5 (Forwards-Compatible Processing).
+     *
+     * In forwards-compatible mode (version > 1.0):
+     * - If the instruction has an xsl:fallback child, execute the fallback
+     * - Otherwise, the instruction is silently ignored
+     *
+     * In strict mode (version = 1.0):
+     * - Unknown instructions are an error
+     *
+     * @param context The Expression Context
+     * @param template The unknown XSLT instruction element
+     * @param output The output node
+     */
+    protected xsltUnknownInstruction(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
     /**
      * Implements `xsl:apply-templates`.
      * @param context The Expression Context.
@@ -764,6 +868,11 @@ declare class Xslt {
      * @protected
      */
     protected xsltApplyTemplates(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Helper method to apply the built-in template for elements.
+     * The built-in template recursively applies templates to children.
+     */
+    private applyBuiltInTemplate;
     /**
      * Implements `xsl:apply-imports`.
      * Applies templates from imported stylesheets with the same match pattern and mode.
@@ -839,6 +948,32 @@ declare class Xslt {
      * @param template The template.
      */
     protected xsltElement(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:accumulator` (XSLT 3.0).
+     *
+     * Accumulators are a declarative way to compute values during template processing.
+     * They consist of rules that are applied as elements are processed.
+     *
+     * @param context The expression context
+     * @param template The xsl:accumulator element
+     */
+    protected xsltAccumulator(context: ExprContext, template: XNode): void;
+    /**
+     * Evaluates all matching accumulator rules for a given node
+     * and updates the accumulator state
+     *
+     * @param context The expression context with current node
+     * @param node The current node being processed
+     */
+    protected evaluateAccumulatorRules(context: ExprContext, node: XNode): void;
+    /**
+     * Retrieves the current value of an accumulator
+     * Used when accessing accumulators in templates via accumulator-after() or accumulator-before()
+     *
+     * @param accumulatorName The name of the accumulator
+     * @returns The current value of the accumulator, or null if not found
+     */
+    protected getAccumulatorValue(accumulatorName: string): any;
     /**
      * Implements `xsl:for-each`.
      * @param context The Expression Context.
@@ -846,6 +981,69 @@ declare class Xslt {
      * @param output The output.
      */
     protected xsltForEach(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:for-each-group` (XSLT 2.0).
+     *
+     * Groups items from the select expression and processes each group.
+     * Supports group-by and group-adjacent grouping methods.
+     *
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output.
+     */
+    protected xsltForEachGroup(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Group items by a computed key value.
+     * Items with the same key are placed in the same group.
+     */
+    private groupByKey;
+    /**
+     * Group adjacent items with the same key.
+     * A new group starts when the key changes.
+     */
+    private groupAdjacent;
+    /**
+     * Convert an XSLT pattern to a self:: expression for matching against the current node.
+     * For example, "h1" becomes "self::h1", "section[@type]" becomes "self::section[@type]".
+     */
+    private patternToSelfExpression;
+    /**
+     * Group items starting with items that match a pattern.
+     * A new group starts when an item matches the pattern.
+     */
+    private groupStartingWith;
+    /**
+     * Group items ending with items that match a pattern.
+     * A group ends when an item matches the pattern.
+     */
+    private groupEndingWith;
+    /**
+     * Implements `xsl:iterate` (XSLT 3.0).
+     *
+     * Iterates over a sequence, maintaining accumulators that are updated across iterations.
+     * Each iteration can output content and update accumulator values.
+     * After all iterations complete, optional xsl:on-completion is executed.
+     *
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output.
+     */
+    protected xsltIterate(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:try`.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output.
+     */
+    protected xsltTry(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:evaluate` (XSLT 3.0).
+     * Dynamically evaluates an XPath expression constructed as a string.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output.
+     */
+    protected xsltEvaluate(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
     /**
      * Implements `xsl:if`.
      * @param context The Expression Context.
@@ -876,6 +1074,60 @@ declare class Xslt {
      * @param output The output.
      */
     protected xsltInclude(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `<xsl:package>` (XSLT 3.0 Section 3.6).
+     * Defines a package of XSLT components with controlled visibility.
+     * @param context The Expression Context.
+     * @param template The xsl:package element.
+     * @param output The output node.
+     */
+    protected xsltPackage(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `<xsl:use-package>` (XSLT 3.0 Section 3.7).
+     * Imports another package and makes its public components available.
+     * @param context The Expression Context.
+     * @param template The xsl:use-package element.
+     * @param output The output node.
+     */
+    protected xsltUsePackage(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `<xsl:expose>` (XSLT 3.0 Section 3.8).
+     * Marks a component as visible outside the package.
+     * @param context The Expression Context.
+     * @param template The xsl:expose element.
+     */
+    protected xsltExpose(context: ExprContext, template: XNode): void;
+    /**
+     * Implements `<xsl:accept>` (XSLT 3.0 Section 3.9).
+     * Accepts and optionally overrides a component from a used package.
+     * @param context The Expression Context.
+     * @param template The xsl:accept element.
+     */
+    protected xsltAccept(context: ExprContext, template: XNode): void;
+    /**
+     * Implements `<xsl:stream>` (XSLT 3.0 Section 16).
+     * Enables streaming processing of large documents.
+     * @param context The Expression Context.
+     * @param template The xsl:stream element.
+     * @param output The output node.
+     */
+    protected xsltStream(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `<xsl:fork>` (XSLT 3.0 Section 17).
+     * Creates multiple independent output branches from the input stream.
+     * @param context The Expression Context.
+     * @param template The xsl:fork element.
+     * @param output The output node.
+     */
+    protected xsltFork(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `<xsl:merge>` (XSLT 3.0 Section 15).
+     * Merges multiple sorted input sequences.
+     * @param context The Expression Context.
+     * @param template The xsl:merge element.
+     * @param output The output node.
+     */
+    protected xsltMerge(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
     /**
      * Implements `xsl:key`.
      * @param context The Expression Context.
@@ -909,29 +1161,57 @@ declare class Xslt {
      * @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.
+     * @param from Pattern to define counting boundary.
+     * @returns Array of count values (single element for 'single'/'any', multiple for 'multiple').
      */
-    protected xsltNumberCount(context: ExprContext, level: string, count: string | null, from: string | null): number;
+    protected xsltNumberCount(context: ExprContext, level: string, count: string | null, from: string | null): number[];
     /**
-     * Checks if a node matches a simple name pattern.
+     * Checks if a node matches a pattern (supports simple names and union patterns).
      * @param node The node to check.
-     * @param pattern The pattern (node name) to match.
+     * @param pattern The pattern (node name, wildcard, or union like "a|b|c").
      * @returns True if the node matches.
      */
     protected nodeMatchesPattern(node: XNode, pattern: string): boolean;
+    /**
+     * Checks if a node matches a single (non-union) pattern.
+     * @param node The node to check.
+     * @param pattern The pattern (node name or wildcard).
+     * @returns True if the node matches.
+     */
+    protected nodeMatchesSinglePattern(node: XNode, pattern: string): boolean;
     /**
      * Gets all nodes preceding the given node in document order.
      * @param node The reference node.
+     * @param fromPattern Optional pattern to define counting boundary.
      * @returns Array of preceding nodes.
      */
-    protected getAllPrecedingNodes(node: XNode): XNode[];
+    protected getAllPrecedingNodes(node: XNode, fromPattern?: string | null): 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 an array of numbers according to the format string.
+     * For level="multiple", numbers like [1, 2, 3] with format "1.1.1" produce "1.2.3".
+     * @param numbers The numbers to format.
+     * @param format The format string (e.g., "1", "1.1", "1.a.i").
+     * @param groupingSeparator Optional grouping separator.
+     * @param groupingSize Optional grouping size.
+     * @returns The formatted number string.
+     */
+    protected xsltFormatNumbers(numbers: number[], format: string, groupingSeparator: string | null, groupingSize: string | null): string;
+    /**
+     * Parses a format string into tokens and separators.
+     * E.g., "1.a.i" -> tokens: ["1", "a", "i"], separators: [".", "."]
+     * @param format The format string.
+     * @returns Object with tokens and separators arrays.
+     */
+    protected parseFormatString(format: string): {
+        tokens: string[];
+        separators: string[];
+    };
     /**
      * Formats a number according to the format string.
      * @param number The number to format.
@@ -1035,6 +1315,34 @@ declare class Xslt {
      */
     protected xsltTransformOrStylesheet(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
     protected xsltValueOf(context: ExprContext, template: XNode, output?: XNode): void;
+    /**
+     * Implements `xsl:sequence` (XSLT 2.0).
+     *
+     * Constructs a sequence by evaluating the select expression or processing
+     * child content. Unlike xsl:copy-of, xsl:sequence returns nodes by reference
+     * and can return atomic values.
+     *
+     * @param context The expression context.
+     * @param template The xsl:sequence element.
+     * @param output The output node.
+     */
+    protected xsltSequence(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:analyze-string` (XSLT 2.0).
+     *
+     * Processes a string using a regular expression, with separate handling
+     * for matching and non-matching substrings.
+     *
+     * @param context The expression context.
+     * @param template The xsl:analyze-string element.
+     * @param output The output node.
+     */
+    protected xsltAnalyzeString(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Helper method to process xsl:matching-substring or xsl:non-matching-substring content.
+     * Sets up the context with the current text and regex groups.
+     */
+    private processAnalyzeStringContent;
     /**
      * Evaluates a variable or parameter and set it in the current input
      * context. Implements `xsl:variable`, `xsl:param`, and `xsl:with-param`.
@@ -1056,6 +1364,12 @@ declare class Xslt {
      * @param output If set, the output where the transformation should occur.
      */
     protected xsltChildNodes(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Processes child nodes while skipping xsl:on-empty and xsl:on-non-empty.
+     * Used by instructions that handle these conditionals explicitly.
+     */
+    protected xsltChildNodesExcludingConditional(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    private findConditionalChild;
     /**
      * This logic is used in two different places:
      * - `xsltPassThrough`, if the template asks this library to write a text node;
@@ -1098,6 +1412,16 @@ declare class Xslt {
      * @returns TODO
      */
     protected xsltAttributeValue(value: any, context: ExprContext): any;
+    /**
+     * Evaluates text value templates in XSLT 3.0. Text value templates
+     * allow XPath expressions in braces {} within text nodes.
+     * The expressions are evaluated in the current input context.
+     * To include a literal brace, use {{ or }}.
+     * @param value The text node value to process
+     * @param context The expression context
+     * @returns The processed text with expressions evaluated
+     */
+    protected xsltTextValueTemplate(value: string, context: ExprContext): string;
     /**
      * Evaluates an XPath expression in the current input context as a
      * match.