Class Xslt

The main entry point of the XSL-T processor, as explained on the top of the file.

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

Implements xsl:apply-imports. Applies templates from imported stylesheets with the same match pattern and mode. This enables template overriding where a template in an importing stylesheet can call the overridden template from the imported stylesheet.

Implements xsl:call-template.

Implements xsl:choose, its child nodes xsl:when, and xsl:otherwise.

Implements xsl:copy for all node types.

Implements xsl:comment.

Implements xsl:processing-instruction.

Implements xsl:copy-of for node-set values of the select expression. Recurses down the source node tree, which is part of the input document.

Implements xsl:decimal-format, registering the settings in this instance and the current context.

Implements xsl:element.

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.

Evaluates all matching accumulator rules for a given node and updates the accumulator state

Retrieves the current value of an accumulator Used when accessing accumulators in templates via accumulator-after() or accumulator-before()

Implements xsl:for-each.

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.

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.

Implements xsl:try.

Implements xsl:evaluate (XSLT 3.0). Dynamically evaluates an XPath expression constructed as a string.

Implements xsl:if.

Common implementation for <xsl:import> and <xsl:include>.

Implements <xsl:import>. For now the code is nearly identical to <xsl:include>, but there's no precedence evaluation implemented yet.

Implements xsl:include.

Implements <xsl:package> (XSLT 3.0 Section 3.6). Defines a package of XSLT components with controlled visibility.

Loads and registers an external package. Creates a temporary context and processes the package document.

Implements <xsl:use-package> (XSLT 3.0 Section 3.7). Imports another package and makes its public components available.

Implements <xsl:expose> (XSLT 3.0 Section 3.8). Marks a component as visible outside the package.

Implements <xsl:accept> (XSLT 3.0 Section 3.9). Accepts and optionally overrides a component from a used package.

Implements xsl:override (XSLT 3.0 Section 3.7.2). Overrides components from a used package.

Implements xsl:original (XSLT 3.0 Section 3.7.2). Calls the original component from within an override.

Implements <xsl:mode> (XSLT 3.0 Section 3.5). Declares a mode with visibility and other properties. Only valid within an xsl:package.

Implements <xsl:stream> (XSLT 3.0 Section 16). Enables streaming processing of large documents.

Implements <xsl:fork> (XSLT 3.0 Section 17). Creates multiple independent output branches from the input stream.

Implements <xsl:merge> (XSLT 3.0 Section 15). Merges multiple sorted input sequences.

Implements xsl:key.

Implements xsl:message. Outputs a message to the console. If terminate="yes", throws an error to stop processing.

Implements xsl:namespace-alias. Declares that a namespace URI in the stylesheet should be replaced by a different namespace URI in the output.

Implements xsl:number. Inserts a formatted number into the result tree.

Counts nodes for xsl:number based on level, count, and from attributes.

Checks if a node matches a pattern (supports simple names and union patterns).

Checks if a node matches a single (non-union) pattern.

Gets all nodes preceding the given node in document order.

Collects all descendant nodes of a given node.

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".

Parses a format string into tokens and separators. E.g., "1.a.i" -> tokens: ["1", "a", "i"], separators: [".", "."]

Formats a number according to the format string.

Converts a number to alphabetic representation.

Converts a number to Roman numeral representation.

Applies grouping separators to a numeric string.

Orders the current node list in the input context according to the sort order specified by xsl:sort child nodes of the current template node. This happens before the operation specified by the current template node is executed.

Implements xsl:strip-space. Collects element name patterns for which whitespace-only text nodes should be stripped.

Implements xsl:preserve-space. Collects element name patterns for which whitespace-only text nodes should be preserved. preserve-space takes precedence over strip-space for matching elements.

Determines if a text node from the input document should be stripped. This applies xsl:strip-space and xsl:preserve-space rules to whitespace-only text nodes.

Matches an element name against a strip-space/preserve-space pattern. Supports:

• "*" matches any element
• "prefix:*" matches any element in a namespace
• "name" matches elements with that local name
• "prefix:name" matches elements with that QName

Implements xsl:template.

Validates XSLT stylesheet/transform attributes. According to XSLT specification, validates:

• Required version attribute
• Valid version values (1.0, 2.0, 3.0)
• Valid namespace declarations
• Valid values for optional attributes (extension-element-prefixes, exclude-result-prefixes)

Implements <xsl:stylesheet> and <xsl:transform>, and its corresponding validations.

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.

Implements xsl:analyze-string (XSLT 2.0).

Processes a string using a regular expression, with separate handling for matching and non-matching substrings.

Implements xsl:function (XSLT 2.0).

Declares a stylesheet function that can be called from XPath expressions. Functions are collected during stylesheet initialization and made available to the XPath evaluator.

Coerce a NodeValue to a specific type based on the 'as' attribute.

Execute a user-defined xsl:function. Called when a function from userDefinedFunctions is invoked from XPath.

Implements xsl:result-document (XSLT 2.0).

Creates a secondary output document. The output is stored in the resultDocuments map, accessible via getResultDocuments().

Implements xsl:perform-sort (XSLT 2.0).

Sorts a sequence of items without iteration. The sorted sequence is available via xsl:sequence or other sequence-consuming instructions.

Implements xsl:namespace (XSLT 2.0).

Creates a namespace node in the result tree.

Evaluates a variable or parameter and set it in the current input context. Implements xsl:variable, xsl:param, and xsl:with-param.

Traverses the template node tree. Calls the main processing function with the current input context for every child node of the current template node.

Processes child nodes while skipping xsl:on-empty and xsl:on-non-empty. Used by instructions that handle these conditionals explicitly.

Passes template text to the output. The current template node does not specify an XSL-T operation and therefore is appended to the output with all its attributes. Then continues traversing the template node tree.

Determines if a text node in the XSLT template document is to be stripped according to XSLT whitespace stripping rules.

Evaluates an XSL-T attribute value template. Attribute value templates are attributes on XSL-T elements that contain XPath expressions in braces {}. The XSL-T expressions are evaluated in the current input context.

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 }}.

Evaluates an XPath expression in the current input context as a match.

Sets parameters defined by xsl:with-param child nodes of the current template node, in the current input context. This happens before the operation specified by the current template node is executed.

Apply one or more attribute sets to an element. Parses space-separated attribute set names and applies them.

Test if an element is a supported extension. Returns false for unrecognized elements in non-XSLT namespaces.

Get the fallback element from an extension element if it exists. Searches for the first direct xsl:fallback child.

Process an extension element with fallback support. If a fallback is defined, executes it; otherwise treats element as literal.

Test if the given element is an XSLT element, optionally the one with the given name.