xslt-processor 1.2.2 → 1.2.4

package/umd/xpath/xpath.d.ts

@@ -1,23 +1,23 @@
-import { ExprContext } from './expr-context';
+import { ExprContext } from '../xslt/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';
-import { NodeTestName } from './node-test-name';
-import { NodeTestNC } from './node-test-nc';
-import { NodeTestPI } from './node-test-pi';
-import { NodeTestText } from './node-test-text';
+import { XPathTokenRule } from './xpath-token-rule';
+import { XNode } from '../dom';
+import { NodeTestAny, NodeTestElementOrAttribute, NodeTestNC, NodeTestName, NodeTestText, NodeTestComment, NodeTestPI } from './node-tests';
 export declare class XPath {
     xPathParseCache: any;
     xPathRules: any[];
+    xPathLog: (message: string) => void;
+    lexerCount: number;
+    parseCount: number;
+    reduceCount: number;
     xPathGrammarRules: ((number | {
         label: string;
         key: any;
-    } | {
+    } | (XPathTokenRule | {
         label: string;
         key: any;
-    }[] | ((rel: any, slash: any, step: any) => any))[] | (number | {
+    })[] | ((rel: any, slash: any, step: any) => any))[] | (number | {
         label: string;
         key: any;
     } | {
@@ -36,10 +36,10 @@ export declare class XPath {
     }[] | ((expr: any, predicates: any) => any))[] | (number | boolean | {
         label: string;
         key: any;
-    } | {
+    } | (XPathTokenRule | {
         label: string;
         key: any;
-    }[] | ((expr1: any, op: any, expr2: any) => BinaryExpr))[])[];
+    })[] | ((expr1: any, op: any, expr2: any) => BinaryExpr))[])[];
     constructor();
     makeTokenExpr(m: any): TokenExpr;
     passExpr(e: any): any;
@@ -101,20 +101,62 @@ export declare class XPath {
      */
     xPathExtractTagNameFromNodeTest(nodeTest: any, ignoreNonElementNodesForNTA: any): string;
     xPathMatchStack(stack: any, pattern: any): any;
+    /**
+     * Finds the best rule for the XPath expression provided.
+     * @param expression The XPath string expression.
+     * @param previous The previous matched XPath rule.
+     * @returns The found rule and the corresponding match.
+     */
+    private findXPathRuleForExpression;
+    /**
+     * Initialization for `xPathParse`.
+     * @see xPathParse
+     */
+    private xPathParseInit;
     /**
      * The entry point for the parser.
      * @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(expression: string, axis?: string, xPathLog?: (message: string) => void): any;
-    xPathParseInit(xPathLog: Function): void;
-    xPathReduce(stack: any, ahead: any, axis?: string, xpathLog?: (message: string) => void): any;
+    xPathParse(expression: string, axis?: string): any;
+    private findGrammarRuleCandidate;
+    /**
+     * DGF xPathReduce is where the magic happens in this parser.
+     * Check `src\xpath\xpath-grammar-rules.ts` to find the table of
+     * grammatical rules and precedence numbers, "The productions of the grammar".
+     *
+     * The idea here is that we want to take a stack of tokens and apply
+     * grammatical rules to them, "reducing" them to higher-level
+     * tokens. Ultimately, any valid XPath should reduce to exactly one
+     * "Expr" token.
+
+     * Reduce too early or too late and you'll have two tokens that can't reduce
+     * to single Expr. For example, you may hastily reduce a qname that
+     * should name a function, incorrectly treating it as a tag name.
+     * Or you may reduce too late, accidentally reducing the last part of the
+     * XPath into a top-level "Expr" that won't reduce with earlier parts of
+     * the XPath.
+     *
+     * A "candidate" is a grammatical rule candidate, with a given precedence
+     * number. "ahead" is the upcoming token, which also has a precedence
+     * number. If the token has a higher precedence number than
+     * the rule candidate, we'll "shift" the token onto the token stack,
+     * instead of immediately applying the rule candidate.
+     *
+     * Some tokens have left associativity, in which case we shift when they
+     * have LOWER precedence than the candidate.
+     */
+    private xPathReduce;
+    /**
+     * Utility function to sort a list of nodes. Used by xsltSort().
+     * @param context The Expression Context.
+     * @param sort TODO
+     */
     xPathSort(context: ExprContext, sort: any[]): void;
     xPathSortByKey(v1: any, v2: any): number;
-    xPathStep(nodes: any[], steps: any[], step: any, input: any, context: ExprContext): void;
+    xPathStep(nodes: any[], steps: any[], step: any, input: XNode, context: ExprContext): void;
     xPathGrammarPrecedence(frame: any): number;
     xPathTokenPrecedence(tag: any): any;
 }

package/umd/{xpath → xslt}/expr-context.d.ts

@@ -1,4 +1,5 @@
 import { XNode } from '../dom';
+import { XsltDecimalFormatSettings } from './xslt-decimal-format-settings';
 /** 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
@@ -41,12 +42,16 @@ export declare class ExprContext {
     variables: {
         [name: string]: any;
     };
+    knownNamespaces: {
+        [alias: string]: string;
+    };
     caseInsensitive: any;
     ignoreAttributesWithoutValue: any;
     returnOnFirstMatch: any;
     ignoreNonElementNodesForNTA: any;
     parent: ExprContext;
     root: XNode;
+    decimalFormatSettings: XsltDecimalFormatSettings;
     inApplyTemplates: boolean;
     baseTemplateMatched: boolean;
     /**
@@ -70,7 +75,11 @@ export declare class ExprContext {
      * @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);
+    constructor(nodeList: XNode[], outputNodeList: XNode[], opt_position?: number, opt_outputPosition?: number, opt_outputDepth?: 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

package/umd/xslt/xslt-decimal-format-settings.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 ";".
+ */
+export type XsltDecimalFormatSettings = {
+    name?: string;
+    decimalSeparator: string;
+    groupingSeparator: string;
+    infinity: string;
+    minusSign: string;
+    naN: string;
+    percent: string;
+    perMille: string;
+    zeroDigit: string;
+    digit: string;
+    patternSeparator: string;
+};

package/umd/xslt/xslt.d.ts

@@ -1,6 +1,7 @@
 import { XDocument, XNode } from '../dom';
 import { ExprContext, XPath } from '../xpath';
 import { XsltOptions } from './xslt-options';
+import { XsltDecimalFormatSettings } from './xslt-decimal-format-settings';
 /**
  * The main class for XSL-T processing. The implementation is NOT
  * complete; some xsl element are left out.
@@ -28,9 +29,11 @@ import { XsltOptions } from './xslt-options';
 export declare class Xslt {
     xPath: XPath;
     options: XsltOptions;
+    decimalFormatSettings: XsltDecimalFormatSettings;
     outputDocument: XDocument;
     outputMethod: string;
     outputOmitXmlDeclaration: string;
+    version: string;
     constructor(options?: Partial<XsltOptions>);
     /**
      * The exported entry point of the XSL-T processor.
@@ -46,14 +49,37 @@ export declare class Xslt {
      * @param output the root of the generated output, as DOM node.
      */
     protected xsltProcessContext(context: ExprContext, template: XNode, output: XNode): void;
+    /**
+     * Implements xsl:choose and its child nodes xsl:when and
+     * xsl:otherwise.
+     * @param input The Expression Context.
+     * @param template The template.
+     * @param output The output.
+     */
+    protected xsltChoose(input: ExprContext, template: any, output: any): 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
-     * @param {XDocument} destinationDocument dstDocument
-     * @returns {XNode|null} If an element node was created, the element node. Otherwise null.
+     * @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: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} dst the node being copied to, part of output document.
+     * @param {XNode} src the node being copied, part in input document.
      */
-    protected xsltCopy(destination: any, source: any, destinationDocument: any): XNode;
+    protected xsltCopyOf(dst: XNode, src: XNode): 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): void;
+    protected groupBy(xs: any, key: any): any;
     /**
      * Orders the current node list in the input context according to the
      * sort order specified by xsl:sort child nodes of the current
@@ -64,6 +90,14 @@ export declare class Xslt {
      * @todo case-order is not implemented.
      */
     protected xsltSort(context: ExprContext, template: XNode): void;
+    /**
+     * Implements `<xsl:stylesheet>` and `<xsl:transform>`, and its corresponding
+     * validations.
+     * @param template The `<xsl:stylesheet>` or `<xsl:transform>` node.
+     * @param context The Expression Context.
+     * @param output The output XML.
+     */
+    protected xsltTransformOrStylesheet(template: XNode, context: ExprContext, 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`.
@@ -76,22 +110,6 @@ export declare class Xslt {
      * value. `xsl:variable` and `xsl:with-param` override; `xsl:param` doesn't.
      */
     protected xsltVariable(input: ExprContext, template: any, override: boolean): void;
-    /**
-     * Implements xsl:choose and its child nodes xsl:when and
-     * xsl:otherwise.
-     * @param input The Expression Context.
-     * @param template The template.
-     * @param output The output.
-     */
-    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): void;
-    protected groupBy(xs: any, key: any): any;
     /**
      * Traverses the template node tree. Calls the main processing
      * function with the current input context for every child node of the
@@ -131,15 +149,6 @@ export declare class Xslt {
      * @returns TODO
      */
     protected xsltAttributeValue(value: any, context: ExprContext): any;
-    /**
-     * 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} dst the node being copied to, part of output document
-     * @param {XNode} src the node being copied, part in input document
-     * @param {XDocument} dstDocument dstDocument
-     */
-    protected xsltCopyOf(dst: any, src: any, dstDocument: any): void;
     /**
      * Evaluates an XPath expression in the current input context as a
      * match.