xslt-processor 1.1.6 → 1.2.0

package/umd/dom/util.d.ts

@@ -1,25 +1,6 @@
-export declare function assert(b: any): void;
-export declare function mapExec(array: any, func: any): void;
+export declare function mapExec(array: any[], func: Function): void;
 export declare function mapExpr(array: any, func: any): any[];
-export declare function reverseInplace(array: any): void;
-export declare function copyArray(dst: any, src: any): void;
-/**
- * This is an optimization for copying attribute lists in IE. IE includes many
- * extraneous properties in its DOM attribute lists, which take require
- * significant extra processing when evaluating attribute steps. With this
- * function, we ignore any such attributes that has an empty string value.
- */
-export declare function copyArrayIgnoringAttributesWithoutValue(dst: any, src: any): void;
-export declare function regExpEscape(text: string): string;
-/**
- * Determines whether a predicate expression contains a "positional selector".
- * A positional selector filters nodes from the nodelist input based on their
- * position within that list. When such selectors are encountered, the
- * evaluation of the predicate cannot be depth-first, because the positional
- * selector may be based on the result of evaluating predicates that precede
- * it.
- */
-export declare function predicateExprHasPositionalSelector(expr: any, isRecursiveCall?: any): any;
+export declare function reverseInPlace(array: any[]): void;
 export declare function namespaceMapAt(node: any): {
     xmlns: string;
     xml: string;

package/umd/dom/xdocument.d.ts

@@ -4,14 +4,14 @@ export declare class XDocument extends XNode {
     constructor();
     clear(): void;
     appendChild(node: any): void;
-    createElement(name: any): any;
-    createElementNS(namespace: any, name: any): any;
+    createElement(name: string): XNode;
+    createElementNS(namespace: any, name: any): XNode;
     createDocumentFragment(): XNode;
-    createTextNode(value: any): any;
-    createTransformedTextNode(value: any): any;
-    createAttribute(name: any): any;
-    createAttributeNS(namespace: any, name: any): any;
-    createComment(data: any): any;
-    createCDATASection(data: any): any;
-    createDTDSection(data: any): any;
+    createTextNode(value: any): XNode;
+    createTransformedTextNode(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;
 }

package/umd/dom/xnode.d.ts

@@ -9,11 +9,13 @@ export declare class XNode {
     lastChild: XNode;
     nextSibling: XNode;
     previousSibling: XNode;
+    siblingPosition: number;
     ownerDocument: any;
-    namespaceURI: any;
-    prefix: any;
+    namespaceUri: any;
+    prefix: string;
     localName: string;
     parentNode: XNode;
+    outputNode: XNode;
     transformedAttributes: XNode[];
     transformedChildNodes: XNode[];
     transformedNodeType: any;
@@ -26,7 +28,7 @@ export declare class XNode {
     transformedPrefix: any;
     transformedLocalName: string;
     transformedParentNode: XNode;
-    printed: boolean;
+    visited: boolean;
     escape: boolean;
     static _unusedXNodes: any[];
     constructor(type: any, name: any, opt_value: any, opt_owner: any, opt_namespace?: any);
@@ -41,7 +43,7 @@ export declare class XNode {
     init(type: any, name: string, value: string, owner: any, namespaceUri: any): void;
     protected qualifiedNameToParts(name: string): string[];
     static recycle(node: any): void;
-    static create(type: any, name: any, value: any, owner: any, namespace?: any): any;
+    static create(type: any, name: any, value: any, owner: any, namespace?: any): XNode;
     static clone(node: XNode, newOwner: XNode): XNode;
     appendChild(node: XNode): void;
     appendTransformedChild(node: XNode): void;
@@ -61,4 +63,6 @@ export declare class XNode {
     getElementsByTagName(name: any): any[];
     getElementsByTagNameNS(namespace: any, localName: any): any[];
     getElementById(id: any): any;
+    getAncestorByLocalName(localName: string): XNode | undefined;
+    getAncestorById(id: number): XNode | undefined;
 }

package/umd/xpath/common-function.d.ts

@@ -0,0 +1,8 @@
+export declare function copyArray(dst: any[], src: any[]): void;
+/**
+ * This is an optimization for copying attribute lists in IE. IE includes many
+ * extraneous properties in its DOM attribute lists, which take require
+ * significant extra processing when evaluating attribute steps. With this
+ * function, we ignore any such attributes that has an empty string value.
+ */
+export declare function copyArrayIgnoringAttributesWithoutValue(dst: any, src: any): void;

package/umd/xpath/expr-context.d.ts

@@ -1,16 +1,89 @@
 import { XNode } from '../dom';
+/** 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::* /".
+ */
 export declare class ExprContext {
     position: number;
-    nodelist: XNode[];
-    variables: any;
-    parent: any;
+    nodeList: XNode[];
+    outputPosition: number;
+    outputNodeList: XNode[];
+    outputDepth: number;
+    variables: {
+        [name: string]: any;
+    };
     caseInsensitive: any;
     ignoreAttributesWithoutValue: any;
     returnOnFirstMatch: any;
     ignoreNonElementNodesForNTA: any;
-    root: any;
-    constructor(nodelist: any[], opt_position?: number, opt_parent?: any, opt_caseInsensitive?: any, opt_ignoreAttributesWithoutValue?: any, opt_returnOnFirstMatch?: any, opt_ignoreNonElementNodesForNTA?: any);
-    clone(opt_nodelist?: any[], opt_position?: any): ExprContext;
+    parent: ExprContext;
+    root: XNode;
+    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 outputNodeList TODO
+     * @param opt_position TODO
+     * @param opt_outputPosition TODO
+     * @param opt_parent TODO
+     * @param opt_caseInsensitive TODO
+     * @param opt_ignoreAttributesWithoutValue TODO
+     * @param opt_returnOnFirstMatch TODO
+     * @param opt_ignoreNonElementNodesForNTA TODO
+     */
+    constructor(nodeList: XNode[], outputNodeList: XNode[], opt_position?: number, opt_outputPosition?: number, opt_outputDepth?: number, 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_outputNodeList TODO
+     * @param opt_position TODO
+     * @param opt_outputPosition TODO
+     * @returns TODO
+     */
+    clone(opt_nodeList?: XNode[], opt_outputNodeList?: XNode[], opt_position?: number, opt_outputPosition?: number): ExprContext;
+    cloneByOutput(opt_outputNodeList?: XNode[], opt_outputPosition?: number, opt_outputDepth?: number): ExprContext;
     setVariable(name?: any, value?: any): void;
     getVariable(name: string): any;
     setNode(position: number): void;

package/umd/xpath/expressions/function-call-expr.d.ts

@@ -1,50 +1,12 @@
 import { ExprContext } from '../expr-context';
-import { BooleanValue } from '../values/boolean-value';
-import { NodeSetValue } from '../values/node-set-value';
-import { NumberValue } from '../values/number-value';
-import { StringValue } from '../values/string-value';
 import { Expression } from './expression';
 export declare class FunctionCallExpr extends Expression {
     name: any;
     args: any[];
-    private cyrb53;
-    xpathfunctions: {
-        last(ctx: ExprContext): NumberValue;
-        position(ctx: ExprContext): NumberValue;
-        count(ctx: ExprContext): NumberValue;
-        'generate-id'(_ctx: ExprContext): StringValue;
-        id(ctx: ExprContext): NodeSetValue;
-        'xml-to-json'(ctx: ExprContext): StringValue;
-        'local-name'(context: ExprContext): StringValue;
-        'namespace-uri'(ctx: ExprContext): StringValue;
-        name(ctx: ExprContext): StringValue;
-        string(ctx: ExprContext): StringValue;
-        concat(ctx: ExprContext): StringValue;
-        'starts-with'(ctx: ExprContext): BooleanValue;
-        'ends-with'(ctx: ExprContext): BooleanValue;
-        contains(ctx: ExprContext): BooleanValue;
-        'substring-before'(ctx: ExprContext): StringValue;
-        'substring-after'(ctx: ExprContext): StringValue;
-        substring(ctx: ExprContext): StringValue;
-        'string-length'(ctx: ExprContext): NumberValue;
-        'normalize-space'(ctx: ExprContext): StringValue;
-        translate(ctx: ExprContext): StringValue;
-        matches(ctx: ExprContext): BooleanValue;
-        boolean(ctx: ExprContext): BooleanValue;
-        not(ctx: ExprContext): BooleanValue;
-        true(): BooleanValue;
-        false(): BooleanValue;
-        lang(ctx: ExprContext): BooleanValue;
-        number(ctx: ExprContext): NumberValue;
-        sum(ctx: ExprContext): NumberValue;
-        floor(ctx: ExprContext): NumberValue;
-        ceiling(ctx: ExprContext): NumberValue;
-        round(ctx: ExprContext): NumberValue;
-        'ext-join'(ctx: ExprContext): StringValue;
-        'ext-if'(ctx: ExprContext): any;
-        'ext-cardinal'(ctx: ExprContext): NodeSetValue;
+    xPathFunctions: {
+        [key: string]: Function;
     };
     constructor(name: any);
     appendArg(arg: any): void;
-    evaluate(ctx: ExprContext): any;
+    evaluate(context: ExprContext): any;
 }

package/umd/xpath/expressions/location-expr.d.ts

@@ -2,9 +2,10 @@ import { ExprContext } from "../expr-context";
 import { NodeSetValue } from "../values/node-set-value";
 import { Expression } from "./expression";
 import { XPath } from "../xpath";
+import { StepExpr } from "./step-expr";
 export declare class LocationExpr extends Expression {
     absolute: boolean;
-    steps: any[];
+    steps: StepExpr[];
     xPath: XPath;
     constructor(xPath: XPath);
     appendStep(s: any): void;

package/umd/xpath/expressions/step-expr.d.ts

@@ -1,14 +1,24 @@
-import { ExprContext } from "../expr-context";
-import { NodeSetValue } from "../values/node-set-value";
-import { Expression } from "./expression";
-import { XPath } from "../xpath";
+import { ExprContext } from '../expr-context';
+import { NodeSetValue } from '../values/node-set-value';
+import { Expression } from './expression';
+import { XPath } from '../xpath';
 export declare class StepExpr extends Expression {
     axis: any;
-    nodetest: any;
+    nodeTest: any;
     predicate: any;
     hasPositionalPredicate: any;
     xPath: XPath;
-    constructor(axis: any, nodetest: any, xPath: XPath, opt_predicate?: any);
+    constructor(axis: any, nodeTest: any, xPath: XPath, opt_predicate?: any);
+    /**
+     * Determines whether a predicate expression contains a "positional selector".
+     * A positional selector filters nodes from the nodeList input based on their
+     * position within that list. When such selectors are encountered, the
+     * evaluation of the predicate cannot be depth-first, because the positional
+     * selector may be based on the result of evaluating predicates that precede
+     * it.
+     */
+    private predicateExprHasPositionalSelector;
+    private exprReturnsNumberValue;
     appendPredicate(p: any): void;
     evaluate(context: ExprContext): NodeSetValue;
 }

package/umd/xpath/expressions/union-expr.d.ts

@@ -2,8 +2,8 @@ import { ExprContext } from "..";
 import { NodeSetValue } from "../values/node-set-value";
 import { Expression } from "./expression";
 export declare class UnionExpr extends Expression {
-    expr1: any;
-    expr2: any;
-    constructor(expr1: any, expr2: any);
-    evaluate(ctx: ExprContext): NodeSetValue;
+    expr1: Expression;
+    expr2: Expression;
+    constructor(expr1: Expression, expr2: Expression);
+    evaluate(context: ExprContext): NodeSetValue;
 }

package/umd/xpath/functions/index.d.ts

@@ -0,0 +1,2 @@
+export * from './non-standard';
+export * from './standard';

package/umd/xpath/functions/internal-functions.d.ts

@@ -0,0 +1,2 @@
+export declare function assert(b: any): void;
+export declare function regExpEscape(text: string): string;

package/umd/xpath/functions/non-standard.d.ts

@@ -0,0 +1,12 @@
+import { ExprContext } from "../expr-context";
+import { NodeSetValue, StringValue } from "../values";
+export declare function extCardinal(context: ExprContext): NodeSetValue;
+/**
+ * evaluates and returns its second argument, if the
+ * boolean value of its first argument is true, otherwise it
+ * evaluates and returns its third argument.
+ * @param context The Expression Context
+ * @returns A `BooleanValue`.
+ */
+export declare function extIf(context: ExprContext): any;
+export declare function extJoin(context: ExprContext): StringValue;

package/umd/xpath/functions/standard.d.ts

@@ -0,0 +1,33 @@
+import { ExprContext } from "../expr-context";
+import { BooleanValue, NodeSetValue, NumberValue, StringValue } from "../values";
+export declare function boolean(context: ExprContext): BooleanValue;
+export declare function ceiling(context: ExprContext): NumberValue;
+export declare function concat(context: ExprContext): StringValue;
+export declare function contains(context: ExprContext): BooleanValue;
+export declare function count(context: ExprContext): NumberValue;
+export declare function endsWith(context: ExprContext): BooleanValue;
+export declare function _false(): BooleanValue;
+export declare function floor(context: ExprContext): NumberValue;
+export declare function generateId(context: ExprContext): StringValue;
+export declare function id(context: ExprContext): NodeSetValue;
+export declare function lang(context: ExprContext): BooleanValue;
+export declare function last(context: ExprContext): NumberValue;
+export declare function localName(context: ExprContext): StringValue;
+export declare function matches(context: ExprContext): BooleanValue;
+export declare function _name(context: ExprContext): StringValue;
+export declare function namespaceUri(context: ExprContext): StringValue;
+export declare function normalizeSpace(context: ExprContext): StringValue;
+export declare function not(context: ExprContext): BooleanValue;
+export declare function number(context: ExprContext): NumberValue;
+export declare function position(context: ExprContext): NumberValue;
+export declare function round(context: ExprContext): NumberValue;
+export declare function startsWith(context: ExprContext): BooleanValue;
+export declare function _string(context: ExprContext): StringValue;
+export declare function stringLength(context: ExprContext): NumberValue;
+export declare function substring(context: ExprContext): StringValue;
+export declare function substringAfter(context: ExprContext): StringValue;
+export declare function substringBefore(context: ExprContext): StringValue;
+export declare function sum(context: ExprContext): NumberValue;
+export declare function translate(context: ExprContext): StringValue;
+export declare function _true(): BooleanValue;
+export declare function xmlToJson(context: ExprContext): StringValue;

package/umd/xpath/tokens.d.ts

@@ -1,4 +1,4 @@
-export declare const xpathAxis: {
+export declare const xPathAxis: {
     ANCESTOR_OR_SELF: string;
     ANCESTOR: string;
     ATTRIBUTE: string;
@@ -12,6 +12,7 @@ export declare const xpathAxis: {
     PRECEDING_SIBLING: string;
     PRECEDING: string;
     SELF: string;
+    SELF_AND_SIBLINGS: string;
 };
 export declare const TOK_PIPE: {
     label: string;

package/umd/xpath/xpath.d.ts

@@ -1,5 +1,6 @@
 import { ExprContext } from './expr-context';
 import { BinaryExpr, FunctionCallExpr, LiteralExpr, LocationExpr, NumberExpr, PathExpr, PredicateExpr, StepExpr, TokenExpr, UnaryMinusExpr, UnionExpr, VariableExpr } from './expressions';
+import { Expression } from './expressions/expression';
 import { NodeTestAny } from './node-test-any';
 import { NodeTestComment } from './node-test-comment';
 import { NodeTestElementOrAttribute } from './node-test-element-or-attribute';
@@ -19,6 +20,12 @@ export declare class XPath {
     }[] | ((rel: any, slash: any, step: any) => any))[] | (number | {
         label: string;
         key: any;
+    } | {
+        label: string;
+        key: any;
+    }[] | ((nodeTest: any, axis?: string) => StepExpr))[] | (number | {
+        label: string;
+        key: any;
     } | {
         label: string;
     }[] | ((name: any, pareno: any, arg1: any, args: any) => FunctionCallExpr))[] | (number | {
@@ -45,9 +52,9 @@ export declare class XPath {
     makeLocationExpr7(rel: any, dslash: any, step: any): any;
     makeStepExpr1(dot: any): StepExpr;
     makeStepExpr2(ddot: any): StepExpr;
-    makeStepExpr3(axisname: any, axis: any, nodetest: any): StepExpr;
-    makeStepExpr4(at: any, nodetest: any): StepExpr;
-    makeStepExpr5(nodetest: any): StepExpr;
+    makeStepExpr3(axisname: any, axis: any, nodeTest: any): StepExpr;
+    makeStepExpr4(at: any, nodeTest: any): StepExpr;
+    makeStepExpr5(nodeTest: any, axis?: string): StepExpr;
     makeStepExpr6(step: any, predicate: any): any;
     makeAbbrevStep(abbrev: any): StepExpr;
     makeNodeTestExpr1(): NodeTestElementOrAttribute;
@@ -69,37 +76,45 @@ export declare class XPath {
     makeLiteralExpr(token: any): LiteralExpr;
     makeNumberExpr(token: any): NumberExpr;
     makeVariableReference(dollar: any, name: any): VariableExpr;
-    makeSimpleExpr(expr: any): LocationExpr | NumberExpr | VariableExpr;
+    /**
+     * Used before parsing for optimization of common simple cases. See
+     * the begin of xPathParse() for which they are.
+     * @param expression The XPath expression.
+     * @param axis The axis, if required. Default is 'child'.
+     * @returns An `Expression` object.
+     */
+    makeSimpleExpr(expression: string, axis?: string): Expression;
     makeSimpleExpr2(expr: any): LocationExpr;
     stackToString(stack: any[]): string;
     xPathCacheLookup(expr: any): any;
-    xPathCollectDescendants(nodelist: any, node: any, opt_tagName?: any): void;
-    xPathCollectDescendantsReverse(nodelist: any, node: any): void;
+    xPathCollectDescendants(nodeList: any, node: any, opt_tagName?: any): void;
+    xPathCollectDescendantsReverse(nodeList: any, node: any): void;
     xPathEval(select: string, context: ExprContext): any;
     /**
      * DGF - extract a tag name suitable for getElementsByTagName
      *
-     * @param nodetest                     the node test
+     * @param nodeTest                     the node test
      * @param ignoreNonElementNodesForNTA  if true, the node list returned when
      *                                     evaluating "node()" will not contain
      *                                     non-element nodes. This can boost
      *                                     performance. This is false by default.
      */
-    xPathExtractTagNameFromNodeTest(nodetest: any, ignoreNonElementNodesForNTA: any): string;
+    xPathExtractTagNameFromNodeTest(nodeTest: any, ignoreNonElementNodesForNTA: any): string;
     xPathMatchStack(stack: any, pattern: any): any;
     /**
      * The entry point for the parser.
-     * @param expr a string that contains an XPath expression.
+     * @param expression a string that contains an XPath expression.
+     * @param axis The XPath axis. Used when the match does not start with the parent.
      * @param xPathLog TODO
      * @returns an expression object that can be evaluated with an
      * expression context.
      */
-    xPathParse(expr: any, xPathLog?: (message: string) => void): any;
+    xPathParse(expression: string, axis?: string, xPathLog?: (message: string) => void): any;
     xPathParseInit(xPathLog: Function): void;
-    xPathReduce(stack: any, ahead: any, xpathLog?: (message: string) => void): any;
+    xPathReduce(stack: any, ahead: any, axis?: string, xpathLog?: (message: string) => void): any;
     xPathSort(context: ExprContext, sort: any[]): void;
     xPathSortByKey(v1: any, v2: any): number;
-    xPathStep(nodes: any[], steps: any[], step: any, input: any, ctx: ExprContext): void;
+    xPathStep(nodes: any[], steps: any[], step: any, input: any, context: ExprContext): void;
     xPathGrammarPrecedence(frame: any): number;
     xPathTokenPrecedence(tag: any): any;
 }

package/umd/xslt/xslt.d.ts

@@ -1,7 +1,6 @@
 import { XDocument, XNode } from '../dom';
 import { ExprContext, XPath } from '../xpath';
 import { XsltOptions } from './xslt-options';
-import { XsltParameter } from './xslt-parameter';
 /**
  * The main class for XSL-T processing. The implementation is NOT
  * complete; some xsl element are left out.
@@ -29,25 +28,24 @@ import { XsltParameter } from './xslt-parameter';
 export declare class Xslt {
     xPath: XPath;
     options: XsltOptions;
+    outputDocument: XDocument;
     outputMethod: string;
     outputOmitXmlDeclaration: string;
-    constructor(options?: XsltOptions);
+    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.
-     * @param parameters Additional parameters to be set as variables.
      * @returns the processed document, as XML text in a string.
      */
-    xsltProcess(xmlDoc: XDocument, stylesheet: XDocument, parameters?: XsltParameter[]): string;
+    xsltProcess(xmlDoc: XDocument, stylesheet: XDocument): 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 the root of the generated output, as DOM node.
-     * @param _parameters Extra parameters.
      */
-    protected xsltProcessContext(context: ExprContext, template: XNode, output: XNode, _parameters: XsltParameter[]): void;
+    protected xsltProcessContext(context: ExprContext, template: XNode, output: XNode): void;
     /**
      * Implements `xsl:copy` for all node types.
      * @param {XNode} destination the node being copied to, part of output document
@@ -77,7 +75,7 @@ export declare class Xslt {
      * 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(input: ExprContext, template: any, override: boolean, _parameters: XsltParameter[]): void;
+    protected xsltVariable(input: ExprContext, template: any, override: boolean): void;
     /**
      * Implements xsl:choose and its child nodes xsl:when and
      * xsl:otherwise.
@@ -85,14 +83,14 @@ export declare class Xslt {
      * @param template The template.
      * @param output The output.
      */
-    protected xsltChoose(input: ExprContext, template: any, output: any, _parameters: XsltParameter[]): void;
+    protected xsltChoose(input: ExprContext, template: any, output: any): void;
     /**
      * Implements `xsl:for-each`.
      * @param input The Expression Context.
      * @param template The template.
      * @param output The output.
      */
-    protected xsltForEach(context: ExprContext, template: XNode, output: XNode, _parameters: XsltParameter[]): void;
+    protected xsltForEach(context: ExprContext, template: XNode, output: XNode): void;
     protected groupBy(xs: any, key: any): any;
     /**
      * Traverses the template node tree. Calls the main processing
@@ -102,7 +100,7 @@ export declare class Xslt {
      * @param template The XSL-T definition.
      * @param output The XML output.
      */
-    protected xsltChildNodes(context: ExprContext, template: any, output: XNode, _parameters: XsltParameter[]): void;
+    protected xsltChildNodes(context: ExprContext, template: XNode, output: XNode): void;
     /**
      * Passes template text to the output. The current template node does
      * not specify an XSL-T operation and therefore is appended to the
@@ -111,9 +109,8 @@ export declare class Xslt {
      * @param context The Expression Context.
      * @param template The XSLT stylesheet or transformation.
      * @param output The output.
-     * @param outputDocument The output document, if the case.
      */
-    protected xsltPassThrough(context: ExprContext, template: any, output: XNode, outputDocument: XDocument, _parameters?: XsltParameter[]): void;
+    protected xsltPassThrough(context: ExprContext, template: XNode, output: XNode): void;
     /**
      * Determines if a text node in the XSLT template document is to be
      * stripped according to XSLT whitespace stripping rules.
@@ -148,11 +145,30 @@ export declare class Xslt {
      * match.
      * @see [XSLT] section 5.2, paragraph 1
      * @param match TODO
-     * @param context TODO
-     * @returns 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): any;
+    protected xsltMatch(match: string, context: ExprContext, axis?: string): XNode[];
     private xsltLocationExpressionMatch;
+    /**
+     * Finds all the nodes through absolute xPath search.
+     * Returns only nodes that match either the context position node,
+     * or an ancestor.
+     * @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;
     /**
      * Sets parameters defined by xsl:with-param child nodes of the
      * current template node, in the current input context. This happens
@@ -161,8 +177,6 @@ export declare class Xslt {
      * @param input TODO
      * @param template TODO
      */
-    protected xsltWithParam(input: ExprContext, template: any, _parameters: XsltParameter[]): void;
-    private absoluteXsltMatch;
-    private relativeXsltMatch;
+    protected xsltWithParam(input: ExprContext, template: any): void;
     protected isXsltElement(element: any, opt_wantedName?: string): boolean;
 }