xslt-processor 3.4.0 → 4.0.0

package/index.d.mts

@@ -0,0 +1,817 @@
+/**
+ * Our W3C DOM Node implementation. Note we call it XNode because we
+ * can't define the identifier Node. We do this mostly for Opera,
+ * where we can't reuse the HTML DOM for parsing our own XML, and for
+ * Safari, where it is too expensive to have the template processor.
+ */
+declare class XNode {
+    id: number;
+    childNodes: XNode[];
+    nodeType: number;
+    nodeName: string;
+    nodeValue: any;
+    firstChild: XNode;
+    lastChild: XNode;
+    nextSibling: XNode;
+    previousSibling: XNode;
+    siblingPosition: number;
+    ownerDocument: any;
+    namespaceUri: any;
+    prefix: string;
+    localName: string;
+    parentNode: XNode;
+    visited: boolean;
+    escape: boolean;
+    static _unusedXNodes: any[];
+    constructor(type: number, name: string, opt_value: any, opt_owner: any, opt_namespace?: any);
+    /**
+     * Node initialization. Called by the constructor and `recycle` method.
+     * @param type The node type.
+     * @param name The node name.
+     * @param value The node value.
+     * @param owner The node owner.
+     * @param namespaceUri The node namespace.
+     */
+    init(type: number, name: string, value: string, owner: any, namespaceUri: any): void;
+    protected qualifiedNameToParts(name: string): string[];
+    protected domTraverseElements(node: XNode, opt_pre: Function, opt_post: any): boolean;
+    static recycle(node: any): void;
+    static create(type: any, name: string, value: any, owner: any, namespace?: any): XNode;
+    static clone(node: XNode, newOwner: XNode): XNode;
+    appendChild(node: XNode): void;
+    replaceChild(newNode: any, oldNode: any): void;
+    insertBefore(newNode: any, oldNode: any): void;
+    removeChild(node: XNode): void;
+    hasAttributes(): boolean;
+    setAttribute(name: string, value: any): void;
+    setAttributeNS(namespace: any, name: any, value: any): void;
+    getAttributeValue(name: string): any;
+    getAttributeNS(namespace: any, localName: any): any;
+    hasAttribute(name: string): boolean;
+    hasAttributeNS(namespace: string, localName: string): boolean;
+    removeAttribute(name: string): void;
+    removeAttributeNS(namespace: string, localName: string): void;
+    getElementsByTagName(name: string): any[];
+    getElementsByTagNameNS(namespace: string, localName: string): any[];
+    getElementById(id: any): any;
+    getAncestorByLocalName(localName: string): XNode | undefined;
+    getAncestorById(id: number): XNode | undefined;
+    toString(): string;
+}
+
+declare class XDocument extends XNode {
+    documentElement: any;
+    constructor();
+    appendChild(node: any): void;
+    createElement(name: string): XNode;
+    createElementNS(namespace: any, name: any): XNode;
+    createDocumentFragment(): XNode;
+    createTextNode(value: any): XNode;
+    createAttribute(name: any): XNode;
+    createAttributeNS(namespace: any, name: any): XNode;
+    createComment(data: any): XNode;
+    createCDATASection(data: any): XNode;
+    createDTDSection(data: any): XNode;
+}
+
+/**
+ * Escape XML special markup characters: tag delimiter <, >, and entity
+ * reference start delimiter &. The escaped string can be used in XML
+ * text portions (i.e. between tags).
+ * @param s The string to be escaped.
+ * @returns The escaped string.
+ */
+declare function xmlEscapeText(s: string): string;
+
+/**
+ * Original author: Steffen Meschkat <mesch@google.com> (the `xmlParse` function,
+ * now `xmlStrictParse`).
+ *
+ * An XML parse and a minimal DOM implementation that just supports
+ * the subset of the W3C DOM that is used in the XSLT implementation.
+ */
+declare class XmlParser {
+    regexEmpty: RegExp;
+    XML10_TAGNAME_REGEXP: RegExp;
+    XML10_ATTRIBUTE_REGEXP: RegExp;
+    XML11_TAGNAME_REGEXP: RegExp;
+    XML11_ATTRIBUTE_REGEXP: RegExp;
+    lenientHtmlTags: string[];
+    /**
+     * The entry point for this parser.
+     * It verifies whether the document seems to be HTML.
+     * HTML is a special case if XML and it should be parsed differently.
+     * @param xmlOrHtml The XML or HTML content to be parsed.
+     * @returns A DOM document.
+     */
+    xmlParse(xmlOrHtml: string): XDocument;
+    /**
+     * Given an XNode, returns an object mapping prefixes to their corresponding namespaces in its scope.
+     * Default namespace is treated as if its prefix were the empty string.
+     * @param node The Node.
+     * @returns An object with prefixes and namespace URLs.
+     */
+    private namespaceMapAt;
+    /**
+     * HTML needs to be parsed differently because it's a special case of XML.
+     * Sources:
+     *
+     * - https://blog.teamtreehouse.com/to-close-or-not-to-close-tags-in-html5
+     * @param htmlText The HTML text
+     * @returns A DOM document.
+     */
+    private htmlParse;
+    /**
+     * Parses the given XML string with our custom, JavaScript XML parser.
+     * @param xml The XML String.
+     * @returns A XDocument.
+     * @author Steffen Meschkat <mesch@google.com>
+     */
+    private xmlStrictParse;
+}
+
+/**
+ * Represents a DOM-like node interface for XPath evaluation.
+ * This is compatible with browser DOM nodes and can be extended for other implementations.
+ */
+interface XPathNode {
+    nodeType: number;
+    nodeName: string;
+    localName?: string;
+    namespaceURI?: string | null;
+    textContent?: string | null;
+    parentNode?: XPathNode | null;
+    childNodes?: ArrayLike<XPathNode>;
+    attributes?: ArrayLike<XPathNode>;
+    nextSibling?: XPathNode | null;
+    previousSibling?: XPathNode | null;
+    ownerDocument?: XPathNode | null;
+    documentElement?: XPathNode;
+    target?: string;
+    getAttribute?(name: string): string | null;
+    compareDocumentPosition?(other: XPathNode): number;
+}
+
+/**
+ * Type for custom XPath functions that can be registered in the context.
+ */
+type XPathFunction = (...args: any[]) => any;
+/**
+ * Type for the variables map in the context.
+ */
+type XPathVariables = Record<string, any>;
+/**
+ * Type for the custom functions map in the context.
+ */
+type XPathFunctions = Record<string, XPathFunction>;
+/**
+ * Type for namespace bindings (prefix -> namespace URI).
+ */
+type XPathNamespaces = Record<string, string>;
+/**
+ * The evaluation context for XPath expressions.
+ *
+ * This context is passed to all expression evaluate() methods and contains:
+ * - The current context node
+ * - Position information for predicates
+ * - Variable bindings
+ * - Custom function definitions
+ */
+interface XPathContext {
+    /**
+     * The current context node being evaluated.
+     */
+    node?: XPathNode;
+    /**
+     * The position of the context node within the current node set (1-based).
+     * Used by position() function and numeric predicates.
+     */
+    position?: number;
+    /**
+     * The size of the current node set.
+     * Used by last() function.
+     */
+    size?: number;
+    /**
+     * The full node list for the current context.
+     * Used by the 'self-and-siblings' axis (XSLT-specific).
+     */
+    nodeList?: XPathNode[];
+    /**
+     * Variable bindings available during evaluation.
+     * Variables are referenced in XPath as $variableName.
+     */
+    variables?: XPathVariables;
+    /**
+     * Custom functions available during evaluation.
+     * These extend the built-in XPath 1.0 function library.
+     */
+    functions?: XPathFunctions;
+    /**
+     * Namespace bindings for resolving prefixes in XPath expressions.
+     * Maps namespace prefixes to namespace URIs.
+     * Example: { "atom": "http://www.w3.org/2005/Atom" }
+     */
+    namespaces?: XPathNamespaces;
+}
+/**
+ * Result types that can be returned from XPath evaluation.
+ */
+type XPathResult = XPathNode[] | string | number | boolean;
+
+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;
+    };
+    caseInsensitive: any;
+    ignoreAttributesWithoutValue: any;
+    returnOnFirstMatch: any;
+    ignoreNonElementNodesForNTA: any;
+    parent: ExprContext;
+    root: XNode;
+    decimalFormatSettings: XsltDecimalFormatSettings;
+    inApplyTemplates: boolean;
+    baseTemplateMatched: boolean;
+    /**
+     * 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);
+    /**
+     * 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;
+    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;
+}
+
+/**
+ * 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;
+}
+/**
+ * Handles conversion between ExprContext and XPathContext.
+ * Uses XNode directly as XPathNode-compatible objects to preserve node identity.
+ */
+declare class NodeConverter {
+    /**
+     * Convert ExprContext to XPathContext for the new XPath implementation.
+     * XNodes are used directly since they implement enough of the XPathNode interface.
+     */
+    exprContextToXPathContext(exprContext: ExprContext): XPathContext;
+    /**
+     * Adapt XNode to be compatible with XPathNode interface.
+     * We add missing properties but keep the original XNode reference.
+     */
+    adaptXNode(node: XNode): XPathNode;
+    /**
+     * Convert XPathNode result back to XNode.
+     * Since we're now using XNodes directly, this is mostly a type cast.
+     */
+    xPathNodeToXNode(xpathNode: XPathNode): XNode | null;
+    /**
+     * Get text content from an XNode.
+     */
+    private getTextContent;
+    /**
+     * Convert variables from ExprContext format to XPathContext format.
+     */
+    private convertVariables;
+    /**
+     * Create custom functions for XPath context (like key(), document(), etc.).
+     */
+    private createCustomFunctions;
+    /**
+     * Convert an XML node to a JSON string representation.
+     * This is a simplified implementation of XSLT 3.0's xml-to-json().
+     */
+    private xmlToJson;
+    /**
+     * Wrap XPath result in appropriate NodeValue type.
+     */
+    wrapResult(result: XPathResult, exprContext: ExprContext): NodeValue;
+    /**
+     * Clear any internal state if needed.
+     */
+    clearCache(): void;
+}
+/**
+ * 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 nodeConverter;
+    private parseCache;
+    constructor();
+    /**
+     * Parse an XPath expression and return an Expression object.
+     * @param expression The XPath expression string.
+     * @param axis Optional axis override for relative paths.
+     */
+    xPathParse(expression: string, axis?: string): Expression;
+    /**
+     * Parse and evaluate an XPath expression.
+     * @param select The XPath expression string.
+     * @param context The expression context.
+     */
+    xPathEval(select: string, context: ExprContext): NodeValue;
+    /**
+     * Sort nodes in context according to sort specifications.
+     * @param context The expression context with nodes to sort.
+     * @param sort Array of sort specifications.
+     */
+    xPathSort(context: ExprContext, sort: any[]): void;
+    /**
+     * Comparison function for sorting.
+     */
+    private xPathSortByKey;
+    /**
+     * Wrap a new XPath expression in the backward-compatible Expression class.
+     */
+    private wrapExpression;
+    /**
+     * Clear parse cache (useful for testing or memory management).
+     */
+    clearCache(): void;
+}
+
+/**
+ * Class that resolves XPath expressions, returning nodes.
+ * This is used for XSLT pattern matching.
+ */
+declare class MatchResolver {
+    /**
+     * Entry point for expression matching.
+     * @param expression The expression to be resolved.
+     * @param context The Expression Context.
+     * @returns An array of nodes.
+     */
+    expressionMatch(expression: Expression, context: ExprContext): XNode[];
+    /**
+     * Resolves a LocationExpr.
+     * @param expression The Location Expression.
+     * @param context The Expression Context.
+     * @returns Either the results of a relative resolution, or the results of an
+     *          absolute resolution.
+     */
+    private locationExpressionMatch;
+    /**
+     * Resolves a UnionExpr.
+     * @param expression The Union Expression.
+     * @param context The Expression Context.
+     * @returns The concatenated result of evaluating both sides of the expression.
+     */
+    private unionExpressionMatch;
+    /**
+     * Finds all the nodes through absolute XPath search, starting on
+     * the #document parent node.
+     * @param expression The Expression.
+     * @param context The Expression Context.
+     * @returns The list of found nodes.
+     */
+    private absoluteXsltMatchByDocumentNode;
+    /**
+     * Finds all the nodes through absolute XPath search, starting with the
+     * first child of the #document node.
+     * @param expression The Expression.
+     * @param context The Expression Context.
+     * @returns The list of found nodes.
+     */
+    private absoluteXsltMatch;
+    /**
+     * Tries to find relative nodes from the actual context position.
+     * If found nodes are already in the context, or if they are children of
+     * nodes in the context, they are returned.
+     * @param expression The expression used.
+     * @param context The Expression Context.
+     * @returns The list of found nodes.
+     */
+    private relativeXsltMatch;
+}
+
+type XsltParameter = {
+    name: string;
+    namespaceUri?: string;
+    value: any;
+};
+
+type XsltOptions = {
+    cData: boolean;
+    escape: boolean;
+    selfClosingTags: boolean;
+    parameters?: XsltParameter[];
+};
+
+/**
+ * The main class for XSL-T processing. The implementation is NOT
+ * complete; some xsl element are left out.
+ *
+ * References:
+ *
+ * [XSLT] XSL-T Specification
+ * <http://www.w3.org/TR/1999/REC-xslt-19991116>.
+ *
+ * [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.
+ *
+ * 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
+ * are found in the `dom` folder.
+ */
+declare class Xslt {
+    xPath: XPath;
+    xmlParser: XmlParser;
+    matchResolver: MatchResolver;
+    options: XsltOptions;
+    decimalFormatSettings: XsltDecimalFormatSettings;
+    outputDocument: XDocument;
+    outputMethod: 'xml' | 'html' | 'text' | 'name' | 'xhtml';
+    outputOmitXmlDeclaration: string;
+    version: string;
+    firstTemplateRan: boolean;
+    constructor(options?: Partial<XsltOptions>);
+    /**
+     * The exported entry point of the XSL-T processor.
+     * @param xmlDoc The input document root, as DOM node.
+     * @param stylesheet The stylesheet document root, as DOM node.
+     * @returns the processed document, as XML text in a string.
+     */
+    xsltProcess(xmlDoc: XDocument, stylesheet: XDocument): Promise<string>;
+    /**
+     * The main entry point of the XSL-T processor, as explained on the top of the file.
+     * @param context The input document root, as XPath `ExprContext`.
+     * @param template The stylesheet document root, as DOM node.
+     * @param output If set, the output where the transformation should occur.
+     */
+    protected xsltProcessContext(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:apply-templates`.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output. Only used if there's no corresponding output node already defined.
+     * @protected
+     */
+    protected xsltApplyTemplates(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:attribute`.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output. Only used if there's no corresponding output node already defined.
+     * @protected
+     */
+    protected xsltAttribute(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:call-template`.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output, used when a fragment is passed by a previous step.
+     */
+    protected xsltCallTemplate(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:choose`, its child nodes `xsl:when`, and
+     * `xsl:otherwise`.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output. Only used if there's no corresponding output node already defined.
+     */
+    protected xsltChoose(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:copy` for all node types.
+     * @param {XNode} destination the node being copied to, part of output document.
+     * @param {XNode} source the node being copied, part in input document.
+     * @returns {XNode|null} If an element node was created, the element node. Otherwise, null.
+     */
+    protected xsltCopy(destination: XNode, source: XNode): XNode;
+    /**
+     * Implements `xsl:comment`.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output. Only used if there's no corresponding output node already defined.
+     */
+    protected xsltComment(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * 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.
+     * @param {XNode} destination the node being copied to, part of output document.
+     * @param {XNode} source the node being copied, part in input document.
+     */
+    protected xsltCopyOf(destination: XNode, source: XNode): void;
+    /**
+     * Implements `xsl:decimal-format`, registering the settings in this instance
+     * and the current context.
+     * @param context The Expression Context.
+     * @param template The template.
+     */
+    protected xsltDecimalFormat(context: ExprContext, template: XNode): void;
+    /**
+     * Implements `xsl:element`.
+     * @param context The Expression Context.
+     * @param template The template.
+     */
+    protected xsltElement(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:for-each`.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output.
+     */
+    protected xsltForEach(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:if`.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output.
+     */
+    protected xsltIf(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Common implementation for `<xsl:import>` and `<xsl:include>`.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output.
+     * @param isImport Whether this is an import (true) or include (false).
+     */
+    protected xsltImportOrInclude(context: ExprContext, template: XNode, output: XNode | undefined, isImport: boolean): Promise<void>;
+    /**
+     * Implements `<xsl:import>`. For now the code is nearly identical to `<xsl:include>`, but there's
+     * no precedence evaluation implemented yet.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output.
+     */
+    protected xsltImport(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:include`.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output.
+     */
+    protected xsltInclude(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * Implements `xsl:key`.
+     * @param context The Expression Context.
+     * @param template The template.
+     */
+    protected xsltKey(context: ExprContext, template: XNode): void;
+    /**
+     * 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.
+     * @param context The expression context.
+     * @param template The template node.
+     * @todo case-order is not implemented.
+     */
+    protected xsltSort(context: ExprContext, template: XNode): void;
+    /**
+     * Implements `xsl:template`.
+     * @param context The Expression Context.
+     * @param template The `<xsl:template>` node.
+     * @param output The output. In general, a fragment that will be used by
+     *               the caller.
+     */
+    protected xsltTemplate(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    protected xsltText(context: ExprContext, template: XNode, output?: XNode): void;
+    /**
+     * Implements `<xsl:stylesheet>` and `<xsl:transform>`, and its corresponding
+     * validations.
+     * @param context The Expression Context.
+     * @param template The `<xsl:stylesheet>` or `<xsl:transform>` node.
+     * @param output The output. In general, a fragment that will be used by
+     *               the caller.
+     */
+    protected xsltTransformOrStylesheet(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    protected xsltValueOf(context: ExprContext, template: XNode, output?: XNode): void;
+    /**
+     * Evaluates a variable or parameter and set it in the current input
+     * context. Implements `xsl:variable`, `xsl:param`, and `xsl:with-param`.
+     *
+     * @param context The expression context.
+     * @param template The template node.
+     * @param override flag that defines if the value computed here
+     * overrides the one already in the input context if that is the
+     * case. I.e. decides if this is a default value or a local
+     * value. `xsl:variable` and `xsl:with-param` override; `xsl:param` doesn't.
+     */
+    protected xsltVariable(context: ExprContext, template: XNode, override: boolean): Promise<void>;
+    /**
+     * Traverses the template node tree. Calls the main processing
+     * function with the current input context for every child node of the
+     * current template node.
+     * @param context Normally the Expression Context.
+     * @param template The XSL-T definition.
+     * @param output If set, the output where the transformation should occur.
+     */
+    protected xsltChildNodes(context: ExprContext, template: XNode, output?: XNode): Promise<void>;
+    /**
+     * This logic is used in two different places:
+     * - `xsltPassThrough`, if the template asks this library to write a text node;
+     * - `xsltProcessContext`, `apply-templates` operation, when the current node is text.
+     *
+     * Text nodes always require a parent, and they never have children.
+     * @param context The Expression Context.
+     * @param template The template, that contains the node value to be written.
+     * @param output The output.
+     */
+    private commonLogicTextNode;
+    /**
+     * 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.
+     * @param context The Expression Context.
+     * @param template The XSLT stylesheet or transformation.
+     * @param output The output.
+     */
+    protected xsltPassThrough(context: ExprContext, template: XNode, output: XNode): Promise<void>;
+    /**
+     * Determines if a text node in the XSLT template document is to be
+     * stripped according to XSLT whitespace stripping rules.
+     * @see [XSLT], section 3.4.
+     * @param template The XSLT template.
+     * @returns TODO
+     * @todo Whitespace stripping on the input document is
+     * currently not implemented.
+     */
+    protected xsltPassText(template: XNode): boolean;
+    protected findAttributeInContext(attributeName: string, context: ExprContext): XNode;
+    /**
+     * 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.
+     * @param value TODO
+     * @param context TODO
+     * @returns TODO
+     */
+    protected xsltAttributeValue(value: any, context: ExprContext): any;
+    /**
+     * Evaluates an XPath expression in the current input context as a
+     * match.
+     * @see [XSLT] section 5.2, paragraph 1
+     * @param match TODO
+     * @param context The Expression Context.
+     * @param axis The XPath axis. Used when the match does not start with the parent.
+     * @returns {XNode[]} A list of the found nodes.
+     */
+    protected xsltMatch(match: string, context: ExprContext, axis?: string): XNode[];
+    /**
+     * 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.
+     * @param context The Expression Context.
+     * @param template The template node.
+     */
+    protected xsltWithParam(context: ExprContext, template: XNode): Promise<void>;
+    /**
+     * Test if the given element is an XSLT element, optionally the one with the given name.
+     * @param {XNode} element The element.
+     * @param {string} opt_wantedName The name for comparison.
+     * @returns True, if element is an XSL node. False otherwise.
+     */
+    protected isXsltElement(element: XNode, opt_wantedName?: string): boolean;
+}
+
+export { ExprContext, XPath, XmlParser, Xslt, type XsltOptions, xmlEscapeText };