# All Classes

- All Classes Interface Summary Class Summary Enum Summary Exception Summary
  Class | Description
  --- | ---
  Abs | This class implements the fn:abs() function
  AbsentExtensionElement | This element is a surrogate for an extension element (or indeed an xsl element) for which no implementation is available.
  AbsolutePath | Represents the path from the root of an XDM tree to a specific node, as a sequence of (name, position) pairs
  AbsolutePath.PathElement | Inner class representing one step in the path
  AbsorbingFunctionCallAdjunct | Handle streaming for calls to user-defined functions with streamability="absorbing"
  AbsorptionFeed | This class is used as an abstract superclass for expressions where the consuming operand is absorbed by the expression: for example, data(), string(), or copy-of().
  AbsorptionFeed.PendingItem | A pending item represents a tree under construction.
  AbstractArrayItem | An abstract implementation of XDM array items, containing methods that can be implemented generically.
  AbstractDestination | An abstract class providing reusable code for implementing the `Destination` interface}
  AbstractFunction | Abstract superclass (and factory class) for implementations of Function
  AbstractNodeWrapper | A node in the XML parse tree representing an XML element, character content, or attribute.
  AbstractNumberer | Class AbstractNumberer is a base implementation of Numberer that provides language-independent default numbering This supports the xsl:number element.
  AbstractReceiver | An abstract implementation of `Receiver` in which all events are (by default) ignored
  AbstractResourceCollection | AbstractCollection is an abstract superclass for the various implementations of ResourceCollection within Saxon.
  AbstractResourceCollection.InputDetails | Information about a resource
  AbstractStaticContext | An abstract and configurable implementation of the StaticContext interface, which defines the static context of an XPath expression.
  AbstractTraceListener | This is the standard trace listener used when the -T option is specified on the command line.
  AbstractVirtualNode | AbstractVirtualNode is an abstract superclass for VirtualNode implementations in which the underlying node is itself a Saxon NodeInfo.
  AbstractWatch | A Watch represents a class that is interested in looking at nodes for the purpose of evaluating uniqueness and key constraints, or for XSLT streaming.
  AbstractXMLFilter | AbstractFilterImpl is skeletal implementation of the SAX XMLFilter interface, used for both streaming and non-streaming filters.
  AccessorFn | This class supports the get_X_from_Y functions defined in XPath 2.0
  AccessorFn.Component |
  AccessorFn.DayFromDate |
  AccessorFn.DayFromDateTime |
  AccessorFn.DaysFromDuration |
  AccessorFn.HoursFromDateTime |
  AccessorFn.HoursFromDuration |
  AccessorFn.HoursFromTime |
  AccessorFn.LocalNameFromQName |
  AccessorFn.MinutesFromDateTime |
  AccessorFn.MinutesFromDuration |
  AccessorFn.MinutesFromTime |
  AccessorFn.MonthFromDate |
  AccessorFn.MonthFromDateTime |
  AccessorFn.MonthsFromDuration |
  AccessorFn.NamespaceUriFromQName |
  AccessorFn.PrefixFromQName |
  AccessorFn.SecondsFromDateTime |
  AccessorFn.SecondsFromDuration |
  AccessorFn.SecondsFromTime |
  AccessorFn.TimezoneFromDate |
  AccessorFn.TimezoneFromDateTime |
  AccessorFn.TimezoneFromTime |
  AccessorFn.YearFromDate |
  AccessorFn.YearFromDateTime |
  AccessorFn.YearsFromDuration |
  AccessorFnCompiler | Generate bytecode for evaluation of accessor functions such as day-from-date, seconds-from-duration, namespace-uri=from-QName
  Accumulator | Represents a single accumulator declared in an XSLT 3.0 stylesheet
  AccumulatorAfterStreamer | Generate streaming code for an accumulator-after() function call, particularly in the case where the instruction is consuming and therefore has to defer evaluation until the endElement event.
  AccumulatorData | Holds the values of an accumulator function for one non-streamed document
  AccumulatorFn | Non-streaming implementation of accumulator-before() and accumulator-after()
  AccumulatorFn.AccumulatorAfter |
  AccumulatorFn.AccumulatorBefore |
  AccumulatorFn.Phase |
  AccumulatorManager | Manager for accumulator functions (XSLT 3.0).
  AccumulatorRegistry | Static registry for accumulators (XSLT 3.0) defined within a single package.
  AccumulatorRegistryEE | Static registry containing the accumulators defined within a package; the Saxon-EE subclass includes support for streamed accumulators.
  AccumulatorRule | This class represents one of the rules making up the definition of an accumulator
  AccumulatorWatch | This watch implements a single accumulator in streaming mode.
  Action | A functional interface that simply encapsulates a callback action of any kind, allowing the action to fail with an XPathException.
  Action | A completely general functional interface for functions that take no arguments, return void, and potentially throw a `SaxonApiException`.
  Actor | This object represents the compiled form of a user-written function, template, attribute-set, etc (the source can be either an XSLT stylesheet function or an XQuery function).
  AdaptiveEmitter | This class implements the Adaptive serialization method defined in XSLT+XQuery Serialization 3.1.
  AdjacentTextNodeMerger | This class performs the first phase of processing in "constructing simple content": it takes an input sequence, eliminates empty text nodes, and combines adjacent text nodes into one.
  AdjacentTextNodeMergerAdjunct | Streaming implementation of an AdjacentTextNodeMerger expression
  AdjacentTextNodeMergerCompiler | Generate byte code for an adjacent text node merger expression
  AdjacentTextNodeMergingIterator | AdjacentTextNodeMergingIterator is an iterator that eliminates zero-length text nodes and merges adjacent text nodes from the underlying iterator
  Adjust_1 | This class implements the XPath 2.0 functions adjust-date-to-timezone(), adjust-time-timezone(), and adjust-dateTime-timezone(), with a single argument
  Adjust_2 | This class implements the XPath 2.0 functions adjust-date-to-timezone(), adjust-time-timezone(), and adjust-dateTime-timezone(), with two arguments
  Affinity | A set of constants enumerating the possible relationships between one type and another
  Aggregate | This abstract class provides functionality common to the sum(), avg(), count(), exists(), and empty() functions.
  AllElementsSpaceStrippingRule | A whitespace stripping rule that strips all elements unless xml:space indicates that whitespace should be preserved.
  AllElementValidator | This class is validator used to check the content of an element whose complex type uses the "xs:all" construction in XML Schema.
  AllModelGroup | An AllModelGroup represents an xs:all element in the schema
  AlphaCode | An AlphaCode is a compact, context-independent string representation of a SequenceType
  Alphanumeric | This class contains static utility methods to test whether a character is alphanumeric, as defined by the rules of xsl:number: that is, whether it is in one of the Unicode categories Nd, Nl, No, Lu, Ll, Lt, Lm or Lo In Saxon 9.9 the data has been regenerated from Unicode 10.0.0.
  AlphanumericCollator | A Comparer that treats strings as an alternating sequence of alpha parts and numeric parts.
  AnalyzeMappingFunction | Mapping function that maps the sequence of matching/non-matching strings to the sequence delivered by applying the matching-substring and non-matching-substring expressions respectively to each such string
  AnalyzeString | An xsl:analyze-string element in the stylesheet.
  AnalyzeStringCompiler | Generate bytecode for a call to the xsl:analyze-string expression.
  AnalyzeStringFn | Implements the fn:analyze-string function defined in XPath 3.0.
  AnalyzeUri | This class implements the saxon:analyze-uri() function which returns a map containing the components of a URI
  AncestorCharacteristic | Given an expression, this characteristic returns a boolean indicating whether or not the context item has a parent (or ancestor, respectively) that matches a given pattern
  AncestorIterator | This class enumerates the ancestor:: or ancestor-or-self:: axes, starting at a given node.
  AncestorPatternOptimizer | A PatternOptimizer is an agent responsible for optimizing a particular class of patterns.
  AncestorQualifiedPattern | An AncestorQualifiedPattern represents a path of the form A/B or A//B, where nodes must match the pattern B and also have a parent/ancestor (respectively) that matches A.
  AnchorPattern | This is a special pattern that matches the "anchor node".
  AndExpression |
  AndExpressionCompiler | Generate bytecode for a call to the And expression
  Annotation | This class represents an annotation that appears in a function or variable declarations
  AnnotationList | An immutable list of function or variable annotations, or of annotation assertions
  AnnotationParent | An abstract superclass for schema elements whose only permitted content is an Annotation element
  AnyExternalObjectType | This class represents the type of an external object returned by an extension function, or supplied as an external variable/parameter.
  AnyFunctionType | An ItemType representing the type function(*).
  AnyFunctionTypeWithAssertions | The item type function(*) when it is preceded by one or more annotation assertions
  AnyItemType | An implementation of ItemType that matches any item (node or atomic value)
  AnyNodeTest | NodeTest is an interface that enables a test of whether a node has a particular name and type.
  AnySimpleType | This class has a singleton instance which represents the XML Schema built-in type xs:anySimpleType
  AnyType | This class has a singleton instance which represents the XML Schema built-in type xs:anyType, also known as the urtype.
  AnyTypeToStringConverterCompiler | Generate code for a AnyType to String CastExpression
  AnyTypeValidator | Validator to validate an element against the class xs:anyType
  AnyURIValue | An XPath value of type xs:anyURI.
  AppendableCharSequence | Defines a CharSequence to which characters can be appended
  ApplyFn | This class implements the function fn:apply(), which is a standard function in XQuery 3.1.
  ApplyImports | An xsl:apply-imports element in the stylesheet.
  ApplyImportsAction | Watch for an xsl:apply-imports instruction.
  ApplyImportsAdjunct | Compile an xsl:apply-imports expression/instruction to Java source code.
  ApplyImportsCompiler | Compiler for the XSLT apply-imports instruction
  ApplyNextMatchingTemplate | An xsl:apply-imports or xsl:next-match element in the stylesheet.
  ApplyTemplates | An instruction representing an xsl:apply-templates element in the stylesheet
  ApplyTemplates.ApplyTemplatesPackage | An ApplyTemplatesPackage is an object that encapsulates the sequence of nodes to be processed, the mode, the parameters to be supplied, and the execution context.
  ApplyTemplatesAction | This watch implements xsl:apply-templates in streaming mode.
  ApplyTemplatesAdjunct | Handle streaming for the xsl:apply-templates instruction
  ApplyTemplatesCompiler | Compiler for the XSLT apply-templates instruction
  ApplyTemplatesFeed | This class is used when a streaming template applies xsl:apply-templates to composed items, typically to the items in the current group established using xsl:for-each-group
  Archive | Implementation of extension functions in the EXPath Archive package, see http://expath.org/spec/archive
  Archive.ArchiveType |
  Archive.CompressionType |
  ARegexIterator | Class ARegexIterator - provides an iterator over matched and unmatched substrings.
  ARegularExpression | Glue class to interface the Jakarta regex engine to Saxon (The prefix 'A' indicates an Apache regular expression, as distinct from a JDK regular expression).
  ArithmeticCompiler | Generate bytecode for a call to the ArithmeticExpression
  ArithmeticExpression | Arithmetic Expression: an expression using one of the operators plus, minus, multiply, div, idiv, mod.
  ArithmeticExpression10 | Arithmetic Expression: an expression using one of the operators plus, minus, multiply, div, idiv, mod, in backwards compatibility mode: see `ArithmeticExpression` for the non-backwards compatible case.
  ArrayBlockAdjunct | Generate streaming code for a Block, that is a sequence of expressions or instructions
  ArrayFunctionSet | Function signatures (and pointers to implementations) of the functions defined in XPath 2.0
  ArrayFunctionSet.ArrayAppend | Implementation of the function array:append(array, item()*) => array
  ArrayFunctionSet.ArrayFilter | Implementation of the function array:filter(array, function) => array
  ArrayFunctionSet.ArrayFlatten | Implementation of the function array:flatten => item()*
  ArrayFunctionSet.ArrayFoldLeft | Implementation of the function array:fold-left(array, item()*, function) => array
  ArrayFunctionSet.ArrayFoldRight | Implementation of the function array:fold-left(array, item()*, function) => array
  ArrayFunctionSet.ArrayForEach | Implementation of the function array:for-each(array, function) => array
  ArrayFunctionSet.ArrayForEachPair | Implementation of the function array:for-each-pair(array, array, function) => array
  ArrayFunctionSet.ArrayFromSequence | Implementation of the function array:_from-sequence(item()*) => array(*) which is used internally for the implementation of array{} and of the saxon:array extension
  ArrayFunctionSet.ArrayGet | Implementation of the function array:get(array, xs:integer) => item()*
  ArrayFunctionSet.ArrayHead | Implementation of the function array:head(array) => item()*
  ArrayFunctionSet.ArrayInsertBefore | Implementation of the function array:insert-before(array, xs:integer, item()*) => array
  ArrayFunctionSet.ArrayJoin | Implementation of the function array:join(arrays) => array
  ArrayFunctionSet.ArrayPut | Implementation of the function array:put(arrays, index, newValue) => array
  ArrayFunctionSet.ArrayRemove | Implementation of the function array:remove(array, xs:integer) => array
  ArrayFunctionSet.ArrayReverse | Implementation of the function array:reverse(array, xs:integer, xs:integer) => array
  ArrayFunctionSet.ArraySize | Implementation of the function array:size(array) => integer
  ArrayFunctionSet.ArraySubarray | Implementation of the function array:subarray(array, xs:integer, xs:integer) => array
  ArrayFunctionSet.ArrayTail | Implementation of the function array:tail(array) => item()*
  ArrayFunctionSet.ArrayToSequence | Implementation of the function array:_to-sequence(array) => item()* which is used internally for the implementation of array?*
  ArrayItem | Interface supported by different implementations of an XDM array item
  ArrayItemType | An instance of this class represents a specific array item type, for example function(xs:int) as xs:boolean
  ArrayIterator<T extends Item> | ArrayIterator is used to enumerate items held in an array.
  ArrayIterator.OfNodes | ArrayIterator.OfNodes is a subclass of ArrayIterator where the array always contains Nodes; it therefore implements the AxisIterator interface.
  ArrayMember | This class implements the saxon:array-member() extension function.
  ArrayMemberValue | This class implements the result of the saxon:array-member() extension function or the saxon:array-member instruction
  ArraySort | Implementation of the extension function array:sort(array, function) => array
  AscentFunctionCallAdjunct | Handle streaming for calls to user-defined functions with streamability="ascent"
  ASCIICharacterSet | This class defines properties of the US-ASCII character set
  Assertion | An Assertion schema component (See XML Schema 1.1 Part 1)
  AssertionFacet | Represents an assertion facet on a schema-defined simple type.
  AssertionTreeBuilder | This class sits in the validation pipeline, ready (when requested) to build subtrees of the validated document for use in testing assertions against complex types.
  Assign | Compiled instruction deriving from saxon:assign element in stylesheet.
  Assignation | Assignation is an abstract superclass for the kinds of expression that declare range variables: for, some, and every.
  ATokenIterator | A ATokenIterator is an iterator over the strings that result from tokenizing a string using a regular expression
  AtomicArray | A sequence of atomic values, implemented using an underlying arrayList.
  AtomicComparer | Interface representing an object that can be used to compare two XPath atomic values for equality or for ordering.
  AtomicConstructorFunction | A function item representing a constructor function for an atomic type
  AtomicItemFeed | An AtomicItemFeed is an ItemFeed in which the only allowed event is `ItemFeed.append(Item)` passing an atomic value.
  AtomicIterator<T extends AtomicValue> | A SequenceIterator is used to iterate over a sequence.
  AtomicMatchKey | Marker interface to identify an object that acts as a surrogate for an atomic value, with the property that if two atomic values are equal under the XPath 'eq' operator, then their corresponding surrogates are equal under the Java equals() comparison (and by implication, they have equal hash codes).
  AtomicSequence | Interface representing a sequence of atomic values.
  AtomicSequenceConverter | An AtomicSequenceConverter is an expression that performs a cast (or other supplied conversion) on each member of a supplied sequence
  AtomicSequenceConverter.AtomicSequenceMappingFunction | Mapping function wrapped around a converter
  AtomicSequenceConverter.ToStringMappingFunction | Mapping function that converts every item in a sequence to a string
  AtomicSequenceConverterAdjunct | Compile a AtomicSequenceConverter or UntypedSequenceConverter expression to streaming code.
  AtomicSequenceConverterCompiler | Generate bytecode for an AtomicSequenceConverter or UntypedSequenceConverter expression, performing run-time type checking
  AtomicSortComparer | An AtomicComparer used for comparing atomic values of arbitrary item types.
  AtomicType | Interface for atomic types (these are either built-in atomic types or user-defined atomic types).
  AtomicTypeValidator | Abstract superclass for generated bytecode for validating atomic values against user-defined atomic types
  AtomicTypeValidatorCompiler | Class to handle bytecode generation for user-defined atomic types
  AtomicValue | The AtomicValue class corresponds to the concept of an atomic value in the XPath 2.0 data model.
  AtomizedValueIterator | Interface implemented by an iterator that can deliver atomized results.
  Atomizer | An Atomizer is an expression corresponding essentially to the fn:data() function: it maps a sequence by replacing nodes with their typed values
  AtomizerAdjunct | Streaming adjunct class for an atomizer (or call on the data() function)
  AtomizerCompiler | Generate code for Atomizer
  AtomizingIterator | AtomizingIterator returns the atomization of an underlying sequence supplied as an iterator.
  AttributeCollectionImpl | AttributeCollectionImpl is an implementation of the SAX2 interface Attributes.
  AttributeCreator | Abstract class for fixed and computed attribute constructor expressions
  AttributeDecl | An XML Schema Attribute Declaration.
  AttributeGetter | An AttributeGetter is an expression that returns the value of a specific attribute of the context item, provided that it is an untyped element node.
  AttributeGetterCompiler | Generate bytecode for evaluation of an AxisExpression
  AttributeGroupDecl | An XML Schema Attribute Group Declaration.
  AttributeGroupReference | An XML Schema Attribute Group Reference, corresponding to an xs:attributeGroup element with a 'ref' attribute.
  AttributeImpl | A node in the "linked" tree representing an attribute.
  AttributeInfo | This class contains immutable information about an attribute.
  AttributeInfo.Deleted | AttributeInfo.Deleted is a subclass used to mark a deleted attribute (in XQuery Update)
  AttributeInheritor | This class handles attribute inheritance.
  AttributeIterator | AttributeIterator is an enumeration of all the attribute nodes of an Element.
  AttributeLocation | A Location corresponding to an attribute in a document (often a stylesheet)
  AttributeMap | AttributeMap represents an immutable collection of attributes available on a particular element node.
  AttributeMapWithIdentity | An implementation of AttributeMap suitable for representing attributes on a mutable tree.
  AttributeSet | The compiled form of an xsl:attribute-set element in the stylesheet.
  AttributeSorter | AttributeSorter: This filter sorts attributes into the order requested using the saxon:attribute-order serialization property
  AttributeUse | An XML Schema Attribute Use: that is, a reference to an attribute declaration from within a complex type or attribute group.
  AttributeValidator | This class is an abstract superclass for all the receivers that do element content validation.
  AttributeValueTemplate | This class represents an attribute value template.
  AttributeWildcard | This class represents an xs:anyAttribute element in the schema.
  AttrOverNodeInfo | This class is an implementation of the DOM Attr class that wraps a Saxon NodeInfo representation of an attribute or namespace node.
  AugmentedSource | This class is an extension of the JAXP Source interface.
  AutomatonState | Defines a state of a finite state machine used when validating an instance against a complex type.
  AvailableEnvironmentVariables |
  AvailableSystemProperties |
  Average | Implementation of the fn:avg function
  AxiomAttributeWrapper | A node in the XML parse tree representing an XML element, character content, or attribute.
  AxiomDocument | Information about a tree that wraps an AXIOM document
  AxiomDocument.FollowingSiblingIterator |
  AxiomDocument.PrecedingSiblingIterator |
  AxiomDocumentNodeWrapper | The document node in an AXIOM tree
  AxiomDocumentNodeWrapper.FollowingSiblingIterator |
  AxiomDocumentNodeWrapper.PrecedingSiblingIterator |
  AxiomElementNodeWrapper | A node in the XDM tree; specifically, a node that wraps an Axiom element node.
  AxiomLeafNodeWrapper | A node in the XDM tree.
  AxiomObjectModel | This interface must be implemented by any third-party object model that can be wrapped with a wrapper that implements the Saxon Object Model (the NodeInfo interface).
  AxiomParentNodeWrapper | A node in the XDM tree; specifically, a node that wraps an Axiom document node or element node.
  AxiomWriter | JDOMWriter is a Receiver that constructs a JDOM document from the stream of events
  Axis | This is an enumeration class containing constants representing the thirteen XPath axes
  AxisAtomizingIterator | This iterator returns a sequence of atomic values, the result of atomizing the sequence of nodes returned by an underlying SequenceIterator.
  AxisExpression | An AxisExpression is always obtained by simplifying a PathExpression.
  AxisExpressionAdjunct | Compile an axis expression to streaming code.
  AxisExpressionCompiler | Generate bytecode for evaluation of an AxisExpression
  AxisInfo | An axis, that is a direction of navigation in the document structure.
  AxisIterator | A SequenceIterator is used to iterate over a sequence of items.
  Base64BinaryEmitter | This emitter implements output method saxon:base64Binary.
  Base64BinaryValue | A value of type xs:base64Binary
  BasePatternWithPredicate | Class for handling patterns with simple non-positional boolean predicates
  BaseUri_1 | This class implements the fn:base-uri() function in XPath 2.0
  BaseURICompiler | Generate bytecode for evaluation of a call to the BaseURI function
  BasicTransformerFactory | A TransformerFactory instance can be used to create Transformer and Template objects.
  BasicUpdatingExpression | A basic updating expression: insert, replace, delete, rename (but not copy)
  BigDecimalValue | An implementation class for decimal values other than integers
  BigDecimalValue.DecimalComparable | A Comparable that performs comparison of a DecimalValue either with another DecimalValue or with some other representation of an XPath numeric value
  BigIntegerValue | An integer value: note this is a subtype of decimal in XML Schema, not a primitive type.
  BigIntegerValue.BigIntegerComparable | A Comparable that performs comparison of BigInteger values either with other BigInteger values or with other representations of XPath numeric values
  BigRangeIterator | An Iterator that produces numeric values in a monotonic sequence, where the integers may exceed the range of a Long
  BinaryEmitter | This is an abstract superclass for the two binary output methods saxon:base64Binary and saxon:hexBinary.
  BinaryExpression | Binary Expression: a numeric or boolean expression consisting of the two operands and an operator
  BinaryResource | A binary resource that might appear in a resource collection.
  BinaryTextDecoder | This class generates decodes processing instructions in text output that represent text encoded in base64 binary or hexBinary
  Bindery | The Bindery class holds information about variables and their values.
  Bindery.FailureValue | A value that can be saved in a global variable to indicate that evaluation failed, and that subsequent attempts at evaluation should also fail
  Binding | Binding is a interface used to represent the run-time properties and methods associated with a variable: specifically, a method to get the value of the variable.
  BindingReference | BindingReference is a interface used to mark references to a variable declaration.
  Block | An expression that delivers the concatenation of the results of its subexpressions.
  BlockAdjunct | Generate streaming code for a Block, that is a sequence of expressions or instructions
  BlockCompiler | Generate bytecode for a call to a Block expression.
  BlockIterator | Iterate over the instructions in a sequence of instructions (or an XPath comma expression), concatenating the result of each instruction into a single combined sequence.
  BMPString | An implementation of UnicodeString optimized for strings that contain no characters outside the BMP (i.e.
  BooleanExpression | Boolean expression: two truth values combined using AND or OR.
  BooleanExpressionPattern | A BooleanExpressionPattern is a pattern of the form .[ Expr ] introduced in XSLT 3.0.
  BooleanFn | This class supports the XPath function boolean()
  BooleanFnCompiler | Compile the fn:boolean() function to Java bytecode
  BooleanFnFeed | Feed implementation supporting the `fn:boolean()` and `fn:not()` functions
  BooleanFnFeed.Negative | Feed implementation for the fn:not function
  BooleanFnFeed.Positive | Feed implementation for the fn:boolean function
  BooleanFnStreamer | Streaming code for an fn:boolean() function call
  BooleanToDoubleCompiler | Bytecode generator for a cast from boolean to double
  BooleanToFloatCompiler | Generate code for a Boolean to Float CastExpression
  BooleanToIntegerCompiler | Generate code for a Boolean to Integer CastExpression
  BooleanToStringCompiler | Generate code for a Boolean to String CastExpression
  BooleanToUntypedAtomicCompiler | Generate code for a Boolean to UntypedAtomic CastExpression
  BooleanValue | A boolean XPath value
  BreakInstr | A compiled xsl:break instruction.
  BreakInstrCompiler | Compiler for xsl:break within xsl:iterate (XSLT 3.0)
  BufferingApplyTemplatesFeed | This class is used when a streaming xsl:for-each requests processing of a grounded consuming sequence with a static dependency on last()
  BufferingFeed | A BufferingFeed is used to wrap an expression that does not have intrinsic capability to accept streamed input.
  BufferingFilterExpressionFeed | This class is used when a streaming template requests filtering of items that don't come directly from the streamed document, but rather are constructed in the course of the push pipeline
  BufferingForEachExpressionFeed | This class is used when a streaming xsl:for-each requests processing of a grounded consuming sequence with a static dependency on last()
  Builder | The abstract Builder class is responsible for taking a stream of SAX events and constructing a Document tree.
  BuilderMonitor | A BuilderMonitor can be inserted into a pipeline immediately in front of a Builder.
  BuildingContentHandler | A SAX `ContentHandler` that builds a Saxon tree, and allows the node at the root of the tree to be retrieved on completion.
  BuildingStreamWriter | A BuildingStreamWriter allows a document to be constructed by calling the methods defined in the `XMLStreamWriter` interface; after the document has been constructed, its root node may be retrieved by calling the `getDocumentNode()` method.
  BuildingStreamWriterImpl | This class is an implementation of `XMLStreamWriter`, allowing a document to be constructed by means of a series of XMLStreamWriter method calls such as writeStartElement(), writeAttribute(), writeCharacters(), and writeEndElement().
  BuiltInAtomicType | This class represents a built-in atomic type, which may be either a primitive type (such as xs:decimal or xs:anyURI) or a derived type (such as xs:ID or xs:dayTimeDuration).
  BuiltInFunctionSet | This class is used to contain information about a set of built-in functions.
  BuiltInFunctionSet.Entry | An entry in the table describing the properties of a function
  BuiltInListType | This class is used to implement the built-in list types NMTOKENS, ENTITIES, IDREFS.
  BuiltInRuleSet | Defines a set of built-in template rules (rules for use when no user-defined template rules match a given node)
  BuiltInType | This non-instantiable class acts as a register of Schema objects containing all the built-in types: that is, the types defined in the "xs" namespace.
  ByteCodeCandidate | A ByteCodeCandidate is an expression on the expression tree which, if evaluated, returns the value of its single operand.
  ByteCodeMonitor | Class to accumulate statistics on the effectiveness of byte code generation.
  ByteCodeTrace | Calls to this class are inserted into the bytecode for debugging purposes
  Calculator | This class evaluates arithmetic expressions; it acts as a helper class to the ArithmeticExpression class.
  Calculator.AnyDivAny | Arithmetic: anyAtomicType div AnyAtomicType
  Calculator.AnyIdivAny | Arithmetic: anyAtomicType idiv AnyAtomicType
  Calculator.AnyMinusAny | Arithmetic: anyAtomicType - AnyAtomicType
  Calculator.AnyModAny | Arithmetic: anyAtomicType mod AnyAtomicType
  Calculator.AnyPlusAny | Arithmetic: anyAtomicType + AnyAtomicType
  Calculator.AnyTimesAny | Arithmetic: anyAtomicType * AnyAtomicType
  Calculator.DecimalDivDecimal | Arithmetic: decimal div decimal (including types that promote to decimal, that is, integer)
  Calculator.DecimalIdivDecimal | Arithmetic: decimal idiv decimal (including types that promote to decimal, that is, integer)
  Calculator.DecimalMinusDecimal | Arithmetic: decimal - decimal (including types that promote to decimal, that is, integer)
  Calculator.DecimalModDecimal | Arithmetic: decimal mod decimal (including types that promote to decimal, that is, integer)
  Calculator.DecimalPlusDecimal | Arithmetic: decimal + decimal (including types that promote to decimal, that is, integer)
  Calculator.DecimalTimesDecimal | Arithmetic: decimal * decimal (including types that promote to decimal, that is, integer)
  Calculator.DoubleDivDouble | Arithmetic: double div double (including types that promote to double)
  Calculator.DoubleMinusDouble | Arithmetic: double - double (including types that promote to double)
  Calculator.DoubleModDouble | Arithmetic: double mod double (including types that promote to double)
  Calculator.DoublePlusDouble | Arithmetic: double + double (including types that promote to double)
  Calculator.DoubleTimesDouble | Arithmetic: double * double (including types that promote to double)
  Calculator.FloatDivFloat | Arithmetic: float div float (including types that promote to float)
  Calculator.FloatIdivFloat | Arithmetic: float idiv float (including types that promote to float)
  Calculator.FloatMinusFloat | Arithmetic: float - float (including types that promote to float)
  Calculator.FloatModFloat | Arithmetic: float mod float (including types that promote to float)
  Calculator.FloatPlusFloat | Arithmetic: float + float (including types that promote to float)
  Calculator.FloatTimesFloat | Arithmetic: float * float (including types that promote to float)
  Calculator.IntegerDivInteger | Arithmetic: integer div integer
  Calculator.IntegerIdivInteger | Arithmetic: integer idiv integer
  Calculator.IntegerMinusInteger | Arithmetic: integer - integer
  Calculator.IntegerModInteger | Arithmetic: integer mod integer
  Calculator.IntegerPlusInteger | Arithmetic: integer + integer
  Calculator.IntegerTimesInteger | Arithmetic: integer * integer
  CalculatorCompiler | This class generates bytecode for arithmetic expressions; it acts as a helper class to the ArithmeticCompiler class.
  CalculatorCompiler.AnyDivAny | Arithmetic: anyAtomicType div AnyAtomicType
  CalculatorCompiler.AnyIdivAny | Arithmetic: anyAtomicType idiv AnyAtomicType
  CalculatorCompiler.AnyMinusAny | Arithmetic: anyAtomicType - AnyAtomicType
  CalculatorCompiler.AnyModAny |
  CalculatorCompiler.AnyPlusAny | Arithmetic: anyAtomicType + AnyAtomicType
  CalculatorCompiler.AnyTimesAny | Arithmetic: anyAtomicType * AnyAtomicType
  CalculatorCompiler.DecimalDivDecimal | Arithmetic: decimal / decimal (including types that promote to decimal, that is, integer)
  CalculatorCompiler.DecimalIdivDecimal | Arithmetic: decimal % decimal (including types that promote to decimal, that is, integer)
  CalculatorCompiler.DecimalMinusDecimal | Arithmetic: decimal - decimal (including types that promote to decimal, that is, integer)
  CalculatorCompiler.DecimalModDecimal | Arithmetic: decimal % decimal (including types that promote to decimal, that is, integer)
  CalculatorCompiler.DecimalPlusDecimal | Arithmetic: decimal + decimal (including types that promote to decimal, that is, integer)
  CalculatorCompiler.DecimalTimesDecimal | Arithmetic: decimal * decimal (including types that promote to decimal, that is, integer)
  CalculatorCompiler.DoubleDivDouble | Arithmetic: double / double (including types that promote to double)
  CalculatorCompiler.DoubleMinusDouble | Arithmetic: double - double (including types that promote to double)
  CalculatorCompiler.DoubleModDouble | Arithmetic: double % double (including types that promote to double)
  CalculatorCompiler.DoublePlusDouble | Arithmetic: double + double (including types that promote to double)
  CalculatorCompiler.DoubleTimesDouble | Arithmetic: double * double (including types that promote to double)
  CalculatorCompiler.FloatDivFloat | Arithmetic: float div float (including types that promote to float)
  CalculatorCompiler.FloatIdivFloat | Arithmetic: float idiv float (including types that promote to float)
  CalculatorCompiler.FloatMinusFloat | Arithmetic: float - float (including types that promote to float)
  CalculatorCompiler.FloatModFloat | Arithmetic: float mod float (including types that promote to float)
  CalculatorCompiler.FloatPlusFloat | Arithmetic: float + float (including types that promote to float))
  CalculatorCompiler.FloatTimesFloat | Arithmetic: float * float (including types that promote to float)
  CalculatorCompiler.IntegerDivInteger |
  CalculatorCompiler.IntegerIdivInteger |
  CalculatorCompiler.IntegerMinusInteger |
  CalculatorCompiler.IntegerModInteger |
  CalculatorCompiler.IntegerPlusInteger |
  CalculatorCompiler.IntegerTimesInteger |
  CalendarValue | Abstract superclass for Date, Time, and DateTime.
  CalendarValueComparer | A comparer specifically for comparing two date, time, or dateTime values
  Callable | A generic interface for calling expressions by supplying the values of their subexpressions
  CallableExpressionCompiler | Compiler for a CallableExpression.
  CallableFeed | A CallableFeed is used to wrap an expression that does (a) not have intrinsic capability to accept streamed input, and (b) does not expect any operand to be a sequence, and (c) implements the Callable interface.
  CallableFunction | A function item that wraps a Callable
  CallableWithBoundFocus | A Callable that wraps another Callable and a Dynamic Context, in effect acting as a closure that executes the original callable with a saved context.
  Callback | A convenient place to put static methods that will be called from generated byte code
  CallTemplate | Instruction representing an xsl:call-template element in the stylesheet.
  CallTemplate.CallTemplatePackage | A CallTemplatePackage is an object that encapsulates the name of a template to be called, the parameters to be supplied, and the execution context.
  CallTemplateAdjunct |
  CallTemplateCompiler | Compiler for the XSLT apply-templates instruction
  CannotCompileException | Exception indicating that constructs were encountered in the expression tree that cannot be compiled to bytecode
  Capture | Represents a match of a captured subgroup
  Cardinality | This class contains static methods to manipulate the cardinality property of a type.
  CardinalityChecker | A CardinalityChecker implements the cardinality checking of "treat as": that is, it returns the supplied sequence, checking that its cardinality is correct
  CardinalityCheckerAdjunct | Generate streaming code for a cardinality checker
  CardinalityCheckerCompiler |
  CardinalityCheckingFeed | A Feed to go on the streaming pipeline that checks the cardinality of the sequence represented by the events passing down the pipeline.
  CardinalityCheckingIterator | CardinalityCheckingIterator returns the items in an underlying sequence unchanged, but checks that the number of items conforms to the required cardinality.
  CaseFirstCollator | A StringCollator that sorts lowercase before uppercase, or vice versa.
  CaseVariants | This class holds data about the case-variants of Unicode characters.
  CastableExpression | Castable Expression: implements "Expr castable as atomic-type?".
  CastableExpressionCompiler | Generate bytecode for evaluation of a CastableExpression
  CastExpression | Cast Expression: implements "cast as data-type ( expression )".
  CastExpressionCompiler | Generate code for a CastExpression
  CastingExpression | Casting Expression: abstract superclass for "cast as X" and "castable as X", which share a good deal of logic
  CastingTarget | This marker interface represents a type that can be used as the target of a cast or castable operation, that is, an atomic type, list type, or plain union type
  CatalogCollection | A resource collection implemented by means of a catalog file.
  CatchingReceiver | This class catches all errors thrown by a Receiver pipeline, and reports them to a specified ErrorReporter; after an error has occurred, all further events are ignored.
  Categories | Data for Regular expression character categories.
  Categories.Category | A Category is a CharacterClass represented in a regular expression as \p{Xx}.
  CDATAFilter | CDATAFilter: This ProxyReceiver converts character data to CDATA sections, if the character data belongs to one of a set of element types to be handled this way.
  Ceiling | This class supports the ceiling() function
  Chain | A chain is an implementation of Sequence that represents the concatenation of a number of subsequences.
  CharacterClass | A character class represents a set of characters for regex matching purposes.
  Characteristic<T> | A Characteristic represents a distinguishing feature of an item that may be used by several patterns in a rule chain, and which can usefully be evaluated once for all rules in the rule chain.
  CharacterMap | This class defines a character map, that is, a mapping from characters to strings used by the serializer when mapping individual characters in the output.
  CharacterMapExpander | CharacterMapExpander: This ProxyReceiver expands characters occurring in a character map, as specified by the XSLT 2.0 xsl:character-map declaration
  CharacterMapIndex | This class represents a set of named character maps.
  CharacterReferenceGenerator | A class that expands a character to a character reference, entity reference, etc, and writes the resulting reference to a writer
  CharacterSet | This interface defines properties of a character set, built in to the Saxon product.
  CharacterSetFactory | This class delivers a CharacterSet object for a given named encoding.
  CharactersFn | Implements the saxon:characters() function.
  CharSequenceConsumer | Interface that accepts a string in the form of a sequence of CharSequences, which are conceptually concatenated (though in some implementations, the final string may never be materialized in memory)
  CharSlice | This is an implementation of the CharSequence interface: it implements a CharSequence as a view of an array.
  CheckSumFilter | A filter to go on a Receiver pipeline and calculate a checksum of the data passing through the pipeline.
  ChoiceModelGroup | A ChoiceCompositor represents an xs:choice element in the schema
  Choose | Compiled representation of an xsl:choose or xsl:if element in the stylesheet.
  ChooseAdjunct | Streaming code to implement a conditional ("if/choose") expression
  ChooseCompiler | Generate code for a conditional expression (if-then-else, xsl:if, xsl:choose, typeswitch...)
  Clause | A "Clause" refers specifically to one of the clauses of a FLWOR expression, for example the "for" clause, the "let" clause, the "where" or "order by" clause.
  Clause.ClauseName |
  ClauseInfo | A "trace" clause in a FLWOR expression, added by a TraceCodeInjector
  Closable | This class represents the common ability of many XQJ classes to be closed.
  CloseNotifier | A receiver that performs specified actions when closed
  Closure | A Closure represents a value that has not yet been evaluated: the value is represented by an expression, together with saved values of all the context variables that the expression depends on.
  CodedName | An implementation of NodeName that encapsulates an integer fingerprint, a string prefix, and a reference to the NamePool from which the fingerprint was allocated.
  CodeInjector | A code injector can be used to add code to the expression tree (for example, diagnostic tracing code) during the process of parsing and tree construction
  CodepointCollatingComparer | An AtomicComparer used for comparing strings, untypedAtomic values, and URIs using the Unicode codepoint collation.
  CodepointCollator | A collating sequence that uses Unicode codepoint ordering
  CodepointEqual | Implements the XPath 2.0 fn:codepoint-equal() function.
  CodepointsToString | This class implements the function fn:codepoints-to-string()
  CodepointsToStringStreamer |
  CoercedFunction | A function item obtained by coercing a supplied function; this adds a wrapper to perform dynamic type checking of the arguments in any call, and type checking of the result.
  CollatingAtomicComparer | An AtomicComparer used for comparing strings, untypedAtomic values, and URIs using a collation.
  CollatingFunctionFixed | Abstract superclass for functions that take an optional collation argument, in which the collation is not present as an explicit argument, either because it was defaulted in the original function call, or because it has been bound during static analysis.
  CollatingFunctionFree | Generic class for all functions that take an optional collation argument, where the collation argument is supplied and has not yet been resolved.
  CollationKeyFn | Implements the collation-key function defined in the XSLT 3.0 and XPath 3.1 specifications
  CollationMatchKey | A match key for comparing strings under a collation.
  CollationURIResolver | A CollationURIResolver accepts a collation name as input, and returns a collation (represented by a `StringCollator` as output.
  CollectionFinder | An instance of CollectionFinder can be registered with the Saxon configuration; it is called in response to calls on the fn:collection() and fn:uri-collection() functions.
  CollectionFn | Implement the fn:collection() function.
  CombinedNodeTest | A CombinedNodeTest combines two node tests using one of the operators union (=or), intersect (=and), difference (= "and not").
  CommandLineOptions | This is a helper class for classes such as net.sf.saxon.Transform and net.sf.saxon.Query that process command line options
  CommandLineOptions.ParamSetter |
  Comment | An instruction representing an xsl:comment element in the stylesheet.
  CommentCompiler | Generate bytecode for the Comment Instruction
  CommentImpl | CommentImpl is an implementation of a Comment node
  CommentStripper | The CommentStripper class is a filter that removes all comments and processing instructions.
  CommonSubexpressionPromoter | This class is responsible for identifying and extracting common subexpressions within an expression.
  CompactStringValue | A compact representation of an atomic xs:string value used in saved tables for key and keyref constraints, designed to economize on space.
  ComparableAtomicValueComparer | A comparer for comparing two "ordinary" atomic values, where the values implement the Comparable interface and the equals() method with the appropriate XPath semantics.
  Compare | This class implements the XPath 2.0 fn:compare() function
  CompareToConstant | This class implements a comparison of a computed value to a literal constant using one of the operators eq, ne, lt, gt, le, ge.
  CompareToIntegerConstant | This class implements a comparison of a numeric value to an integer constant using one of the operators eq, ne, lt, gt, le, ge.
  CompareToIntegerConstantCompiler | Generate code for a CompareToIntegerConstant
  CompareToStringConstant | This class implements a comparison of a computed value to a string constant using one of the operators eq, ne, lt, gt, le, ge.
  CompareToStringConstantCompiler | Generate code for a CompareToStringConstant
  ComparisonException | A `ComparisonException` is a `ClassCastException` that encapsulates an `XPathException`.
  ComparisonExpression | Interface implemented by expressions that perform a comparison
  Compilation | Represents an XSLT compilation episode, compiling a single package.
  CompiledAxisMappingFunction | Abstract MappingFunction class that must be passed to a MappingIterator.
  CompiledBlockIterator | Iterate over the instructions in the Block, concatenating the result of each instruction into a single combined sequence.
  CompiledContextMappingFunction | Abstract ContextMappingFunction class that must be passed to a ContextMappingIterator.
  CompiledExpression | An expression that has been compiled to Java bytecode.
  CompiledExpressionCompiler | Compiler for a CompiledExpression.
  CompiledFilterIterator | A CompiledFilterIterator filters an input sequence using a filter expression.
  CompiledItemMappingFunction |
  CompileQuery | This class implements the saxon:compile-query() extension function
  CompilerInfo | This class exists to hold information associated with a specific XSLT compilation episode.
  CompilerService | Controlling/service class for compilation of expressions to Java bytecode
  CompilerService.GeneratedClassInfo |
  CompilerService.StaticSubClasses |
  CompilerService.StaticVariableInfo |
  CompileStylesheet | This class implements the saxon:compile-stylesheet() extension function
  CompileXPath | This class implements the saxon:compile-XPath() extension function, which is specially-recognized by the system because it needs access to parts of the static context.
  ComplexContentOutputter | This class is used for generating complex content, that is, the content of an element or document node.
  ComplexContentValidator | This class is a filter that is used to validate the content of an element with a complex type.
  ComplexNodeEventFeed | This event feed supports instructions that create a document or element node.
  ComplexType | A complex type as defined in XML Schema: either a user-defined complex type, or xs:anyType, or xs:untyped.
  Component | Represents a component as defined in the XSLT 3.0 specification: for example a function, a named template, an attribute set, a global variable.
  Component.M |
  ComponentBinding | A ComponentBinding is a reference from one component to another; for example a variable reference or function call.
  ComponentDeclaration | The object represents a declaration (that is, a top-level element) in a stylesheet.
  ComponentInversion | This class represents the inversion of a template or function body
  ComponentInvocation | Represents an expression or instruction such as call-template, or a user function call, or a global variable reference, that needs to be bound to a target component, and can potentially be re-bound when the containing component is copied into another package.
  ComponentReference | A reference to a schema component.
  ComponentTest |
  ComponentTracer | A wrapper expression used to trace execution of components such as functions, templates, and global variables in XSLT and XQuery.
  ComponentWithValueConstraint | Interface for Element Declaration, Attribute Declaration and Attribute Use, created because they share common functionality for handling fixed and default values
  ComposingAdjunct | Watch factory class for an class that composes items from sequences of events: examples are copy-of(), data(), and string().
  CompoundMode | A CompoundMode is a mode representing the templates contained within an xsl:override element in a using package together with the rules in the corresponding mode of the base package.
  CompressedWhitespace | This class provides a compressed representation of a sequence of whitespace characters.
  ComputedAttribute | An instruction derived from an xsl:attribute element in stylesheet, or from an attribute constructor in XQuery, in cases where the attribute name is not known statically
  ComputedAttributeCompiler | Generate bytecode for a computed attribute constructor
  ComputedElement | An instruction representing an xsl:element element in an XSLT stylesheet, or a computed element constructor in XQuery.
  ComputedElementCompiler | Generate bytecode for a computed element constructor (or xsl:element in XSLT)
  Concat | Implementation of the fn:concat() function
  ConcatCompiler | Generate bytecode for evaluation of a Concat function
  ConcatenatingAxisIterator | An iterator over nodes, that concatenates the nodes returned by two supplied iterators.
  ConcatenatingIterator<E> | An iterator over nodes, that concatenates the nodes returned by two supplied iterators.
  ConditionalBlock | An XSLT 3.0 sequence constructor containing xsl:on-empty and/or xsl:on-non-empty instructions
  ConditionalBlockAdjunct | Generate streaming code for a conditional Block, that is a sequence constructor containing xsl:on-empty and/or xsl:on-not-empty instructions
  ConditionalBlockAdjunct.ConditionalBlockFeed |
  ConditionalInstruction | This is a marker interface for Choose and Switch instructions
  ConditionalSorter | An expression that sorts an underlying sequence into document order if some condition is true, or that returns the sequence "as is" (knowing that it doesn't need sorting) if the condition is false.
  ConditionalSorterCompiler | Generate bytecode for evaluation of a ConditionalSorterCompiler
  Configuration | This class holds details of user-selected configuration options for a set of transformations and/or queries.
  Configuration.ApiProvider | Marker interface to represent an API that is provided as a layer on top of this `Configuration`
  Configuration.LicenseFeature | This class contains constants representing features of the software that may or may not be licensed.
  ConfigurationReader | Class used to read a config.xml file and transfer all settings from the file to the Configuration
  ConfigurationReaderPE | Subclass of ConfigurationReader providing functionality particular to Saxon Professional Edition
  ConnectionPoolXQDataSource | A factory for `PooledXQConnection` objects.
  ConstantFunction | A ConstantFunction is a zero-argument function that always delivers the same result, supplied at the time the function is instantiated.
  ConstantFunction.False |
  ConstantFunction.True |
  ConstrainedIterator<T extends Item> | SingletonIterator: an iterator over a sequence of zero or one values
  ConstraintChecker | This class handles the checking of Schema-defined unique, key, and keyref constraints.
  ConstructorFunctionLibrary | The ConstructorFunctionLibrary represents the collection of constructor functions for atomic types.
  ConsumingOperand | This expression is used as a proxy for the consuming operand of an expression such as an arithmetic expression for which there is no explicit streaming support.
  Contains | Implements the fn:contains() function, with the collation already known
  ContainsCompiler | Generate bytecode for a call on fn:contains where the collation is known statically
  ContainsToken | Implements the fn:contains-token() function with the collation already bound.
  ContainsTokenPatternOptimizer | A PatternOptimizer is an agent responsible for optimizing a particular class of patterns.
  ContentDetector | A ContentDetector is a filter that can be added to a Receiver pipeline to note whether the current element node has children.
  ContentHandlerProxy | A ContentHandlerProxy is a Receiver that converts events into the form expected by an underlying SAX2 ContentHandler.
  ContentHandlerProxy.ContentHandlerProxyTraceListener | Create a TraceListener that will collect information about the current location in the source document.
  ContentHandlerProxyLocator | Implementation of the SAX Locator interface, used to supply location information to the ContentHandler.
  ContentType | Corresponds to a Content Type Property Record as defined in the XML Schema 1.1 specification
  ContentTypeTest | NodeTest is an interface that enables a test of whether a node matches particular conditions.
  ContentValidator | This class is an abstract superclass for all the validators.
  ContentValidator.Nillability |
  ContextAccessorFunction | A ContextAccessorFunction is a function that is dependent on the dynamic context.
  ContextItemAccessorFunction | A ContextItemAccessorFunction is a function that takes no arguments, but operates implicitly on the context item.
  ContextItemAccessorFunction.Number_0 | Subclass of ContextItemAccessorFunction to handle number().
  ContextItemAccessorFunction.StringAccessor | Subclass of ContextItemAccessorFunction to handle string-length() and normalize-space().
  ContextItemCompiler | Generate code for a context item expression (that is, "."), and also for an XSLT CurrentItemExpression (current()), which differs only in the error code it returns
  ContextItemExprAdjunct |
  ContextItemExpression | This class represents the expression "(dot)", which always returns the context item.
  ContextItemStaticInfo | A data structure that represents the required type of the context item, together with information about whether it is known to be present or absent or whether it is not known statically whether it is present or absent.
  ContextItemStaticInfoEE | Saxon-EE version of ContextItemStaticInfo, with extra information used for streamability analysis
  ContextMappingFunction | ContextMappingFunction is an interface that must be satisfied by an object passed to a ContextMappingIterator.
  ContextMappingIterator | ContextMappingIterator merges a sequence of sequences into a single flat sequence.
  ContextOriginator | Represents a construct that is responsible for originating a new context; used in analysing the stack of context objects for diagnostics
  ContextStackFrame | An entry on the context stack.
  ContextStackFrame.ApplyTemplates | Subclass of ContextStackFrame representing an xsl:apply-templates call in XSLT
  ContextStackFrame.BuiltInTemplateRule | Subclass of ContextStackFrame representing a built-in template rule in XSLT
  ContextStackFrame.CallingApplication | Subclass of ContextStackFrame representing the outermost stack frame, for the calling application
  ContextStackFrame.CallTemplate | Subclass of ContextStackFrame representing an xsl:call-template instruction in XSLT
  ContextStackFrame.FunctionCall | Subclass of ContextStackFrame representing a call to a user-defined function either in XSLT or XQuery
  ContextStackFrame.VariableEvaluation | Subclass of ContextStackFrame representing the evaluation of a variable (typically a global variable)
  ContextStackIterator | This class provides a representation of the current runtime call stack, as represented by the stack of XPathContext objects.
  ContextSwitchingExpression | Interface implemented by expressions that switch the context, for example A/B or A[B]
  Controller | The Controller underpins Saxon's implementation of the JAXP Transformer class, and represents an executing instance of a transformation or query.
  ConversionResult | This is a marker interface used as the result of methods that convert or cast values from one type to another.
  ConversionRules | This class defines a set of rules for converting between different atomic types.
  Converter | A converter implements conversions from one atomic type to another - that is, it implements the casting rules for a (source type, destination type) pair.
  Converter.Base64BinaryToHexBinary | Converts base64 to hexBinary
  Converter.BooleanToDecimal | Converts a boolean to a decimal
  Converter.BooleanToDouble | Converts a boolean to a double
  Converter.BooleanToFloat | Converts a boolean to an xs:float
  Converter.BooleanToInteger | Converts a boolean to an integer
  Converter.DateTimeToDate | Converts a dateTime to a date
  Converter.DateTimeToGDay | Converts a dateTime to a gDay
  Converter.DateTimeToGMonth | Converts a dateTime to a gMonth
  Converter.DateTimeToGMonthDay | Converts a dateTime to a gMonthDay
  Converter.DateTimeToGYear | Converts a dateTime to a gYear
  Converter.DateTimeToGYearMonth | Converts a dateTime to a gYearMonth
  Converter.DateTimeToTime | Converts a dateTime to a time
  Converter.DateToDateTime | Converts a date to a dateTime
  Converter.DecimalToInteger | Converts a decimal to an integer.
  Converter.DoubleToDecimal | Convers a double to a decimal
  Converter.DoubleToInteger | Converts a double to an integer
  Converter.DownCastingConverter | Converter that checks that a value belonging to a supertype is a valid instance of a subtype, and returns an instance of the subtype
  Converter.DurationToDayTimeDuration | Converts a duration to a dayTimeDuration
  Converter.DurationToYearMonthDuration | Converts a duration to a yearMonthDuration
  Converter.FloatToDecimal | Converts a float to a decimal
  Converter.FloatToInteger | Converts a float to an integer
  Converter.HexBinaryToBase64Binary | Converts hexBinary to base64Binary
  Converter.IdentityConverter | Converter that does nothing - it returns the input unchanged
  Converter.IntegerToDecimal | Converts an integer to a decimal
  Converter.NotationToQName | Converts Notation to QName
  Converter.NumericToBoolean | Converts a numeric value to a boolean
  Converter.NumericToDecimal | Converts any numeric value to a decimal
  Converter.NumericToDouble | Converts any numeric value to a double.
  Converter.NumericToFloat | Converts any numeric value to xs:float
  Converter.NumericToInteger | Converts any numeric value to an integer.
  Converter.PromoterToDouble | Converter that implements the promotion rules to a required type of xs:double
  Converter.PromoterToFloat | Converter that implements the promotion rules to a required type of xs:float
  Converter.QNameToNotation | Converts QName to Notation
  Converter.ToStringConverter | Converts any value to a string
  Converter.ToUntypedAtomicConverter | Converts any value to untyped atomic
  Converter.TwoPhaseConverter | Converter that operates in two phases, via an intermediate type
  Converter.UnfailingConverter | Specialisation for converters that always succeed
  Converter.UpCastingConverter | Converter that does nothing except change the type annotation of the value.
  ConverterCompiler | This class generates code to implement a casting conversion.
  ConverterCompiler.GenericConverterCompiler |
  Copy | Handler for xsl:copy elements in stylesheet.
  CopyAdjunct | Compile an xsl:copy expression/instruction to streaming code.
  CopyCompiler | Generate bytecode for an xsl:copy instruction
  CopyInformee<T> | A CopyInformee is an agent that receives extra information while a tree is being copied.
  CopyModifyExpression | A copy-modify expression (called a "transform" expression in the XQuery Update specification)
  CopyNamespaceSensitiveException | Exception indicating that an attempt was made to copy namespace-sensitive content without copying its associated namespaces
  CopyOf | An xsl:copy-of element in the stylesheet.
  CopyOfAdjunct |
  CopyOfFeed | This class is used to construct a grounded copy of a streamed node, by capturing the events representing the streamed node as they are notified, and constructing the grounded copy from these events.
  CopyOfFeed.AccumulatorCopier |
  CopyOfFn | XSLT 3.0 function copy-of().
  CopyOptions | Non-instantiable class to define options for the `NodeInfo.copy(net.sf.saxon.event.Receiver, int, net.sf.saxon.s9api.Location)` method
  Count | Implementation of the fn:count function
  CountClause | A "count" clause in a FLWOR expression
  CountClausePull | A tuple stream that implements a "count" clause in an XQuery 3.0 FLWOR expression
  CountClausePush | A tuple stream in push mode that implements a "count" clause in an XQuery 3.0 FLWOR expression
  CountCompiler | Generate bytecode for a call to the count() function
  CountingCompletionService<V> | Extension of ExecutorCompletionService to count the number of tasks submitted and take that many completed tasks before calling it a day.
  CountingFilter | A filter that can be inserted into a Receiver pipeline to count the events that pass through.
  CountingState | A counting state is a dynamic object representing the combination of an AutomatonState and a counter value
  CountStreamer | Streaming code for the count() function.
  Current | Implement the XSLT current() function
  CurrentGroup | Implements the XSLT function current-group()
  CurrentGroupCall | Implements the XSLT function current-group()
  CurrentGroupingKey | Implements the XSLT function current-grouping-key()
  CurrentGroupingKeyCall | Implements the XSLT function current-grouping-key()
  CurrentGroupPattern | This is a special pattern that matches the "anchor node".
  CurrentGroupStreamer | Provides streaming code for a call on current-group().
  CurrentItemExpression | The expression is generated when compiling the current() function in XSLT.
  CurrentMergeGroup | Implements the XSLT 3.0 function current-merge-group()
  CurrentMergeGroupStreamer | Generate streaming code for a call on current-merge-group().
  CurrentMergeKey | Implements the XSLT function current-grouping-key()
  CurrentOutputUri | This class implements the XSLT 3.0 function current-output-uri()
  CurriedFunction | A function obtained by currying another function, that is, the result of calling fn:partial-apply
  Data_1 | Implement XPath function fn:data() with a single argument
  DataElement | This element represents a top-level element in a user-defined namespace, or a child/descendant of such an element.
  DataURIScheme | This class handles URIs using the data: URI scheme defined in RFC 2397
  Date | This class implements extension functions in the http://exslt.org/dates-and-times namespace.
  DateTimeConstructor | This class supports the dateTime($date, $time) function
  DateTimeConstructorCompiler | Compile the fn:dateTime() function to Java bytecode
  DateTimeValue | A value of type `xs:dateTime`.
  DateValue | A value of type Date.
  DayTimeDurationValue | A value of type xs:dayTimeDuration.
  Debugger | This interface may be implemented by an external debugging tool
  DecimalCharacterReferenceGenerator | A class that represents a character as a decimal character reference and writes the result to a supplied Writer.
  DecimalDivide | Implements the saxon:decimal-divide() function
  DecimalFormatManager | DecimalFormatManager manages the collection of named and unnamed decimal formats, for use by the format-number() function.
  DecimalSortComparer | An AtomicComparer used for sorting values that are known to be instances of xs:decimal (including xs:integer), It also supports a separate method for getting a collation key to test equality of items
  DecimalSymbols | This class is modelled on Java's DecimalFormatSymbols, but it allows the use of any Unicode character to represent symbols such as the decimal point and the grouping separator, whereas DecimalFormatSymbols restricts these to a char (1-65535).
  DecimalValue | Abstract class representing the XDM type xs:decimal.
  Declaration | This interface represents the union of global variable declarations and function declarations in XQuery modules
  DecomposingFeed | Appends the output of an ItemFeed to an Outputter
  DeepCopyRuleSet | The built-in rule set introduced in XSLT 3.0, which performs a deep copy of any unmatched node.
  DeepDescentFunctionCallAdjunct | Handle streaming for calls to user-defined functions with streamability="absorbing"
  DeepEqual | Implements the saxon:deep-equal() function, a variant of fn:deep-equal that provides additional control over how the comparison is performed.
  DeepEqual | XSLT 2.0 deep-equal() function, where the collation is already known.
  DeepEqualStreamer | Implement streaming of deep-equal function.
  DeepSkipRuleSet | The rule set introduced in XSLT 3.0, which (for any kind of node) simply ignores the node and its descendants.
  DeepUpdate | Handler for saxon:deep-update elements in stylesheet.
  DefaultTalker |
  DelegatingArrayItem | A `DelegatingArrayItem` is an abstract class representing an array that is implemented by delegating all array-related functionality to a base class.
  DelegatingFeed | A DelegatingFeed is an ItemFeed that delegates most of its work to a supplied Outputter.
  DelegatingMapItem | A `DelegatingMapItem` is an abstract class representing a map that is implemented by delegating all map-related functionality to another map.
  DeleteAction | A pending update action representing the effect of a delete expression
  DeleteExpression | A delete expression in XQuery Update
  DescendingComparer | A Comparer used for comparing descending keys.
  Destination | A `Destination` represents a place where XDM values can be sent.
  DestinationHelper | A helper class for implementing the `Destination` interface
  DeterminizedState | A state in a determinized finite state machine
  DictionaryMap | A simple implementation of MapItem where the strings are keys, and modification is unlikely.
  DifferenceEnumeration | An enumeration representing a nodeset that is teh difference of two other NodeSets.
  DigitsFacet | Represents either of the facets totalDigits or fractionDigits
  DirectoryCollection | This class represents a resource collection containing all, or selected, files within a filestore directory.
  DistinctFacet | The saxon:distinct facet on a list type can be used to constrain the list to contain distinct values.
  DistinctValues | The XPath 2.0 distinct-values() function, with the collation argument already known
  DistinctValues.DistinctIterator | Iterator class to return the distinct values in a sequence
  DistinctValuesStreamer | Implement the distinct-values function in streaming mode.
  Doc | Implement the fn:doc() function - a simplified form of the Document function
  Doc_2 | Implement the saxon:doc() function - a variant of the fn:doc function with a second argument to supply option parameters.
  DocAvailable | Implement the fn:doc-available() function
  Doctype | A saxon:doctype element in the stylesheet.
  DocumentBuilder | A document builder holds properties controlling how a Saxon document tree should be built, and provides methods to invoke the tree construction.
  DocumentBuilderImpl | This class implements the JAXP DocumentBuilder interface, allowing a Saxon TinyTree to be constructed using standard JAXP parsing interfaces.
  DocumentFn | Implements the XSLT document() function
  DocumentImpl | A node in the XML parse tree representing the Document itself (or equivalently, the root node of the Document).
  DocumentInstr | An instruction to create a document node.
  DocumentInstrAdjunct | Evaluate an xsl:document instruction in streaming code.
  DocumentInstrAdjunct.DocumentInstrFeed |
  DocumentInstrCompiler | Generate bytecode for the xsl:document instruction in XSLT or the document-node{} constructor in XQuery
  DocumentKey | This class encapsulates a string used as the value of the document-uri() property of a document, together with a normalized representation of the string used for equality comparisons.
  DocumentNodeTest | A DocumentNodeTest implements the test document-node(element(~,~))
  DocumentNumberAllocator | This class (which has one instance per Configuration) is used to allocate unique document numbers.
  DocumentOrderIterator | DocumentOrderIterator takes as input an iteration of nodes in any order, and returns as output an iteration of the same nodes in document order, eliminating any duplicates.
  DocumentOverNodeInfo | This class is an implementation of the DOM Document class that wraps a Saxon DocumentInfo representation of a document node.
  DocumentPool | An object representing the collection of documents handled during a single transformation.
  DocumentSorter | A DocumentSorter is an expression that sorts a sequence of nodes into document order.
  DocumentSorterAdjunct | Generate streaming code for a document sorting expression node.
  DocumentSorterCompiler | Generate bytecode for a call to the DocumentSorter
  DocumentUri_1 | This class supports the document-uri() function
  DocumentValidator | DocumentValidator checks that a document is well-formed: specifically, that it contains a single element node child and no text node children.
  DocumentWrapper | The tree info object for a tree implemented as a wrapper around a DOM Document.
  DocumentWrappingPullProvider | Returns the events provided by an underlying PullProvider, with the addition of a START_DOCUMENT event immediately after the START_OF_INPUT, and an END_DOCUMENT event immediately before the END_OF_INPUT
  DoInstr | Compiled instruction deriving from saxon:do element in stylesheet.
  DOM4JDocumentWrapper | TreeInfo class for a virtual tree that wraps a DOM4J tree
  DOM4JNodeWrapper | A node in the XML parse tree representing an XML element, character content, or attribute.
  DOM4JObjectModel | This class is the DOM4J implementation of Saxon's ExternalObjectModel interface; it supports the wrapping of DOM4J documents as instances of the Saxon NodeInfo interface.
  DOM4JWriter | JDOMWriter is a Receiver that constructs a DOM4J document from the stream of events
  DOMDestination | This class represents a Destination (for example, the destination of the output of a transformation) in which the results are written to a newly constructed DOM tree in memory.
  DOMEnvelope | DOMEnvelope is an object model representation in which DOM interfaces are wrapped around Saxon NodeInfo nodes: that is, it implements the DOM on top of a Saxon tree implementation such as the tiny tree or linked tree.
  DOMExceptionImpl | DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an operation is impossible to perform (either for logical reasons, because data is lost, or because the implementation has become unstable).
  DominoAttr | An attribute node in the Domino tree
  DominoNode | A node in the Domino tree (other than an attribute or namespace node)
  DominoTree | An adaptation of the TinyTree structure, used to index a DOM.
  DominoTreeModel | Tree model implementation for the DOMINO tree
  DominoTreeModel.DominoBuilder | A Builder class for the Domino tree model
  DOMNodeList | This class wraps a list of nodes as a DOM NodeList
  DOMNodeWrapper | A node in the XML parse tree representing an XML element, character content, or attribute.
  DOMObjectModel | This interface must be implemented by any third-party object model that can be wrapped with a wrapper that implements the Saxon Object Model (the NodeInfo interface).
  DOMSender | DOMSender.java: pseudo-SAX driver for a DOM source document.
  DOMTransform | Variant of command line net.sf.saxon.Transform do build the source document in DOM and then proceed with the transformation.
  DOMWriter | DOMWriter is a Receiver that attaches the result tree to a specified Node in the DOM Document
  DotNetLocalizerFactory | Default factory for number/date localizers for the .NET platform.
  DoubleSortComparer | An AtomicComparer used for sorting values that are known to be numeric.
  DoubleToBooleanCompiler | Generate code for a Double to Boolean CastExpression
  DoubleToFloatCompiler | Generate code for a Double to Float CastExpression
  DoubleToIntegerCompiler | Generate code for a Double to Integer CastExpression
  DoubleToStringCompiler | Generate code for a Double to String CastExpression
  DoubleToUntypedAtomicCompiler | Generate code for a Double to UntypedAtomic CastExpression
  DoubleValue | A numeric (double precision floating point) value
  DummyNamespaceResolver | A dummy namespace resolver used when validating QName-valued attributes written to the result tree.
  DurationValue | A value of type xs:duration
  DynamicContextAccessor | A DynamicContextAccessor is a function that takes no arguments, but operates implicitly on the dynamic context.
  DynamicContextAccessor.CurrentDate |
  DynamicContextAccessor.CurrentDateTime |
  DynamicContextAccessor.CurrentTime |
  DynamicContextAccessor.DefaultLanguage |
  DynamicContextAccessor.ImplicitTimezone |
  DynamicLoader | Utility class used to perform dynamic loading of user-hook implementations
  DynamicLoaderEE | Specialization of DynamicLoader for use in Saxon-EE
  DynamicLoaderPE | Specialization of DynamicLoader for use in Saxon-PE
  DynamicQueryContext | This object represents a dynamic context for query execution.
  EagerLetExpression | An EagerLetExpression is the same as a LetExpression except that the variable is evaluated using eager evaluation rather than lazy evaluation.
  EarlyEvaluationContext | This class is an implementation of XPathContext used when evaluating constant sub-expressions at compile time.
  Edge | Internal class to represent the data associated with a transition: the element that triggers the transition, and the new state that results from the transition.
  Edge.MaxOccursParticle |
  Edge.MaxOccursTerm | Special singular Term identifying a transition to be used when the maxOccurs value of a counting state is reached.
  ElementAvailable | This class supports the XSLT element-available function.
  ElementCreator | An instruction that creates an element node.
  ElementCreatorAdjunct | Generate streaming code for an xsl:element instruction
  ElementCreatorCompiler | Generate bytecode.
  ElementCreatorFeed | This event feed supports instructions that create a document or element node.
  ElementDecl | The object represents an element declaration in the schema.
  ElementImpl | ElementImpl implements an element node in the Linked tree model.
  ElementNameTracker | This is a filter that can be added to a pull pipeline to remember element names so that they are available immediately after the END_ELEMENT event is notified
  ElementOverNodeInfo | This class is an implementation of the DOM Element class that wraps a Saxon NodeInfo representation of an element node.
  ElementParticle | A reference to an element declaration within the content model of a complex type.
  ElementWildcard | This class represents an `<any>` element in the schema.
  Emitter | Emitter: This abstract class defines methods that must be implemented by components that format SAXON output.
  Empty | Implementation of the fn:empty function
  EmptyAtomicSequence | An implementation of AtomicSequence that contains no items.
  EmptyAttributeMap | An implementation of AttributeMap representing an empty AttributeMap
  EmptyCharacterClass | A character class represents a set of characters for regex matching purposes.
  EmptyCompiler | Generate bytecode for the fn:empty() function
  EmptyContentValidator | This class is a filter that is used to validate that an element has empty content.
  EmptyGreatestComparer | A Comparer that modifies a base comparer by sorting empty key values and NaN values last (greatest), as opposed to the default which sorts them first.
  EmptyIntIterator | An iterator over a zero-length sequence of integers
  EmptyIterator | EmptyIterator: an iterator over an empty sequence.
  EmptySequence<T extends Item> | An EmptySequence object represents a sequence containing no members.
  EmptySource | This class is an implementation of the JAXP Source interface.
  EmptyStreamer | Streaming code for an fn:empty() function call
  EmptyString | An implementation of UnicodeString representing a zero-length string.
  EmptyTextNodeRemover | This class performs part of the processing in "constructing simple content": it takes an input sequence and eliminates empty text nodes into one.
  EmptyTextNodeRemoverAdjunct | Compile an EmptyTextNodeRemover expression to Java source code Needed only for streaming - this class is not used in XQuery
  EmptyTextNodeRemoverCompiler | Generate code for EmptyTextNodeRemover expression
  EncodeForUri | This class supports the function fn:encode-for-uri()
  Ending | This class supports the two extension functions saxon:ending-where and saxon:ending-before.
  Ending.ItemsBefore |
  Ending.ItemsUntil |
  EndsWith | Implements the fn:ends-with() function, with the collation already fixed
  EnterpriseConfiguration | A subclass of Configuration that defines a processor with Saxon-EE capabilities.
  EnterpriseTransformerFactory | The is the JAXP TransformerFactory implementation for the enterprise edition of Saxon.
  EnterpriseXPathFactory | An implementation of the JAXP XPath Factory that creates an enterprise configuration.
  EntityValidator | This class validates that elements and attributes of type ENTITY or ENTITIES have values are declared in the DOCTYPE declaration of the instance document as unparsed entities.
  Entry |
  EnumerationFacet | Represents a single enumeration facet defined on a simple type.
  EnumerationFacetSet | Represents the set of enumeration values defined on a single simple type, This is a "virtual" facet that combines all the enumeration facets in one simple type definition.
  EnumSetTool | A couple of utility methods for handling EnumSet objects.
  EnvironmentVariable | Implement the XPath 3.0 fn:environment-variable() function
  EnvironmentVariableResolver | This interface defines a Saxon plug-in used to resolve calls on the XPath 3.0 functions available-environment-variables() and environment-variable().
  EQName | This class implements the saxon:EQName extension function.
  EqualityComparer | A comparer for comparing two atomic values where (a) equals is defined, and is implemented using the Java equals() method, and (b) ordering is not defined, and results in a dynamic error.
  EqualityPatternOptimizer | A PatternOptimizer is an agent responsible for optimizing a particular class of patterns.
  EquivalenceComparer | A comparer that compares atomic values for equality, with the properties: - non-comparable types compare false - NaN compares equal to NaN
  EquivalenceComparison | Class to handle equivalence comparisons of singletons.
  EquivalenceComparisonCompiler | Generate bytecode for an equivalence expression, which is the equality test used in an XQuery 3.0 switch expression
  Erector | This class is instantiated to build a DOMINO tree, taking a DOM Document as input; its task is to add the indexing information.
  Err | Class containing utility methods for handling error messages
  Error | Implement XPath function fn:error()
  Error.UserDefinedXPathException |
  ErrorExpression | Error expression: this expression is generated when the supplied expression cannot be parsed, and the containing element enables forwards-compatible processing.
  ErrorExpressionCompiler | Generate bytecode for an error expression (an expression that throws a dynamic error if evaluated)
  ErrorIterator | A SequenceIterator that throws an exception as soon as its next() method is called.
  ErrorReporter | The ErrorReporter is a generic functional interface for reporting errors and warnings.
  ErrorReporterToListener | A bridging class that allows errors in an XSLT Transformation, or in a Query, to be reported to a JAXP `ErrorListener`.
  ErrorType | This class has a singleton instance which represents the XML Schema 1.1 built-in type xs:error.
  EscapeHtmlUri | This class supports the function fn:escape-html-uri()
  Eval | This class implements the saxon:eval() extension function
  Evaluate | This class implements the saxon:evaluate() extension function
  Evaluate.PreparedExpression | Inner class PreparedExpression represents a compiled XPath expression together with the standard variables $p1 ..
  EvaluateInstr | An EvaluateInstr is the compiled form of an xsl:evaluate instruction
  EvaluationMode | An evaluation mode represents a way in which expressions can be evaluated
  EvaluationNuisance | This filter sometimes gets inserted into a serialization pipeline when running under an evaluation license: it's a deterrent to using the evaluation version for production
  Evaluator | An Evaluator evaluates an expression to return a sequence
  Event | An event is an object representing one of the events that can be passed to a receiver: for example, a startElement, endElement, characters, or comment event.
  Event.Append | Event representing an arbitrary item being sent to the event stream in composed form.
  Event.Comment | Event representing a comment node
  Event.EndDocument | Event representing end of document
  Event.EndElement | Event representing the end of an element
  Event.ProcessingInstruction | Event representing a processing instruction node
  Event.StartDocument | Event representing start of document
  Event.StartElement | Event representing the start of an element (including attributes or namespaces)
  Event.Text | Event representing a text node
  EventBuffer | An `EventBuffer` is a receiver of events that records the events in memory for subsequent replay.
  EventMonitor | An `EventMonitor` is a filter that passes all events down the pipeline unchanged, keeping a note of whether any data has passed through the filter.
  EventSource | An implementation of the JAXP Source class that supplies a document in the form of a stream of push events sent to a Receiver
  ExceptPattern | A pattern formed as the difference of two other patterns
  Executable | A compiled stylesheet or a query in executable form.
  ExecutableFunctionLibrary | An ExecutableFunctionLibrary is a function library that contains definitions of functions for use at run-time.
  ExistenceFeed | ItemFeed implementation supporting the `fn:exists()`, `fn:empty()`, and `fn:count()` function
  Exists | Implementation of the fn:exists function
  ExistsCompiler | Generate bytecode for a call to the exists() function
  ExistsStreamer | Streaming code for an fn:exists() function call
  ExpandedStreamResult | An ExpandedStreamResult is similar to a StreamResult, and is created from a StreamResult.
  EXPathBinary | Implementation of extension functions in the EXPath Binary package, see http://expath.org/spec/binary
  EXPathFile | Implementation of extension functions in the EXPath File package, see http://expath.org/spec/file
  EXPathFileFunctionSet | Implementation of the file:base-dir function in the EXPath file library.
  EXPathFileFunctionSet.BaseDir |
  ExperimentalSequenceTypeMarshaller |
  ExperimentalXPathCompiler | This class provides support to the xslt-in-xslt compiler.
  ExplicitTimezoneFacet | Represents an explicitTimezone facet on a schema-defined simple type derived from date, time, dateTime, gYear, gYearMonth, gMonth, gMonthDay, or gDay
  ExportAgent | An export agent performs the job of exporting an expression to a SEF file.
  Expression | Interface supported by an XPath expression.
  ExpressionAction | General action class which can be used to process all nodes on an expression tree
  ExpressionCompiler | This abstract class represents the compiler (that is, Java bytecode generator) for a particular kind of expression on the expression tree.
  ExpressionCompilerMap |
  ExpressionContext | An ExpressionContext represents the context for an XPath expression written in the stylesheet.
  ExpressionFn | This class implements the saxon:expression() extension function.
  ExpressionOwner | Abstraction representing any class that can act as the container for an expression: either an Operand of a parent expression, or a top-level construct such as a function or template or XQuery expression
  ExpressionPresenter | This class handles the display of an abstract expression tree in an XML format with some slight resemblance to XQueryX
  ExpressionPresenter.ExportOptions |
  ExpressionPresenter.Options |
  ExpressionPresenterToJson | This class handles export of packages for Saxon-JS 2.0 by converting the XML representation of SEF files to a JSON representation, at the level of emitting events.
  ExpressionTool | This class, ExpressionTool, contains a number of useful static methods for manipulating expressions.
  ExpressionTool.ExpressionSelector | Callback for selecting expressions in the tree
  ExpressionVisitor | The ExpressionVisitor supports the various phases of processing of an expression tree which require a recursive walk of the tree structure visiting each node in turn.
  ExsltCommonFunctionSet | Implementation of the exslt-common function library.
  ExsltCommonFunctionSet.NodeSetFn | Implement exslt:node-set
  ExsltCommonFunctionSet.ObjectTypeFn | Implement exslt:object-type
  ExtensionElementFactory | Interface ExtensionElementFactory.
  ExtensionFunction | This is an interface for simple external/extension functions.
  ExtensionFunctionCall | This abstract class is provided to allow user-written extension functions to be implemented with the full capabilities of functions that are an intrinsic part of the Saxon product.
  ExtensionFunctionDefinition | This abstract class is provided to allow user-written extension functions to be implemented with the full capabilities of functions that are an intrinsic part of the Saxon product.
  ExtensionFunctionFactory | This is a marker interface representing an abstract superclass of JavaExtensionFunctionFactory and DotNetExtensionFunctionFactory.
  ExtensionInstruction | Abstract class representing an extension instruction
  Extensions | This class implements functions that are supplied as standard with SAXON, but which are not defined in the XSLT or XPath specifications.
  ExternalObject<T> | An item that wraps an external (Java or .NET) object
  ExternalObjectModel | This interface must be implemented by any third-party object model that can be wrapped with a wrapper that implements the Saxon Object Model (the NodeInfo interface).
  ExternalObjectType | This class represents the type of an external object returned by an extension function, or supplied as an external variable/parameter.
  Facet | Represents an XML Schema Facet.
  FailedAccumulatorData | Represents the values of an accumulator whose evaluation has failed.
  FailedResource | FailedResource represents an item in a collection that could not be processed because of some kind of error
  FailRuleSet | The built-in rule set introduced in XSLT 3.0, which raises an error when there is no user-supplied template rule that matches a node.
  FastStringBuffer | A simple implementation of a class similar to StringBuffer.
  Feature<T> | Feature defines a set of constants, representing the details of Saxon configuration options which can be supplied to the Saxon method Configuration.setProperty(), and to other interfaces
  FeatureCode | FeatureCode defines a set of integer constants, representing unique identifiers for the features that can be configured.
  FeatureData |
  FeatureKeys | FeatureKeys defines a set of constants, representing the names of Saxon configuration options which can be supplied to the Saxon implementations of the JAXP interfaces TransformerFactory, SchemaFactory, Validator, and ValidationHandler, and to other interfaces such as the s9api `Processor`
  FeedMaker | An expression that can be evaluated in streaming mode is represented at compile time by a list of FeedMaker objects.
  FeedToEventBuffer | An ItemFeed that captures all written events in a buffer for subsequent replay.
  FieldChecker | A FieldChecker is instantiated when a field in an identity constraint is matched; it receives notification of all events until the end of the element (or attribute) that matched the selector.
  FieldOrSelector | The selector of an IdentityConstraint
  FieldWatch | A FieldWatch is a class that is looking for nodes that match a field selector within a uniqueness or key constraint.
  FilterExpression | A FilterExpression contains a base expression and a filter predicate, which may be an integer expression (positional filter), or a boolean expression (qualifier)
  FilterExpressionAdjunct | Generate streaming code for a filter expression (when not part of a Watch).
  FilterExpressionCompiler | Generate bytecode to evaluate a filter expression
  FilterFactory | Factory class to create a ProxyReceiver which filters events on a push pipeline
  FilterFn | This class implements the function fn:filter(), which is a standard function in XQuery 3.0
  FilterFnStreamer | Generate streaming code for the fn:filter function.
  FilterFunctionCallAdjunct | Handle streaming for calls to user-defined functions with streamability="filter"
  FilterImpl | FilterImpl is an XMLFilter (a SAX2 filter) that performs a transformation taking a SAX stream as input and producing a SAX stream as output.
  FilteringAdjunct | A subclass of StreamingAdjunct used for expressions that have a sequence-valued operand with usage transmission.
  FilteringFeed | This class selects a subset of the items, nodes, or events selected by some supplying expression.
  FilteringFeed.Filter | Interface defining the filter function, to be implemented by the caller
  FilteringFeed.OpaqueFilter | A filter that matches nothing
  FilteringFeed.TransparentFilter | A filter that matches everything
  FilterIterator | A FilterIterator filters an input sequence using a filter expression.
  FilterIterator.NonNumeric | Subclass to handle the common special case where it is statically known that the filter cannot return a numeric value
  FingerprintedQName | A QName triple (prefix, URI, local) with the additional ability to hold an integer fingerprint.
  FiniteStateMachine | Class representing a finite state machine, as a collection of states with transitions between them.
  FiniteStateMachine.TermParticlePair |
  FirstItemExpression | A FirstItemExpression returns the first item in the sequence returned by a given base expression
  FirstItemExpressionAdjunct | Generate streaming code for a first item expression (when not part of a Watch).
  FirstItemExpressionCompiler | Generate code for the FirstItemExpression
  FixedAttribute | An instruction derived from an xsl:attribute element in stylesheet, or from an attribute constructor in XQuery.
  FixedAttributeCompiler | Generate bytecode for a fixed attribute constructor
  FixedElement | An instruction that creates an element node whose name is known statically.
  FixedElementCompiler | Generate bytecode for a fixed element constructor (or XSLT literal result element)
  FleetingDocumentNode | A Fleeting node (that is a transient node in a streamed document) that represents a document node
  FleetingElementNode | Represents an element node available transiently within a streamed document
  FleetingNode | A FleetingNode is a node that exists transiently in the course of streaming processing.
  FleetingParentNode | A streamed document or element node.
  FloatingPointConverter | This is a utility class that handles formatting of numbers as strings.
  FloatToBooleanCompiler | Generate code for a Float to Boolean CastExpression
  FloatToDoubleCompiler | Generate code for a Float to Double CastExpression
  FloatToIntegerCompiler | Generate code for a Float to Integer CastExpression
  FloatToStringCompiler | Generate code for a Float to String CastExpression
  FloatToUntypedAtomicCompiler | Generate code for a Float to Untyped Atomic CastExpression
  FloatValue | A numeric (single precision floating point) value
  Floor | This class implements the fn:floor() function
  FLWORExpression | This class represents a FLWOR expression, evaluated using tuple streams
  FLWORExpressionCompiler | Generate bytecode for a call to the FLWORExpression
  FocusIterator | An iterator that maintains the values of position() and current(), typically implemented as a wrapper over an iterator which does not maintain these values itself.
  FocusTrackingIterator | An iterator that maintains the values of position() and current(), as a wrapper over an iterator which does not maintain these values itself.
  Fold |
  FoldingFunction | Implementation of aggregate functions such as sum() and avg() that supply a fold() function.
  FoldLeftFn | This class implements the function fn:fold-left(), which is a standard function in XPath 3.0
  FoldRightFn | This class implements the function fn:fold-right(), which is a standard function in XQuery 1.1
  FoldStreamer | Streaming code for functions implemented as fold operations.
  ForceCaseCompiler | Generate bytecode for evaluation of a call to the upper-case() and lower-case functions
  ForClause | A "for" clause in a FLWOR expression
  ForClauseOuterPull | This class represents the tuple stream returned by a "for" clause in a FLWOR expression
  ForClauseOuterPush | This class implements the changes to the tuple stream effected by a "for" clause in a FLWOR expression where "allowing empty" is specified
  ForClausePull | This class implements the changes to the tuple stream effected by a "for" clause in a FLWOR expression
  ForClausePush | This class implements the changes to the tuple stream effected by a "for" clause in a FLWOR expression
  ForEach | Handler for xsl:for-each elements in a stylesheet.
  ForEachAction | This watch implements xsl:for-each in streaming mode.
  ForEachAdjunct | Compile an xsl:for-each instruction to streaming code.
  ForEachFn | This class implements the function fn:for-each() (formerly fn:map), which is a standard function in XQuery 3.0
  ForEachGroup | Handler for xsl:for-each-group elements in stylesheet.
  ForEachGroupAdjunct | Compile an xsl:for-each-group instruction to streaming code.
  ForEachGroupCompiler | Bytecode generator for the xsl:for-each-group class
  ForEachGroupParallelAction | This watch implements xsl:for-each-group in streaming mode, in cases where the population is being forked (using group-by), and where the population is not grounded.
  ForEachGroupPartitionAction | This watch implements xsl:for-each-group in streaming mode, in cases where the population is being partitioned (that is, group-adjacent, group-starting-with, and group-ending-with), and where the population is not grounded.
  ForEachPairFn | This class implements the function fn:for-each-pair() (formerly fn:map-pairs()), which is a standard function in XQuery 3.0
  ForExpression | A ForExpression maps an expression over a sequence.
  ForExpression.MappingAction | The MappingAction represents the action to be taken for each item in the source sequence.
  ForExpressionAdjunct | Streaming code to implement a "for" expression
  ForExpressionAdjunct.ForExpressionFeed |
  ForExpressionCompiler | Generate bytecode for a call to the ForExpression()
  ForItemMappingAction | The ForItemMappingAction supports compilation of a ForExpression.
  Fork | This class implements an xsl:fork expression.
  ForkAdjunct | Streaming code to implement an xsl:fork expression
  FormatDate | Implement the format-date(), format-time(), and format-dateTime() functions in XSLT 2.0 and XQuery 1.1.
  FormatInteger |
  FormatNumber | Implementation of format-number() function.
  ForMemberExpression | A ForMemberExpression maps an expression over the members of an array.
  ForSequenceMappingAction | The ForSequenceMappingAction supports compilation of a ForExpression.
  FractionDigitsFacet | Represents the fraction-digits facet in a simple type restriction
  Function | XDM 3.0 introduces a third kind of item, beyond nodes and atomic values: the function.
  FunctionAnnotationHandler | Interface to a user-supplied class that handles XQuery annotation assertions in a particular namespace.
  FunctionAnnotations | Implementation of the saxon:function-annotations() extension function.
  FunctionArity | This class implements the function function-arity(), which is a standard function in XPath 3.0
  FunctionAvailable | This class implements the XSLT function-available functions.
  FunctionCall | Abstract superclass for calls to system-defined and user-defined functions
  FunctionItemType | Higher-order functions in XPath 3.0 introduce a third kind of Item, namely a Function Item.
  FunctionLibrary | A FunctionLibrary handles the binding of function calls in XPath (or XQuery) expressions.
  FunctionLibraryList | A FunctionLibraryList is a list of FunctionLibraries.
  FunctionLiteral | A FunctionLiteral is a wrapper around a FunctionItem; it is an expression, whose value is the function that it wraps.
  FunctionLiteralCompiler | Generate bytecode for a call to a FunctionLiteral
  FunctionLookup | This class supports the function-lookup() function in XPath 3.0.
  FunctionName | This class implements the function function-name(), which is a standard function in XPath 3.0
  FunctionSequenceCoercer | An FunctionSequenceCoercer is an expression that performs function coercion on a sequence of function items: it takes a sequence of supplied items as input, and wraps each one in a CoercedFunction value, which dynamically converts the supplied arguments to the required type, and converts the result in the opposite direction, or throws a type error if conversion is not possible.
  FunctionSequenceCoercer.Coercer |
  FunctionSequenceCoercerCompiler | Generate bytecode to evaluate a FunctionSequenceCoercer function
  FunctionStreamability | Enumeration class giving the different streamability categories defined for stylesheet functions in XSLT 3.0
  GDateValue | Abstract superclass for the primitive types containing date components: xs:date, xs:gYear, xs:gYearMonth, xs:gMonth, xs:gMonthDay, xs:gDay
  GDayValue | Implementation of the xs:gDay data type
  GeneralComparison | GeneralComparison: a boolean expression that compares two expressions for equals, not-equals, greater-than or less-than.
  GeneralComparison.ComparisonCardinality |
  GeneralComparison10 | GeneralComparison10: a boolean expression that compares two expressions for equals, not-equals, greater-than or less-than.
  GeneralComparison20 | The class GeneralComparison20 specializes GeneralComparison for the case where the comparison is done with 2.0 semantics (i.e.
  GeneralComparisonAdjunct | Watch factory class for a general comparison
  GeneralComparisonCompiler | Generate code for a GeneralComparison
  GeneralComparisonEE | This class provides an implementation of the GeneralComparison "=" operator, which deals efficiently with comparing two sequences.
  GeneralComparisonFeed | This class is used when a streaming template requests a general comparison with one operand being pushed from the streamed input document, and the other being evaluated in pull mode.
  GeneralComparisonOperand | Given an expression, this characteristic evaluates the set of hash keys corresponding to the string values of the items selected by that expression
  GeneralNodePattern | A GeneralNodePattern represents a pattern which, because of the presence of positional predicates or otherwise, can only be evaluated "the hard way", by evaluating the equivalent expression with successive ancestors of the tested node as context item.
  GeneralPatternOptimizer | A PatternOptimizer is an agent responsible for optimizing a particular class of patterns.
  GeneralPositionalPattern | A GeneralPositionalPattern is a pattern of the form A[P] where A is an axis expression using the child axis and P is an expression that depends on the position.
  GeneralUnicodeString | A Unicode string which, in general, may contain non-BMP characters (that is, codepoints outside the range 0-65535)
  GeneratedClassLoader | GeneratedClassLoader interface.
  GeneratedCode | This abstract class is extended by the compiled code representing an Expression.
  GeneratedMethodInfo | Information about the current method whose bytecode is being generated
  GeneratedMethodInfo.LocalSlotInfo |
  GenerateId_1 | This class supports the generate-id() function with one argument
  GenerateIdCompiler | Generate bytecode for evaluation of a generate-id() function
  Generator | This class is an extension of the ASM-supplied GeneratorAdapter library, containing additional utility and shortcut methods for bytecode generation
  GenericAtomicComparer | An AtomicComparer used for comparing atomic values of arbitrary item types.
  GenericTreeInfo | A generic (model-independent) implementation of the TreeInfo interface, suitable for use with all tree models where the object representing the document node does not itself act as the TreeInfo implementation
  Genre | The Genre of an item is the top-level classification of its item type: one of Atomic, Node, Function, Map, Array, or External
  Gizmo | A Gizmo is a simple tool for performing a particular easily specified transformation on an XML document, for example deleting or renaming all the elements with a particular name.
  GlobalContextRequirement | Information about the requirements placed by a query or stylesheet on the global context item: whether it is mandatory or optional, what its type must be, and whether it has a default value.
  GlobalExtractor | This class is responsible for extracting global variables from subexpressions within a function or template
  GlobalOrderComparer | A Comparer used for comparing nodes in document order.
  GlobalParam | The compiled form of a global xsl:param element in an XSLT stylesheet or an external variable declared in the prolog of a Query.
  GlobalParameterSet | A GlobalParameterSet is a set of parameters supplied when invoking a stylesheet or query.
  GlobalVariable | A compiled global variable in a stylesheet or query.
  GlobalVariableManager | This interface provides access to a collection of global variables.
  GlobalVariableReference | A reference to a global variable
  GMonthDayValue | Implementation of the xs:gYear data type
  GMonthValue | Implementation of the xs:gMonth data type
  GroundedItemFeed | An GroundedItemFeed is an ItemFeed in which decomposed document and element nodes (that is, start|end Document|Element events) are not accepted, and parentless leaf nodes supplied using methods such as `GroundedItemFeed.characters(java.lang.CharSequence, net.sf.saxon.s9api.Location, int)` or `GroundedItemFeed.attribute(NodeName, SimpleType, CharSequence, Location, int)` are converted into calls on `ItemFeed.append(Item)` supplying an `Orphan` item.
  GroundedIterator | This interface is an extension to the SequenceIterator interface; it represents a SequenceIterator that is based on an in-memory representation of a sequence, and that is therefore capable of returning a Sequence containing all the items in the sequence.
  GroundedValue | A value that exists in memory and that can be directly addressed
  GroupAdjacentIterator | A GroupAdjacentIterator iterates over a sequence of groups defined by xsl:for-each-group group-adjacent="x".
  GroupAdjacentTester | This class implements GroupingFeed when the group-adjacent option is used.
  GroupBoundaryTester | This feed supports xsl:for-each-group in streaming mode.
  GroupByClause | This class represents an "group by" clause in a FLWOR expression
  GroupByClause.ObjectToBeGrouped | Inner class representing the contents of a tuple from the pre-grouping tuple stream; a set of such objects consitutes a group.
  GroupByClausePull | Represents the tuple stream delivered by an "group by" clause.
  GroupByClausePush | Represents the tuple stream delivered by an "group by" clause.
  GroupByIterator | A GroupByIterator iterates over a sequence of groups defined by xsl:for-each-group group-by="x".
  GroupEndingIterator | A GroupEndingIterator iterates over a sequence of groups defined by xsl:for-each-group group-ending-with="x".
  GroupEndingTester | This class implements GroupingFeed when the group-ending-with option is used.
  GroupIterator | A GroupIterator is an iterator that iterates over a sequence of groups.
  GroupMatchingIterator | A GroupMatchingIterator contains code shared between GroupStartingIterator and GroupEndingIterator
  GroupStarting | This class supports the extension function saxon:group-starting.
  GroupStartingIterator | A GroupStartingIterator iterates over a sequence of groups defined by xsl:for-each-group group-starting-with="x".
  GroupStartingTester | This class implements GroupingFeed when the group-starting-with option is used.
  GroupToBeSorted | This class is a specialization of ObjectToBeSorted for use when the sequence being sorted is a sequence of groups.
  GYearMonthValue | Implementation of the xs:gYearMonth data type
  GYearValue | Implementation of the xs:gYear data type
  HasChildren_1 | This class implements the function fn:has-children($node), which is a standard function in XPath 3.0
  HashTrieMap | An immutable map.
  HeadFn | This class implements the function fn:head(), which is a standard function in XPath 3.0
  HexBinaryEmitter | This emitter implements output method saxon:hexBinary.
  HexBinaryValue | A value of type xs:hexBinary
  HexCharacterReferenceGenerator | A class that represents a character as a hexadecimal character reference and writes the result to a supplied Writer
  HighestOrLowest | This class implements the saxon:highest() and saxon:lowest() extension functions.
  History | The History object is used to avoid backtracking too far.
  HomogeneityChecker | This class is an expression that does a run-time check of the result of a "/" expression to ensure that (a) the results consists entirely of atomic values and function items, or entirely of nodes, and (b) if the results are nodes, then they are deduplicated and sorted into document order.
  HomogeneityCheckerCompiler |
  HomogeneityCheckerIterator | An iterator that returns the same items as its base iterator, checking to see that they are either all nodes, or all non-nodes; if they are all nodes, it delivers them in document order.
  HostLanguage | Identifies a host language in which XPath expressions appear.
  HTML40Emitter | This class generates HTML 4.0 output
  HTML50Emitter | This class generates HTML 5.0 output
  HTML5CaseBlindCollator | A collating sequence that compares strings according to the HTML5 rules for case-blind matching.
  HTMLEmitter | This class generates HTML output
  HTMLEntityReferenceGenerator | A class that represents a character as a decimal character reference and writes the result to a supplied Writer.
  HTMLIndenter | HTMLIndenter: This ProxyReceiver indents HTML elements, by adding whitespace character data where appropriate.
  HTMLIndenterPE | HTMLIndenter with extra functionality used by Saxon-PE and Saxon-EE
  HTMLTagHashSet | A simple class for testing membership of a fixed set of case-insensitive ASCII strings.
  HTMLURIEscaper | This class is used as a filter on the serialization pipeline; it performs the function of escaping URI-valued attributes in HTML
  IAccumulatorData | Holds the values of an accumulator function for one non-streamed document
  ICompilerService | Marker interface representing a bytecode generation service
  ICULibrary | Class to report whether ICU features are loaded.
  ICUNumberer_de | A numberer for German using the ICU features, which supports variable ordinal suffixing, for example '-en', '-es'
  ICUNumbererEnUnhyphenated | A numberer for English, using the ICU features, which produces space-separated word numbers, for example "Twenty Two" rather than the ICU default, which is hyphen-separated: "Twenty-Two".
  ICUNumbererPE | A numberer using the ICU features, used principally for formatting numbers as words and day/month names
  Idempotency |
  IdentityComparable | The IdentityComparable class provides a way to compare objects for strong equality.
  IdentityComparison | IdentityComparison: a boolean expression that compares two nodes for equals, not-equals, greater-than or less-than based on identity and document ordering
  IdentityComparisonCompiler | Generate bytecode for IdentityComparison expression
  IdentityConstraint | The base class for the XML Schema Identity Constraints (key, keyref, unique).
  IdentityConstraintReference | A reference to an identity constraint
  IdentityField | The field selector for an IdentityConstraint
  IdentitySelector | The selector of an IdentityConstraint
  IdentityTransformer | Saxon implementation of the JAXP IdentityTransformer.
  IdentityTransformerHandler | IdentityTransformerHandler implements the javax.xml.transform.sax.TransformerHandler interface.
  IDFilter | IDFilter is a ProxyReceiver that extracts the subtree of a document rooted at the element with a given ID value.
  Idref |
  IdValidator | This class validates that ID elements and attributes have unique values and that IDREF and IDREFS elements and attributes refer to an ID in the same document.
  IgnorableSpaceStrippingRule | A whitespace stripping rule that strips whitespace text node children from all elements having an element-only content model, regardless of the value of the xml:space attribute
  IgnorableWhitespaceStripper | The IgnorableWhitespaceStripper removes whitespace text nodes belonging to elements whose schema-defined type defines element-only content
  ImmList<E> | An immutable list of elements
  ImmList0<E> | Implementation of an immutable empty list
  ImmList1<E> | Implementation of an immutable list of length 1 (one)
  ImmList2<E> | Implementation of an immutable list of arbitrary length, implemented as a binary tree
  ImmutableArrayItem | Implementation of ArrayItem backed by a persistent immutable array, so that operations that "update" the array do not have to copy the whole array
  ImmutableHashTrieMap<K,​V> |
  ImmutableList<T> | An immutable list implementation that only supports sequential traversal using an iterator, prepending an item to the start, and extraction of the head()/tail() of the list.
  ImmutableMap<K,​V> |
  ImportedFunctionLibrary | This implementation of FunctionLibrary contains all the functions imported into a Query Module.
  IndependentContext | An IndependentContext provides a context for parsing an XPath expression appearing in a context other than a stylesheet.
  Index | This class supports the extension function saxon:index, which returns an indexed sequence
  IndexedFilterExpression | An IndexedFilterExpression contains a base expression and a filter predicate.
  IndexedFilterExpressionCompiler |
  IndexedValue | A representation of a (sequence) value that allows the construction of one or more indexes to provide rapid access to the items in the sequence.
  IndexOf | The XPath 2.0 index-of() function, with the collation already known
  IndexOfStreamer | Generate streaming code for the index-of() function.
  IndexWhere | The saxon:index-where() extension function
  Initializer | This interface can be implemented by users (there are no implementations in Saxon itself).
  Innermost | This class implements the function fn:has-children(), which is a standard function in XPath 3.0
  InScopeNamespacesFn | Implementation of the saxon:in-scope-namespaces extension function.
  InScopePrefixes | This class implements the XPath 2.0 function fn:in-scope-prefixes()
  InsertAction | A pending update action representing the effect of an insert expression
  InsertAttributeAction | A pending update action representing the insert attribute action.
  InsertBefore | The XPath 2.0 insert-before() function
  InsertBefore.InsertIterator | Insertion iterator.
  InsertBeforeStreamer | Implement streaming of insert-before instruction.
  InsertExpression | An insert expression in XQuery Update
  InSituValidator | This class performs in-situ validation of a tree represented in memory as a NodeInfo object.
  InspectionAdjunct | Abstract superclass for constructs that have operand usage "inspection" on their primary (sequence-valued) operand
  InstanceOfAdjunct | Generate streaming code for an "instance of" expression
  InstanceOfCompiler | Generate bytecode for a call to the "instance of" expression
  InstanceOfExpression | InstanceOf Expression: implements "Expr instance of data-type"
  Instantiator<T> | Interface representing a factory class for instantiating instances of a specific class
  Instruction | Abstract superclass for all instructions in the compiled stylesheet.
  InstructionInfo | Information about an instruction in the stylesheet or a construct in a Query, made available at run-time to a TraceListener.
  InstructionWithComplexContent | Interface implemented by instructions that contain a sequence constructor evaluated using the rules for "constructing complex content": for example, xsl:element, xsl:copy, xsl:document, xsl:result-document
  Instrumentation | Internal class used for instrumentation purposes.
  Int64Value | An integer value: note this is a subtype of decimal in XML Schema, not a primitive type.
  Int64Value.Int64Comparable | A Comparable that performs comparison of an Int64Value either with another Int64Value or with some other representation of an XPath numeric value
  IntArraySet | Set of int values.
  IntArraySet.IntArrayIterator | Iterator class: iterate over an array of integers
  IntBlockSet | Set of int values.
  IntComplementSet | An immutable integer set containing all int values except those in an excluded set
  IntegerRange | This class represents a sequence of consecutive ascending integers, for example 1 to 50.
  IntegerRangeTest | An IntegerRangeTest is an expression of the form E = N to M where N and M are both expressions of type integer.
  IntegerRangeTestCompiler | Generate bytecode for an expression of the form ($I = $J to $K)
  IntegerToBooleanCompiler | Generate code for a Integer to Boolean CastExpression
  IntegerToDoubleCompiler | Generate code for a Integer to Double CastExpression
  IntegerToFloatCompiler | Generate code for a Integer to Float CastExpression
  IntegerToStringCompiler | Generate code for a Integer to String CastExpression
  IntegerToUntypedAtomicCompiler | Generate code for a Integer to Untyped Atomic CastExpression
  IntegerValue | This class represents the XPath built-in type xs:integer.
  IntegratedFunctionCall | Expression representing a call to a user-written extension function implemented as a subtype of `ExtensionFunctionCall`
  IntegratedFunctionCall.ConfigurationCheckingFunction | This class checks that NodeInfo objects returned by an extension function were created under the right Configuration
  IntegratedFunctionLibrary | A library of integrated function calls, that is, user-written extension functions implemented as instances of the class IntegratedFunction.
  IntEmptySet | An immutable integer set containing no integers
  IntEqualityPatternOptimizer | A PatternOptimizer is an agent responsible for optimizing a particular class of patterns.
  InterpretedExpressionCompiler | Bytecode generator for instructions that calls back to the interpreter.
  IntersectionEnumeration | An enumeration representing a nodeset that is an intersection of two other NodeSets.
  IntersectPattern | A pattern formed as the difference of two other patterns
  IntExceptPredicate | An IntPredicate formed as the difference of two other predicates: it matches an integer if the first operand matches the integer and the second does not
  IntHashMap<T> | A hash table that maps int keys to Object values.
  IntHashSet | Set of int values.
  IntIterator | An iterator over a sequence of unboxed int values
  IntRangeSet | Set of int values.
  IntSet | A set of integers represented as int values
  IntSetCharacterClass | A character class represents a set of characters for regex matching purposes.
  IntSetPredicate | An implementation of IntPredicate that tests whether a given integer is a member of some IntSet
  IntSingletonIterator | An iterator over a single integer
  IntSingletonSet | An immutable integer set containing a single integer
  IntStepIterator | An iterator over a sequence of integers with regular steps, e.g.
  IntToIntArrayMap | An implementation of `IntToIntMap` that relies on serial searching, and is therefore optimized for very small map sizes
  IntToIntHashMap | A hash table that maps int keys to int values.
  IntToIntMap | Interface defining a map from integers to integers
  IntUnionPredicate | An IntPredicate formed as the union of two other predicates: it matches an integer if either of the operands matches the integer
  IntUniversalSet | An immutable integer set containing every integer
  IntValuePredicate | An IntPredicate that matches a single specific integer
  Invalidity | An `Invalidity` is a validation error, that is, a failure of the instance document to conform to the schema being used for validation.
  InvalidityHandler | Interface for reporting validation errors found during validation of an instance document against a schema.
  InvalidityHandlerWrappingErrorListener | Interface for reporting validation errors found during validation of an instance document against a schema.
  InvalidityHandlerWrappingErrorReporter | Interface for reporting validation errors found during validation of an instance document against a schema.
  InvalidityReportGenerator | This class `InvalidityReportGenerator` extends the standard error handler for errors found during validation of an instance document against a schema, used if user specifies -report option on validate.
  InvalidityReportGeneratorEE | This class `InvalidityReportGenerator` extends the standard error handler for errors found during validation of an instance document against a schema, used if user specifies -report option on validate.
  InverseCharacterClass | A character class represents a set of characters for regex matching purposes.
  Inversion | This class represents an expression that has been "inverted" (in the Jackson sense) so that its execution is push-driven, that is, driven by events from the streamed document.
  Inversion.PushAction | A PushAction is a collection of data that together represents the strategy for how an expression should be evaluated in push mode.
  IPackageLoader |
  IriToUri | This class supports the functions encode-for-uri() and iri-to-uri()
  IrregularGroupFormatter | Handles grouping separators when formatting a number in cases where the grouping separators are not at regular intervals
  IsIdRef | This class implements the saxon:is-idref() extension function, which is specially-recognized by the system because calls are generated by the optimizer.
  IsLastExprAdjunct |
  IsLastExpression | A position() eq last() expression, generated by the optimizer.
  IsLastExpressionCompiler | Generate bytecode for the IsLastExpression, which tests whether position() is equal to last()
  IsNaN | Implements the saxon:is-NaN() function.
  ISO88591CharacterSet | This class defines properties of the ISO-8859-1 character set
  Item | An Item is an object that can occur as a member of a sequence.
  ItemChecker | A ItemChecker implements the item type checking of "treat as": that is, it returns the supplied sequence, checking that all its items are of the correct type
  ItemCheckerAdjunct | Streaming code for an item checker
  ItemCheckerCompiler | Generate bytecode for an ItemChecker expression, performing run-time type checking
  ItemCheckingFeed | A Feed to go on the streaming pipeline that checks the item type of the items in the sequence represented by the events passing down the pipeline.
  ItemConsumer<T extends Item> | A FunctionalInterface for any method that processes individual items, and which may generate exceptions.
  ItemFeed | An ItemFeed evaluates an expression in "composed push" mode.
  ItemMappingFeed | A Feed which applies an ItemMappingFunction to each supplied item.
  ItemMappingFunction | ItemMappingFunction is an interface that must be satisfied by an object passed to a ItemMappingIterator.
  ItemMappingIterator | ItemMappingIterator applies a mapping function to each item in a sequence.
  ItemOrderComparer | A Comparer used for comparing nodes in document order, or items in merge order
  ITemplateCall | An interface satisfied by all instructions that invoke templates: apply-templates, call-template.
  ItemsAfterStreamer | Generate streaming code for the saxon:items-after function.
  ItemsBeforeStreamer | Generate streaming code for the saxon:items-before function.
  ItemsFromStreamer | Generate streaming code for the saxon:items-from function.
  ItemsUntilStreamer | Generate streaming code for the saxon:items-after function.
  ItemToBeSorted | This class is a specialization of class ObjectToBeSorted for use when the sequence being sorted is a sequence of items (including tuples, which are represented as items).
  ItemType | An item type, as defined in the XPath/XQuery specifications.
  ItemType | ItemType is an interface that allows testing of whether an Item conforms to an expected type.
  ItemType.WithSequenceTypeCache | Extension of the ItemType interface implemented by some item types, to provide a cache of SequenceType objects based on this item type, with different occurrence indicators.
  ItemTypeCheckingFunction | A mapping function for use in conjunction with an `ItemMappingIterator` that checks that all the items in a sequence are instances of a given item type
  ItemTypeFactory | This class is used for creating ItemType objects.
  ItemTypePattern | An ItemTypePattern is a pattern that consists simply of an ItemType; although a node test is an item type, this class is used only for non-node item types, such as atomic types, map types, array types etc.
  ItemWithMergeKeys | A class representing an item together with its merge keys and the name of the merge source object from which it derived, suitable for encapsulation as an ObjectValue.
  IterateAction | This watch implements xsl:iterate in streaming mode.
  IterateAdjunct | Implement streaming code for xsl:iterate
  IterateInstr | An IterateInstr is the compiled form of an xsl:iterate instruction
  IterateInstrCompiler | Bytecode generator for the xsl:iterate instruction
  IteratorWrapper | Class IteratorWrapper - provides an an SequenceIterator over a Java Iterator.
  IXSLElementFactory | Class IXSLElementFactory.
  IXSLFunctionSet | The IXSLFunctionSet represents additions to the set of Saxon vendor-supplied extension functions that are available on Saxon-JS.
  IXSLFunctionSet.Call |
  IXSLFunctionSet.Eval |
  IXSLFunctionSet.ScheduleActionFn |
  IXSLFunctionSet.Source |
  IXSLFunctionSet.Stub | Most of the functions in this library will only run in Saxon-JS, some of them only in the browser
  IXSLRemoveAttribute | Handler for ixsl:remove-attribute elements in stylesheet.
  IXSLRemoveProperty | Handler for ixsl:remove-property elements in stylesheet.
  IXSLScheduleAction | Handler for ixsl:schedule-action elements in stylesheet.
  IXSLSetAttribute | Handler for ixsl:set-attribute elements in stylesheet.
  IXSLSetProperty | Handler for ixsl:set-property elements in stylesheet.
  IXSLSetStyle | Handler for ixsl:set-style elements in stylesheet.
  JarCollection | A JarCollection represents a collection of resources held in a JAR or ZIP archive, accessed typically using a URI using the (Java-defined) "jar" URI scheme, or simply a "file" URI where the target file is a JAR or ZIP file.
  JavaCharacterSet | This class establishes properties of a character set that is known to the Java VM but not specifically known to Saxon.
  JavaCollationFactory | A JavaCollationFactory allows a Collation to be created given a set of properties that the collation should have.
  JavaExtensionFunctionCall | This class acts as a container for an extension function defined to call a method in a user-defined class.
  JavaExtensionFunctionCallCompiler | Compiles a call to an old-style "reflexive" Java extension function.
  JavaExtensionFunctionFactory | This class acts as a factory for creating expressions that call Java extension functions.
  JavaExtensionLibrary | The JavaExtensionLibrary is a FunctionLibrary that binds XPath function calls to calls on Java methods (or constructors, or fields).
  JavaExternalObjectType | This class represents the type of an external Java object returned by an extension function, or supplied as an external variable/parameter.
  JavaLocalizerFactory | Default factory for number/date localizers for the Java platform
  JavaPlatform | Implementation of the Platform class containing methods specific to the Java platform (as distinct from .NET).
  JavaPlatformEE | Implementation of the Platform class containing methods specific to the Java platform (as distinct from .NET) for Saxon-EE.
  JavaPlatformPE | Implementation of the Platform class containing methods specific to the Java platform (as distinct from .NET) for Saxon-PE and Saxon-EE.
  JavaRegularExpression | An implementation of RegularExpression that calls the JDK regular expression library directly.
  JAXPVariableReference | This class represents a variable in an XPath expression compiled using the JAXP XPath API.
  JAXPXPathStaticContext | A JAXPXPathStaticContext provides a context for parsing an XPath expression in a context other than a stylesheet.
  JDOM2DocumentWrapper | The tree information for a tree acting as a wrapper for a JDOM2 Document.
  JDOM2NodeWrapper | A node in the XML parse tree representing an XML element, character content, or attribute.
  JDOM2ObjectModel | This interface must be implemented by any third-party object model that can be wrapped with a wrapper that implements the Saxon Object Model (the NodeInfo interface).
  JDOM2Query | Variant of command line net.sf.saxon.Transform do build the source document in JDOM2 and then proceed with the transformation.
  JDOM2Transform | Variant of command line net.sf.saxon.Transform do build the source document in JDOM2 and then proceed with the transformation.
  JDOM2Writer | JDOMWriter is a Receiver that constructs a JDOM2 document from the stream of events
  JLine2Talker | Handles terminal interaction for Gizmo using the JLine2 library: https://github.com/jline/jline2
  JLine2Talker.XPathCompleter |
  JPConverter | This class together with its embedded subclasses handles conversion from Java values to XPath values.
  JPConverter.ExternalObjectWrapper |
  JPConverter.FromBigDecimal |
  JPConverter.FromBigInteger |
  JPConverter.FromBoolean |
  JPConverter.FromBooleanArray |
  JPConverter.FromByte |
  JPConverter.FromByteArray |
  JPConverter.FromCharacter |
  JPConverter.FromCharArray |
  JPConverter.FromCollection |
  JPConverter.FromDate |
  JPConverter.FromDouble |
  JPConverter.FromDoubleArray |
  JPConverter.FromFloat |
  JPConverter.FromFloatArray |
  JPConverter.FromInstant |
  JPConverter.FromInt |
  JPConverter.FromIntArray |
  JPConverter.FromLocalDate |
  JPConverter.FromLocalDateTime |
  JPConverter.FromLong |
  JPConverter.FromLongArray |
  JPConverter.FromObject |
  JPConverter.FromObjectArray |
  JPConverter.FromOffsetDateTime |
  JPConverter.FromQName |
  JPConverter.FromSequence |
  JPConverter.FromSequenceIterator |
  JPConverter.FromShort |
  JPConverter.FromShortArray |
  JPConverter.FromSource |
  JPConverter.FromString |
  JPConverter.FromURI |
  JPConverter.FromXdmValue |
  JPConverter.FromZonedDateTime |
  JPConverter.VoidConverter |
  JRegexIterator | Class JRegexIterator - provides an iterator over matched and unmatched substrings.
  JSFunctionLibrary | The JSFunctionLibrary is a FunctionLibrary that binds XPath function calls to calls on JavaScript methods.
  JsonDoc | Implements the json-to-xml function defined in XSLT 3.0.
  JSONEmitter | This class implements the back-end text generation of the JSON serialization method.
  JsonHandler | Default handler class for accepting the result from parsing JSON strings
  JsonHandlerMap | Event handler for the JSON parser which constructs a structure of maps and arrays representing the content of the JSON text.
  JsonHandlerXML | Handler to generate an XML representation of JSON from a series of events
  JsonParser | Parser for JSON, which notifies parsing events to a JsonHandler
  JsonReceiver | A Receiver which receives a stream of XML events using the vocabulary defined for the XML representation of JSON in XSLT 3.0, and which generates the corresponding JSON text as a string
  JSONResource | A Resource (that is, an item in a collection) holding JSON content
  JSONSerializer | This class implements the JSON serialization method defined in XSLT+XQuery Serialization 3.1.
  JsonToXMLFn | Implements the json-to-xml function defined in XSLT 3.0.
  JTokenIterator | A JTokenIterator is an iterator over the strings that result from tokenizing a string using a regular expression, in this case a regular expression evaluated using the JDK regex engine
  Key | A class that represents the XML Schema Identity Constraint: Key.
  KeyDefinition | Corresponds to a single xsl:key declaration.
  KeyDefinitionSet | A set of xsl:key definitions in a stylesheet that share the same name
  KeyFn |
  KeyFn.SubtreeFilter | Mapping class to filter nodes that have the origin node as an ancestor-or-self
  KeyIndex | A key index is an index maintained to support xsl:key key definitions, including both user-defined keys and keys added by the optimizer.
  KeyIndex.Status |
  KeyManager | KeyManager manages the set of key definitions in a stylesheet, and the indexes associated with these key definitions.
  KeyMap | Implementation of the saxon:key-map() extension function.
  KeyRef | This class represents an xs:keyRef identity constraint in a schema
  KeySelectorWatch | This class watches the selector for a key or unique constraint
  KeyValuePair | A key and a corresponding value to be held in a Map.
  LabelInfo | An ASM label object with some control information to enable better diagnostics
  Lang |
  LargeAttributeMap | An implementation of AttributeMap suitable for larger collections of attributes (say, more than five).
  LargeStringBuffer | This is an implementation of the CharSequence interface: it implements a CharSequence as a list of arrays of characters (the individual arrays are known as segments).
  LastCompiler | Generate code for a call to last()
  LastItemExpression | A LastItemExpression returns the last item in the sequence returned by a given base expression.
  LastItemExpressionCompiler | Generate bytecode for a call to the LastItemExpression()
  LastModified | Extension function to determined the last-modified date of a file
  LastPositionFinder | A LastPositionFinder is an interface implemented by any SequenceIterator that is able to return the position of the last item in the sequence.
  LastStreamer |
  LatinString | An implementation of UnicodeString optimized for strings that contain no characters outside the Latin-1 range (i.e.
  LaxValidator | This class performs lax validation on an element.
  LazySequence | A sequence that wraps an iterator, without being materialized.
  Leading | This class implements the saxon:leading() extension functions.
  LengthFacet | Represents the length facet
  LengthRangeFacet | Abstract class for the three facets length, minLength, and maxLength.
  LetClause | A "let" clause in a FLWOR expression
  LetClausePull | Implements the changes to a tuple stream effected by the Let clause in a FLWOR expression
  LetClausePush | Implements the changes to a tuple stream effected by the Let clause in a FLWOR expression
  LetExpression | A LetExpression represents the XQuery construct let $x := expr return expr.
  LetExpressionAdjunct | Compiles streaming code to implement a Let expression
  LetExpressionAdjunctB | Compiles streaming code to implement a Let expression for which the "action" part (the return clause) is consuming
  LetExpressionCompiler | Generate bytecode for evaluation of an LetExpression
  LicenseException | Exception thrown when there are problems with the license file
  LineNumberMap | Line numbers are not held in nodes in the tree, because they are not usually needed.
  LinkedBuilderMonitor | Monitor construction of a document tree.
  LinkedTreeBuilder | The LinkedTreeBuilder class is responsible for taking a stream of Receiver events and constructing a Document tree using the linked tree implementation.
  ListCastableFunction | A function item representing a castability test for a list type
  ListConstructorFunction | A function item representing a constructor function for a list type
  ListIterator<T extends Item> | Class ListIterator, iterates over a sequence of items held in a Java List
  ListIterator.Atomic |
  ListIterator.OfNodes |
  ListType | Interface representing a simple type of variety List
  Literal | A Literal is an expression whose value is constant: it is a class that implements the `Expression` interface as a wrapper around a `GroundedValue`.
  LiteralAdjunct | Streamed evaluation of a literal (not difficult!)
  LiteralCompiler | Generate byte code for a literal expression in the expression tree
  LiteralResultElement | This class represents a literal result element in the style sheet (typically an HTML element to be output).
  LoadXqueryModule | This class implements the function load-xquery-module(), which is a standard function in XPath 3.1.
  Loc | Class to hold details of the location of an expression, of an error in a source file, etc.
  LocalBinding | Binding for local variables and parameters: anything that is allocated a slot on the XPathContext stack frame.
  LocalizerFactory | Interface allowing localization modules for different languages to be dynamically loaded
  LocalName_1 | This class supports the local-name() function
  LocalNameCompiler | Generate bytecode for evaluation of functions such as name() and local-name() which return a string property of a node
  LocalNameTest | NodeTest is an interface that enables a test of whether a node has a particular name and type.
  LocalOrderComparer | A Comparer used for comparing nodes in document order.
  LocalParam | The compiled form of an xsl:param element within a template in an XSLT stylesheet.
  LocalParamBlock | Represents the set of xsl:param elements at the start of an xsl:iterate instruction
  LocalParamBlockCompiler | Compiler for LocalParam instructions in XSLT (representing an xsl:param in a template)
  LocalParamCompiler | Compiler for LocalParam instructions in XSLT (representing an xsl:param in a template)
  LocalUnionType | A class that represents a union type declared locally, for example using the (Saxon-extension) item-type syntax union(a,b,c), or internally in Java code.
  LocalVariableBinding | Represents the defining occurrence of a variable declared within a FLWOR expression, for example the $p in "for $x at $p in ...".
  LocalVariableReference | Variable reference: a reference to a local variable.
  LocalVariableReferenceCompiler | Generate code for a LocalVariableReference
  Locatable | Represents a construct that has a meaningful location for use in diagnostics
  Location | Saxon interface to represent a location, typically the location of an expression within a query or stylesheet.
  LocationCopier | A Receiver that can be inserted into an event pipeline to copy location information.
  Logger | Interface to diagnostic event logging mechanism.
  LookaheadIterator | A SequenceIterator is used to iterate over a sequence.
  LookaheadIteratorImpl | This class wraps any sequence iterator, turning it into a lookahead iterator, by looking ahead one item
  LookupAllExpression | A lookup expression is an expression of the form A?*, where A must be a map or an array
  LookupExpression | A lookup expression is an expression of the form A?B.
  LoopLifter | Class to handle loop-lifting optimization, that is, extraction of subexpressions appearing within a loop when there is no dependency on the controlling variable of the loop.
  LowerCase | This class implements the fn:lower-case() function
  LRUCache<K,​V> | An LRU cache, based on `LinkedHashMap`.
  LSSchemaResolver | This class is a SchemaURIResolver implemented as a wrapper around a JAXP LSResourceResolver
  Mailer2 | Helper class for saxon:send-mail() extension function
  Maker<T> | Interface representing a factory class for instances of a specific type
  ManualGroupIterator | The class ManualGroupIterator represents an iterator that is never repositioned, but can be used to represent the focus in the dynamic context.
  ManualIterator | ManualIterator: a pseudo-iterator used while streaming.
  ManualRegexIterator | The class ManualRegexIterator represents an iterator that is never repositioned, but can be used to represent the current regex groups in the dynamic context.
  MapCreate | This is a variant of the map:new() or map:merge() function which differs in that duplicate keys are considered an error.
  MapEntryStreamer | Streaming code to implement an xsl:map instruction or map constructor, where each map entry is allowed to be consuming.
  MapFunctionSet | Function signatures (and pointers to implementations) of the functions defined in XPath 2.0
  MapFunctionSet.MapContains | Implementation of the XPath 3.1 function map:contains(Map, key) => boolean
  MapFunctionSet.MapEntry | Implementation of the extension function map:entry(key, value) => Map
  MapFunctionSet.MapFind | Implementation of the XPath 3.1 function map:find(item()*, key) => array
  MapFunctionSet.MapForEach | Implementation of the extension function map:for-each(Map, Function) => item()*
  MapFunctionSet.MapGet | Implementation of the XPath 3.1 function map:get(Map, key) => value
  MapFunctionSet.MapKeys | Implementation of the extension function map:keys(Map) => atomicValue*
  MapFunctionSet.MapMerge | Implementation of the extension function map:merge() => Map From 9.8, map:merge is also used to implement map constructors in XPath and the xsl:map instruction in XSLT.
  MapFunctionSet.MapPut | Implementation of the extension function map:put() => Map
  MapFunctionSet.MapRemove | Implementation of the XPath 3.1 function map:remove(Map, key) => value
  MapFunctionSet.MapSize | Implementation of the extension function map:size(map) => integer
  MapItem | Interface supported by different implementations of an XDM map item
  MappingFunction | MappingFunction is an interface that must be satisfied by an object passed to a MappingIterator.
  MappingIterator | MappingIterator merges a sequence of sequences into a single flat sequence.
  MappingJavaIterator<S,​T> | A Java Iterator which applies a mapping function to each item in an input sequence
  MapSearch | The saxon:map-search function, new in Saxon 9.9
  MapType | An instance of this class represents a specific map item type, for example map(x:integer, element(employee))
  MapUntypedContains | Implementation of an internal function map:untyped-contains(Map, key) => boolean, which is like map:contains except that if the supplied key is untyped atomic, it is converted to all the possible types present in the map and returns true if the key after conversion is present.
  Matches | This class implements the 3-argument matches() function for regular expression matching
  MatchesCompiler | Generate code for the fn:matches function
  Math | This class implements extension functions in the http://exslt.org/math namespace.
  MathFunctionSet | Abstract class providing functionality common to functions math:sin(), math:cos(), math:sqrt() etc; contains the concrete implementations of these functions as inner subclasses
  MathFunctionSet.AcosFn | Implement math:acos
  MathFunctionSet.AsinFn | Implement math:asin
  MathFunctionSet.Atan2Fn | Implement math:atan2
  MathFunctionSet.AtanFn | Implement math:atan
  MathFunctionSet.CosFn | Implement math:cos
  MathFunctionSet.Exp10Fn | Implement math:exp10
  MathFunctionSet.ExpFn | Implement math:exp
  MathFunctionSet.Log10Fn | Implement math:log10
  MathFunctionSet.LogFn | Implement math:log
  MathFunctionSet.PiFn | Implement math:pi
  MathFunctionSet.PowFn | Implement math:pow
  MathFunctionSet.SinFn | Implement math:sin
  MathFunctionSet.SqrtFn | Implement math:sqrt
  MathFunctionSet.TanFn | Implement math:tan
  MaxExclusiveFacet | Implements the maxExclusive facet on a simple type
  MaxInclusiveFacet | Implements the maxInclusive facet on a simple type
  MaxLengthFacet | Represents the minLength facet
  MemoClosure | A MemoClosure represents a value that has not yet been evaluated: the value is represented by an expression, together with saved values of all the context variables that the expression depends on.
  MemoFunction | A user-defined function that is declared as a memo function, meaning that it remembers results of previous calls.
  MemoSequence | A Sequence implementation that represents a lazy evaluation of a supplied iterator.
  MergeGroupingIterator | An iterator that groups the result of merging several xsl:merge input streams, identifying groups of adjacent items having the same merge key value
  MergeInstr |
  MergeInstr.MergeKeyMappingFunction | Mapping function for items encountered during the merge; the mapping function wraps the merged item and its merge keys into a single composite object
  MergeInstr.MergeSource | Inner class representing one merge source
  MergeInstrAdjunct | Streaming adjunct for the xsl:merge instruction.
  MergeIterator | An iterator representing the sorted merge of two merge inputs, retaining all duplicates.
  Message | An xsl:message element in the stylesheet.
  MessageBuilder | Helper interface MeassageBuilder.
  MessageCount | This class implements the saxon:message-count() function which returns the value of message counters at the moment of execution
  MessageEmitter | MessageEmitter is the default Receiver for xsl:message output.
  MessageFromStack | Helper class to generate a run-time exception using a message that is present at the top of the bytecode stack
  MessageListener | A user-written implementation of the MessageListener interface may be registered with the XsltTransformer to receive notification of xsl:message output.
  MessageListener2 | A user-written implementation of the MessageListener interface may be registered with the XsltTransformer to receive notification of xsl:message output.
  MessageTemplate | Helper class to build messages in which the value of run-time bytecode variables can be inserted.
  MessageWarner | MessageWarner is a user-selectable receiver for XSLT xsl:message output.
  MetadataResource | Created by mike on 28/10/15.
  MetaTagAdjuster | The MetaTagAdjuster adds a meta element to the content of the head element, indicating the required content type and encoding; it also removes any existing meta element containing this information
  MinExclusiveFacet | Implements the minExclusive facet on a simple type
  Minimax | This class implements the min() and max() functions, with the collation argument already known.
  Minimax.Max | Concrete subclass to define the fn:max() function
  Minimax.Min | Concrete subclass to define the fn:min() function
  MinimaxStreamer | Generate streaming code for the min() and max() functions.
  MinInclusiveFacet | Implements the minInclusive facet on a simple type
  MinLengthFacet | Represents the minLength facet
  MissingComponentException | This exception occurs when an attempt is made to dereference a reference from one schema component to another, if the target of the reference cannot be found.
  MissingComponentExceptionImpl | This exception occurs when an attempt is made to dereference a reference from one schema component to another, if the target of the reference cannot be found.
  Mode | A Mode is a collection of rules; the selection of a rule to apply to a given element is determined by a Pattern.
  Mode.RuleAction | Interface for helper classes used to process all the rules in the Mode
  Mode.RuleFilter | Interface for helper classes used to filter a chain of rules
  ModeEE | A version of class Mode that optimizes various aspects of the template patterns, most notably supporting rule preconditions and indexation of unnamed elements.
  ModeEE.RuleChainOptimizationData |
  ModeEE.RuleTypeAction |
  ModelGroup | An XML Schema Model Group.
  ModelGroupDefinition | A Model Group Definition: a schema component corresponding to a top-level (named) xs:group element in a schema document.
  ModelGroupParticle | A reference within the content model of a complex type to a Model Group Definition.
  ModePE | The Mode class for use in Saxon-PE, which may contain additional XSLT3.0 features This is subclassed in Saxon-EE to add optimisation features
  ModeTraceListener | A trace listener for XSLT that only handles invocation of template rules; enabled using saxon:trace="yes" on the xsl:mode declaration
  ModuleURIResolver | A ModuleURIResolver is used when resolving references to query modules.
  MonoIterator<T> | An iterator over a single object (typically a sub-expression of an expression)
  MonotonicIntSet | Set of int values.
  MotionlessFeed | A feed for an expression that typically accesses the context item but does not consume the input stream.
  MultiAccumulatorWatch | This watch managers a set of accumulators in streaming mode.
  MultiIndex | A MultiIndex provides fast access to the items in a sequence.
  MultiIndex.SelectedItemsIterator | Iterator over a subset of the items in this IndexedValue, identified by an IntSet holding the positions of the items in the selected subset (zero-based)
  MultiIterator<T> | An iterator that combines the results of a sequence of iterators
  MultipleNodeKindTest | An MultipleNodeKindTest is a nodetest that matches nodes belonging to any subset of possible node kinds, for example element and document nodes, or attribute and namespace nodes
  MultithreadedContextMappingIterator | This class performs the same role as ContextMappingIterator, but using multiple threads.
  MultithreadedFocusTrackingIterator | This is a thread-safe version of the parent class `FocusTrackingIterator`.
  MultithreadedForEach | This instruction represents an xsl:for-each instruction using more than one thread
  MultithreadedItemMappingIterator | Parallel-processing version of the ItemMappingIterator class, which executes a mapping function for each item in a sequence.
  MultithreadingFactory | This class defines a number of methods that support the use of multi-threading in Saxon.
  MutableDocumentInfo | Interface representing the document node of a mutable document
  MutableNodeInfo | An extension of the NodeInfo interface defining a node that can be updated.
  Name_1 | This class supports the name() function with one argument
  NameChecker | The NameChecker performs validation and analysis of XML names.
  NameCompiler | Generate bytecode for evaluation of functions such as name() and local-name() which return a string property of a node
  NamedLabel | Subclass of the ASM Label class that adds a diagnostic name to the label; this enables more intelligible bytecode to be output for diagnostics
  NamedTemplate | The runtime object corresponding to a named xsl:template element in the stylesheet.
  NamedTemplate.LocalParamInfo |
  NamedTimeZone | This class attempts to identify a timezone name, given the date (including the time zone offset) and the country.
  NameOfNode | An implementation of NodeName that gets the name of an existing NodeInfo object.
  NamePool | A NamePool holds a collection of expanded names, each containing a namespace URI, and a local name.
  NamePool.NamePoolLimitException | Unchecked Exception raised when some limit in the design of the name pool is exceeded
  NamePoolConverter | This class is a filter that passes all Receiver events through unchanged, except that it changes namecodes to allow for the source and the destination using different NamePools.
  NamespaceBinding | Represents the binding of a prefix to a URI.
  NamespaceBindingSet | Represents a set of namespace bindings
  NamespaceConstant | This class is not instantiated, it exists to hold a set of constants representing known namespaces.
  NamespaceConstructor | A namespace constructor instruction.
  NamespaceConstructorCompiler | Generate bytecode for the xsl:namespace Instruction
  NamespaceContextImpl | This class bridges between the JAXP 1.3 NamespaceContext interface and Saxon's equivalent NamespaceResolver interface.
  NamespaceDeltaMap | Holds a set of namespace bindings as a simple immutable map from prefixes to URIs.
  NamespaceDifferencer | `NamespaceDifferencer` is a `ProxyReceiver` responsible for removing duplicate namespace declarations.
  NamespaceForPrefix | This class supports the function namespace-uri-for-prefix()
  NamespaceMap | Holds a set of namespace bindings as a simple immutable map from prefixes to URIs.
  NamespaceNode | This class represents a namespace node; it is used in several tree models.
  NamespaceReducer | `NamespaceReducer` is a `ProxyReceiver` responsible for removing duplicate namespace declarations.
  NamespaceResolver | Abstract class that supports lookup of a lexical QName to get the expanded QName.
  NamespaceResolverWithDefault | This class is a NamespaceResolver that modifies an underyling NamespaceResolver by changing the mapping of the null prefix to be a specified namespace, rather than the one used by the underlying namespace resolver.
  NamespaceTest | NodeTest is an interface that enables a test of whether a node has a particular name and type.
  NamespaceUri_1 | This class supports the namespace-uri() function
  NamespaceUriFnCompiler | Generate bytecode for evaluation of a namespace-uri() function
  NameTest | NodeTest is an interface that enables a test of whether a node has a particular name and type.
  Navigator | The Navigator class provides helper classes for navigating a tree, irrespective of its implementation
  Navigator.AncestorEnumeration | General-purpose implementation of the ancestor and ancestor-or-self axes
  Navigator.AxisFilter | AxisFilter is an iterator that applies a NodeTest filter to the nodes returned by an underlying AxisIterator.
  Navigator.DescendantEnumeration | General-purpose implementation of the descendant and descendant-or-self axes, in terms of the child axis.
  Navigator.EmptyTextFilter | EmptyTextFilter is an iterator that applies removes any zero-length text nodes returned by an underlying AxisIterator.
  Navigator.FollowingEnumeration | General purpose implementation of the following axis, in terms of the ancestor, child, and following-sibling axes
  Navigator.PrecedingEnumeration | Helper method to iterate over the preceding axis, or Saxon's internal preceding-or-ancestor axis, by making use of the ancestor, descendant, and preceding-sibling axes.
  Negatable | This interface is implemented by expressions that returns a boolean value, and returns an expression whose result is the negated boolean value
  NegateExpression | Negate Expression: implements the unary minus operator.
  NegateExpressionCompiler | Generate bytecode for evaluation of a call to the substring() function
  NestedIntegerValue | This class represents a dot-separated sequence of numbers such as 1.12.5, typically used as a software version number.
  NewAttribute | Implements the saxon:new-attribute() function.
  NewComment | Implements the saxon:new-comment() function.
  NewDocument | Implements the saxon:new-text() function.
  NewElement | Implements the saxon:new-text() function.
  NewMapStreamer | Streaming code to implement an xsl:map instruction or map constructor, where each map entry is allowed to be consuming.
  NewNamespace | Implements the saxon:new-namespace() function.
  NewProcessingInstruction | Implements the saxon:new-processing-instruction() function.
  NewText | Implements the saxon:new-text() function.
  NextIteration | Implements a xsl:next-iteration instruction within the body of xsl:iterate
  NextIterationAdjunct | Compile a xsl:next-intruction instruction to streaming code.
  NextIterationCompiler | Compiler for xsl:next-iteration within xsl:iterate (XSLT 3.0)
  NextIterationFeed | This class is used when one of the xsl:with-param elements within an xsl:next-iteration of an xsl:iterate consumes the streamed input
  NextMatch | An xsl:next-match element in the stylesheet
  NextMatchAction | Watch for an xsl:next-match instruction.
  NextMatchAdjunct | Compile an xsl:next-match expression/instruction to streaming code.
  NextMatchCompiler | Compiler for the XSLT next-match instruction
  Nilled_1 | This class supports the nilled() function
  NoCloseFeed | This feed suppresses the call on close().
  NodeFactory | Interface NodeFactory.
  NodeImpl | A node in the "linked" tree representing any kind of node except a namespace node.
  NodeInfo | The NodeInfo interface represents a node in Saxon's implementation of the XPath 2.0 data model.
  NodeKindTest | NodeTest is an interface that enables a test of whether a node has a particular name and kind.
  NodeName | This interface represents a node name.
  NodeName_1 | This class supports the node-name() function with a single argument
  NodeNameFnCompiler | Generate bytecode for evaluation of the node-name() function
  NodeOverNodeInfo | This class implements the DOM Node interface as a wrapper around a Saxon NodeInfo object.
  NodePropertyCompiler | Generate bytecode for evaluation of functions such as name() and local-name() which return a string property of a node
  NodeSetPattern | A NodeSetPattern is a pattern based on an expression that is evaluated to return a set of nodes; a node matches the pattern if it is a member of this node-set.
  NodeTest | A NodeTest is a simple kind of pattern that enables a context-free test of whether a node matches a given node kind and name.
  NodeTestPattern | A NodeTestPattern is a pattern that consists simply of a NodeTest
  NodeVectorTree | Interface defining methods common to the TinyTree and the Domino tree model.
  NodeWrappingAxisIterator<B> | An AxisIterator that wraps a Java Iterator.
  NodeWrappingFunction<B,​T extends NodeInfo> | Interface to a function that wraps nodes from an external object model in a Saxon NodeInfo representation
  NoDynamicContextException | This exception class is used when early (compile-time) evaluation of an expression is attempted, and the expression requires knowledge of the current dateTime or implicit timezone.
  NoElementsSpaceStrippingRule | A whitespace stripping rule that retains all whitespace text nodes
  NoNamespaceName | An implementation of NodeName for the common case of a name in no namespace
  NonDelegatingURIResolver | This is a marker interface: if a URIResolver implements this interface and returns null from its resolve() method, then the standard URI resolver will not be invoked.
  NonDeterminizedState | A state in the non-determinized finite state machine
  NoOpenFeed | This feed is used for the inner loop of a for-each, where the results of multiple iterations need to be concatenated into a single sequence.
  NoOpenOrCloseFeed | This feed is used for the inner loop of a for-each, where the results of multiple iterations need to be concatenated into a single sequence.
  NoOpenStartTagException | Exception indicating that an attribute or namespace node has been written when there is no open element to write it to
  Normalizer | Implements Unicode Normalization Forms C, D, KC, KD.
  NormalizerData | Accesses the Normalization Data used for Forms C and D.
  NormalizeSpace_1 | Implement the XPath normalize-space() function
  NormalizeSpaceCompiler | Generate bytecode for evaluation of a call to the normalize-space() function
  NormalizeUnicode | Implement the XPath normalize-unicode() function (both the 1-argument and 2-argument versions)
  Notation | A Notation Declaration Schema Component
  NotationSet | A set of declared notations (in the sense of XSD xs:notation)
  NotationValue | An xs:NOTATION value.
  NotFn | This class supports the XPath functions boolean(), not(), true(), and false()
  NotFnCompiler | Generate bytecode for the fn:not() function
  NotFnStreamer | Streaming code for an fn:not() function call
  NullDestination | A NullDestination is a Destination that discards all output sent to it.
  Number_1 | Implements the XPath fn:number() function when called with one argument.
  Numberer | Interface Numberer supports number formatting.
  Numberer_da | Localization class for Danish.
  Numberer_de | Class Numberer_de provides localization for format-date() and xsl:number with language = "de" (German)
  Numberer_en | Numberer class for the English language.
  Numberer_fr | Class Numberer_fr is a number formatter for french.
  Numberer_frBE | Class Numberer_frBE is a number formatter for French as used in Belgium.
  Numberer_he | Class Numberer_he does number formatting for language="he" (Hebrew).
  Numberer_it | Localization class for Italian
  Numberer_nl | Localization class for Dutch.
  Numberer_nlBE | Numberer class for the Belgian-Dutch language region.
  Numberer_sv | Numberer class for the Swedish language.
  Numberer_tr |
  NumberFnCompiler | Compile the fn:number() function to Java bytecode
  NumberFormatter | Class NumberFormatter defines a method to format a ArrayList of integers as a character string according to a supplied format specification.
  NumberInstruction | This instruction performs the node-counting function of the xsl:number instruction.
  NumberSequenceFormatter | This expression performs the formatting part of the logic of the xsl:number instruction It takes as input a sequence of integers, which may either be supplied directly as the value attribute of xsl:number, or may be computed by counting nodes.
  NumericComparer | A Comparer used for comparing sort keys when data-type="number".
  NumericComparer11 | A Comparer used for comparing sort keys when data-type="number".
  NumericComparisonOperand | Given an expression, this characteristic evaluates the set of hash keys corresponding to the string values of the items selected by that expression
  NumericGroupFormatter | A NumericGroupFormatter is responsible for insertion of grouping separators into a formatted number (for example, reformatting "1234" as "1,234").
  NumericType | Singleton class representing the class xs:numeric as defined in XPath 3.1: a union type whose members are xs:double, xs:decimal, and xs:float
  NumericValue | NumericValue is an abstract superclass for IntegerValue, DecimalValue, FloatValue, and DoubleValue
  ObjectConverter | This interface is based on the "CommonHandler" concept defined in early drafts of XQJ.
  ObjectLookupExpression | Saxon extension: a lookup expression of the form X?Y where X is a Java external object and Y is a method defined on that object
  ObjectMap | Extension function saxon:object-map(), which converts an external object to a map
  ObjectToBeSorted<T> | This class represents a member of a sequence that is being sorted.
  ObjectValue<T> | An XPath value that encapsulates a Java object.
  OccurrenceIndicator | Represents one of the possible occurrence indicators in a SequenceType.
  OnDemandFunctionSet | The `OnDemandFunctionSet` represents a function library where the implementation classes are loaded dynamically on demand.
  One<T extends Item> | A sequence containing exactly one item.
  OnEmpty | The OnEmpty class represents an action to be taken by the bytecode generator when compiling an expression to return a "primitive" (unboxed) value such as a double float int long or String (treated as primitive for this purpose).
  OnEmpty.ReturnEmptyString | The ReturnNull subclass indicates that when an expression evaluates to the empty sequence, the value should be returned as a zero-length string.
  OnEmpty.ReturnNull | The ReturnNull subclass indicates that when an expression evaluates to the empty sequence, the value should be returned as a Java null.
  OnEmpty.UnwindAndJump | The UnwindAndJump subclass causes the code generator, when an expression evaluates to the empty sequence, to generate a "goto" instruction to a defined label; but before executing the jump, the stack will be unwound to a known position.
  OnEmptyAdjunct | Generate streaming code for a consuming xsl:on-empty instruction
  OnEmptyExpr | A compiled xsl:on-empty instruction.
  OneOrMore<T extends Item> | A value that is a sequence containing one or more items.
  OneToOneMappingIterator | Abstract iterator that performs a one-to-one mapping from the items in the input sequence to the items in the output sequence; the mapping operation is defined by the map() action implemented in the subclass.
  OnNonEmptyAdjunct | Generate streaming code for a consuming xsl:on-non-empty instruction
  OnNonEmptyExpr | A compiled xsl:on-non-empty instruction.
  Operand | Information about a sub-expression and its relationship to the parent expression
  OperandArray | Defines an operand set comprising an array of operands numbered zero to N.
  OperandProcessor | Interface representing a visitor of the clauses of a FLWOR expession that can process and modify the operands of each clause
  OperandRole | Defines the role of a child expression relative to its parent expression.
  OperandUsage | The usage of an operand defines how the containing expression makes use of the value of the operand, as defined in the XSLT 3.0 specification.
  Operation | Represents an operation or instruction in the regular expression program.
  Operation.OpAtom | A match against a fixed string of any length
  Operation.OpBackReference | Back-reference
  Operation.OpBOL | Beginning of Line (^)
  Operation.OpCapture | Open paren (captured group)
  Operation.OpCharClass | A match of a single character in the input against a set of permitted characters
  Operation.OpChoice | A choice of several branches
  Operation.OpEndProgram | End of program
  Operation.OpEOL | End of Line ($)
  Operation.OpGreedyFixed | Handle a greedy repetition (with possible min and max) where the size of the repeated unit is fixed.
  Operation.OpNothing | Match empty string
  Operation.OpReluctantFixed | Handle a reluctant repetition (with possible min and max) where the size of the repeated unit is fixed.
  Operation.OpRepeat | Handle a repetition (with possible min and max) where the size of the repeated unit is variable.
  Operation.OpSequence | A sequence of multiple pieces
  Operation.OpTrace | Operation that wraps a base operation and traces its execution
  Operation.OpUnambiguousRepeat | Handle a repetition where there is no ambiguity; if the repeated term is matched in the string, then it cannot match anything other than the repeated term.
  Optimizer | This class performs optimizations that vary between different versions of the Saxon product.
  OptimizerEE | This class performs a number of optimizations that are specific to the Saxon-EE product.
  OptimizerOptions | Defines switches that can be used to control which optimizations take place.
  Optionality |
  OptionsParameter | This class implements the rules for options parameters, as used in functions such as parse-json, serialize, json-to-XML, map:merge.
  OrderByClause | This class represents an "order by" clause in a FLWOR expression
  OrderByClausePull | Represents the tuple stream delivered by an "order by" clause.
  OrderByClausePush | Represents the tuple stream delivered by an "order by" clause.
  OrderFacet | The saxon:order facet on a list type can be used to constrain the list to be in ascending or descending order.
  OrExpression |
  OrExpressionCompiler | Generate bytecode for an Or expression
  OriginalFunction | This class represents a function invoked using xsl:original from within an xs:override element.
  Orphan | A node (implementing the NodeInfo interface) representing an attribute, text node, comment, processing instruction, or namespace that has no parent (and of course no children).
  Outcome<T> | An Outcome represents the result of a task, which might be success or failure `T` is the class of the result of the task in the event that it is successful
  OuterForExpression | Expression class that implements the "outer for" clause of XQuery 3.0
  OuterForExpressionCompiler | Generate bytecode for a call to the OuterForExpression()
  Outermost | This class implements the function fn:outermost(), which is a standard function in XPath 3.0
  OutermostStreamer | Streaming code for an outermost() function call.
  OuterNewlineInserter | OuterNewlineInserter: This ProxyReceiver inserts a newline after any comment or PI child of the document node that precedes the first element child, and before any comment or PI child that follows the first element child.
  Outputter | Outputter: This interface represents a recipient of XML tree-walking (push) events.
  OutputterEvent | An outputter event is an object representing one of the events that can be passed to an `Outputter` : for example, a startElement, attribute, namespace endElement, characters, or comment event.
  OutputterEvent.Append | Event representing an arbitrary item being sent to the event stream in composed form.
  OutputterEvent.Attribute | Event representing an attribute node
  OutputterEvent.Comment | Event representing a comment node
  OutputterEvent.EndDocument | Event representing end of document
  OutputterEvent.EndElement | Event representing the end of an element
  OutputterEvent.Namespace | Event representing a namespace node
  OutputterEvent.ProcessingInstruction | Event representing a processing instruction node
  OutputterEvent.StartContent | Event representing the start of element content
  OutputterEvent.StartDocument | Event representing start of document
  OutputterEvent.StartElement | Event representing the start of an element (including attributes or namespaces)
  OutputterEvent.Text | Event representing a text node
  OutputterEventBuffer | An `EventBuffer` is a receiver of events that records the events in memory for subsequent replay.
  OutputURIResolver | This interface defines an OutputURIResolver.
  OutputURIResolverWrapper | This class is an implementation of the `ResultDocumentResolver` interface that wraps a supplied `OutputURIResolver`.
  PackageData | Information about a unit of compilation: in XSLT, a package; in XQuery, a module.
  PackageDetails | Information about a package held in a package library; the package may or may not be loaded in memory
  PackageInspector | The PackageInspector class is a Receiver that looks at an incoming stylesheet document and extracts the package name and version from the root element; parsing is then abandoned.
  PackageLibrary | A PackageLibrary represents a collection of packages that can be searched, typically to satisfy an xsl:use-package declaration.
  PackageLoaderEE | Saxon-EE version of PackageLoader
  PackageLoaderHE | This class reads the XML exported form of a package and reconstructs the package object in memory.
  PackageLoaderHE.ExpressionLoader |
  PackageLoaderHE.PatternLoader |
  PackageLoaderPE | This class reads the XML exported form of a package and reconstructs the package object in memory.
  PackageVersion | A class to represent an XSLT package version such as 1.12.5 or 3.0-alpha
  PackageVersionRanges | A class to handle a set of package version ranges
  PairIterator<T> | An iterator over a pair of objects (typically sub-expressions of an expression)
  ParameterSet | A ParameterSet is a set of parameters supplied when calling a template.
  ParentConstructorAdjunct | Watch factory class for an atomizer
  ParentNodeConstructor | An abstract class to act as a common parent for instructions that create element nodes and document nodes.
  ParentNodeImpl | ParentNodeImpl is an implementation of a non-leaf node (specifically, an Element node or a Document node)
  Parse | This class implements the saxon:parse() extension function, which is specially-recognized by the system because it needs access to parts of the static context
  ParseHtml | Supports the saxon:parse-html() function, a variant of saxon:parse() that differs only in that it uses the TagSoup HTML parser
  ParseIetfDate | This class implements the function parse-ietf-date(), which is a standard function in XPath 3.1
  ParseJsonFn | Implements the parse-json function, as defined in XPath 3.1 The parsing code, and the handling of options is shared with the json-to-xml function.
  ParseOptions | This class defines options for parsing and/or validating a source document.
  ParserExtension | Dummy Parser extension for syntax in XPath that is accepted only in particular product variants.
  ParserExtension.InlineFunctionDetails |
  ParserExtension.TemporaryXSLTVariableBinding |
  ParseXml |
  ParseXml.RetentiveErrorHandler |
  ParseXmlFragment |
  ParseXPath | This class implements the saxon:parse-XPath() extension function, which is specially-recognized by the system because it needs access to parts of the static context
  PartialApply | This expression class implements the operation of currying (or performing partial application) of a function.
  PartialApplyCompiler | Generate bytecode for a call to a PartialApply expression
  Particle | Represents a Particle as defined by XML Schema.
  Path_1 | Implement the fn:path function with one argument
  PathMaintainer | This class sits in a receiver (push) pipeline and maintains the current path.
  PathMap | A PathMap is a description of all the paths followed by an expression.
  PathMap.PathMapArc | An arc joining two nodes in the path map.
  PathMap.PathMapNode | A node in the path map.
  PathMap.PathMapNodeSet | A (mutable) set of nodes in the path map
  PathMap.PathMapRoot | A root node in the path map.
  PathMappedAccumulatorData | Accumulator data for a tree that is obtained by mapping the nodes in this tree to nodes in some other tree (specifically, the subtree from which this tree was originally copied with copy-accumulators=yes) and getting the accumulator value from the corresponding node in the other tree.
  Pattern | A Pattern represents the result of parsing an XSLT pattern string.
  PatternFacet | Represents a pattern facet on a schema-defined simple type
  PatternMaker | This is a singleton class used to convert an expression to an equivalent pattern.
  PatternOptimizer | A PatternOptimizer is an agent responsible for optimizing a particular class of patterns.
  PatternParser | Interface to a parser of XSLT patterns.
  PatternParser30 | Parser for XSLT patterns.
  PatternThatSetsCurrent | This class represents a pattern that sets the value of current() to the node being matched, and then wraps another pattern that uses the value of current()
  PatternWatch | A Watch represents a class that is interested in looking at nodes for the purpose of evaluating uniqueness and key constraints, or for XSLT streaming; specifically, an implementation of Watch that retains a Pattern which is evaluated to see whether a particular node matches the Watch.
  PatternWithPredicate | Represents a pattern with a predicate, for example item[@value=3] or .[.
  Pedigree | A `Pedigree` is transient information relating to a map or array indicating the route by which it was reached; it thus compensates for the absence of parent pointers in a JSON-like tree, by allowing the steps used to reach a map or array in such a structure to be retraced.
  PedigreeArrayItem | A `PedigreeArrayItem` represents an XDM array together with a `Pedigree`: that is, retained information about how the array was selected with a JSON-like tree.
  PedigreeFn | The saxon:pedigree function, new in Saxon 9.9.
  PedigreeMapItem | A `PedigreeMapItem` represents an XDM map together with a `Pedigree`: that is, retained information about how the map was selected within a JSON-like tree.
  PedigreeValue | A `PedigreeValue` is a map or array together with a `Pedigree` indicating how that map or array was selected within a JSON-like tree structure.
  PendingUpdateAction | A pending update action, such as is found on a pending update list
  PendingUpdateList | A PendingUpdateList is created by updating expressions in XQuery Update.
  PendingUpdateListImpl | Concrete implementation of the Pending Update List
  PIGrabber | The `PIGrabber` class is a `ProxyReceiver` that looks for `xml-stylesheet` processing instructions and tests whether they match specified criteria; for those that do, it creates a `Source` object referring to the relevant stylesheet
  PIOverNodeInfo | This class is an implementation of the DOM ProcessingInstruction interface that wraps a Saxon NodeInfo representation of a text or comment node.
  PipelineConfiguration | A PipelineConfiguration sets options that apply to all the operations in a pipeline.
  PJConverter | This class together with its embedded subclasses handles conversion from XPath values to Java values
  PJConverter.AnyURIValueToURI |
  PJConverter.AnyURIValueToURL |
  PJConverter.Atomic | Converter for use when the source object is an atomic value, but nothing more is known statically.
  PJConverter.BooleanValueToBoolean |
  PJConverter.CalendarValueToCalendar |
  PJConverter.CalendarValueToDate |
  PJConverter.CalendarValueToInstant |
  PJConverter.CalendarValueToLocalDateTime |
  PJConverter.CalendarValueToOffsetDateTime |
  PJConverter.CalendarValueToZonedDateTime |
  PJConverter.DateValueToLocalDate |
  PJConverter.General | General-purpose converter when nothing more specific is available.
  PJConverter.Identity |
  PJConverter.IntegerValueToBigInteger |
  PJConverter.IntegerValueToByte |
  PJConverter.IntegerValueToChar |
  PJConverter.IntegerValueToInt |
  PJConverter.IntegerValueToLong |
  PJConverter.IntegerValueToShort |
  PJConverter.NumericValueToBigDecimal |
  PJConverter.NumericValueToDouble |
  PJConverter.NumericValueToFloat |
  PJConverter.QualifiedNameValueToQName |
  PJConverter.StringValueToChar |
  PJConverter.StringValueToString |
  PJConverter.ToArray | Converter for use when the target class is an array
  PJConverter.ToCollection | Converter for use when the target class is a collection class.
  PJConverter.ToNull |
  PJConverter.ToOne | Converter for use when the target class is `One`, which constrains the value to be a singleton
  PJConverter.ToOneOrMore | Converter for use when the target class is `OneOrMore`, which constrains the value to be a non-empty sequence
  PJConverter.ToSequenceExtent |
  PJConverter.ToSequenceIterator |
  PJConverter.ToZeroOrMore | Converter for use when the target class is `ZeroOrMore`, which allows any sequence but is a generic (parameterized) class so there is compile-time information about the type of items
  PJConverter.ToZeroOrOne | Converter for use when the target class is `ZeroOrOne`, which constrains the value to be a singleton or an empty sequence
  PJConverter.UnwrapExternalObject |
  PlainType | A "plain type" is either an atomic type, or a union type that (a) imposes no restrictions other than those imposed by its member types, and (b) has exclusively plain types as its member types
  Platform | This interface provides access to methods whose implementation depends on the chosen platform (typically Java or .NET)
  PooledXQConnection | An object that provides hooks for connection pool management.
  PositionAndLast |
  PositionAndLast.Last |
  PositionAndLast.Position |
  PositionCompiler | Generate code for a call to position()
  Posture | The posture of an expression defines the relationship of the result to a streamed input document, as defined in the XSLT 3.0 specification.
  PostureAndSweep | This class defines a composite property of an expression containing both the posture and sweep of the expression, as defined in the XSLT 3.0 specification.
  PostureGetter | This interface defines a method used to get the context item posture.
  Precondition | A Precondition is a boolean condition that must be true if a pattern is to match (but in general is not a sufficient condition for the pattern to match).
  Precondition.BooleanPrecondition | A `BooleanPrecondition` can in principle test any boolean characteristic of a pattern.
  Precondition.NumericComparisonPrecondition | A numeric comparison precondition is used for patterns containing a predicate that compares some expression E with a numeric constant.
  Precondition.StringHashPrecondition | A StringHashPrecondition compares a characteristic in the form of a set of integer hash codes against a constant hash code; the precondition is satisfied if the constant hash code is present in the set.
  PreconditionMatcher | This class contains the stateful part of the precondition checker.
  PredicateCharacterClass | A character class represents a set of characters for regex matching purposes.
  Predicates | This non-instantiable class provides a number of useful implementations of the `Predicate` interface, designed for use when navigating streams of XDM items.
  PrefixPool | A prefix pool maintains a two-way mapping from namespace prefixes (as strings) to integer prefix codes.
  PreparedSchema | A schema is a collection of schema components.
  PreparedStylesheet | This PreparedStylesheet class represents a Stylesheet that has been prepared for execution (or "compiled").
  PrependAxisIterator | An iterator over nodes, that prepends a given node to the nodes returned by another iterator.
  PrependSequenceIterator | An iterator over nodes, that prepends a given node to the nodes returned by another iterator.
  PreprocessFacet | Represents the preprocess facet on a schema-defined simple type.
  PrimitiveUType |
  PrincipalOutputGatekeeper | This class is added to the output pipeline for the principal result destination for a transformation if the transformation uses xsl:result-document instructions.
  PrincipalStylesheetModule | Represents both the stylesheet module at the root of the import tree, that is, the module that includes or imports all the others, and also the XSLT package that has this stylesheet module as its root.
  PrincipalStylesheetModuleEE | This version of the StylesheetPackage class represents a "real" package, that is one with an xsl:package element, which potentially uses other packages and overrides selected components in those packages.
  ProcessingInstruction | An xsl:processing-instruction element in the stylesheet, or a processing-instruction constructor in a query
  ProcessingInstructionCompiler |
  Processor | The `Processor` class serves three purposes: it allows global Saxon configuration options to be set; it acts as a factory for generating XQuery, XPath, and XSLT compilers; and it owns certain shared resources such as the Saxon NamePool and compiled schemas.
  ProcInstImpl | ProcInstImpl is an implementation of ProcInstInfo used by the Propagator to construct its trees.
  ProcInstParser | ProcInstParser is used to parse pseudo-attributes within Processing Instructions.
  ProfessionalConfiguration | This class holds details of user-selected configuration options for a set of transformations and/or queries.
  ProfessionalTransformerFactory | The is the JAXP TransformerFactory implementation for the professional edition of Saxon.
  ProfessionalXPathFactory | An implementation of the JAXP XPath Factory that creates a Professional configuration.
  Projector | This class uses a `PathMap` to do document projection.
  ProtocolRestricter | This class implements the rules in a property such as `XMLConstants.ACCESS_EXTERNAL_SCHEMA`, which constrain the set of URIs that can be used by supplying a list of permitted protocols.
  ProxyOutputter |
  ProxyReceiver | A ProxyReceiver is an Receiver that filters data before passing it to another underlying Receiver.
  PseudoExpression | A pseudo-expression is an object that can appear as a node on the expression tree, but which cannot actually be evaluated in its own right.
  PublicStylesheetFunctionLibrary | A PublicStylesheetFunctionLibrary filters a StylesheetFunctionLibrary to include only those functions whose visibility is final or public.
  PullConsumer | A PullConsumer consumes all the events supplied by a PullProvider, doing nothing with them.
  PullFilter | PullFilter is a pass-through filter class that links one PullProvider to another PullProvider in a pipeline.
  PullFromIterator | This class delivers any XPath sequence through the pull interface.
  PullNamespaceReducer | PullNamespaceReducer is a PullFilter responsible for removing duplicate namespace declarations.
  PullProvider | PullProvider is Saxon's pull-based interface for reading XML documents and XDM sequences.
  PullProvider.Event |
  PullPushCopier | This class copies a document by using the pull interface to read the input document, and the push interface to write the output document.
  PullPushTee | PullPushTee is a pass-through filter class that links one PullProvider to another PullProvider in a pipeline, copying all events that are read into a push pipeline, supplied in the form of a Receiver.
  PullSource | A PullSource is a JAXP Source that encapsulates a PullProvider - that is, an object that supplies an XML document as a sequence of events that are read under the control of the recipient.
  PullToStax | This class bridges PullProvider events to XMLStreamReader (Stax) events.
  PullToStax.SourceStreamLocation | Bridge a SAX SourceLocator to a javax.xml.stream.Location
  PullTracer | PullTracer is a PullFilter that can be inserted into a pull pipeline for diagnostic purposes.
  Push | An interface designed for applications to generate XML documents by issuing events.
  Push.Container | The `Container` interface represents a document node or element node under construction; there are concrete subclasses representing document nodes and element nodes respectively.
  Push.Document | A `Push.Container` representing a document node.
  Push.Element | A `Push.Container` representing an element node.
  PushableFunction | Interface implemented by functions that have a "push" implementation, whereby the result of the function is written incrementally to an `Outputter` rather than being returned as the result of a `call()` method.
  PushToPull | This class evaluates an expression in push mode in one thread, and provides an iterator to read the results of the expression in pull mode in the original thread.
  PushToPull.Pusher |
  PushToReceiver |
  Put | Implements the fn:put() function in XQuery Update 1.0.
  PutAction | A saved put() call on the pending update list.
  QName | The QName class represents an instance of xs:QName, as defined in the XPath 2.0 data model.
  QNameException | A QNameException represents an error condition whereby a QName (for example a variable name or template name) is malformed
  QNameFn | This class supports the fn:QName() function (previously named fn:expanded-QName())
  QNameFnCompiler | Generate bytecode for a call to fn:QName
  QNameParser | Parser to handle QNames in either lexical QName or EQName syntax, including resolving any prefix against a URIResolver.
  QNameTest | Interface for tests against a QName.
  QNameValue | A QName value.
  QualifiedNameValue | A qualified name: this is an abstract superclass for QNameValue and NotationValue, representing the XPath primitive types xs:QName and xs:NOTATION respectively
  QuantifiedExpression | A QuantifiedExpression tests whether some/all items in a sequence satisfy some condition.
  QuantifiedExpressionCompiler | Compile the QuantifiedExpression to Java bytecode
  Query | This is a synonym of net.sf.saxon.Query, the command line interface for running XQuery.
  Query | This Query class provides a command-line interface to the Saxon XQuery processor.
  QueryFn | This class implements the saxon:query() extension function
  QueryLibrary | A QueryLibrary represents an independently compiled set of query modules that does not include a main module.
  QueryLibraryImpl | Concrete implementation of a separately-compiled XQuery library
  QueryModule | This class represents a query module, and includes information about the static context of the query module.
  QueryReader | This class contains static methods used to read a query as a byte stream, infer the encoding if necessary, and return the text of the query as a string; also methods to import functions and variables from one module into another, and check their consistency.
  QueryResult | This utility class takes the result sequence produced by a query, and wraps it as an XML document.
  QuickXPathParser | This class performs a quick parse of commonly encountered XPath expressions that conform to common syntactic patterns.
  QuitParsingException | An exception used to signal that no more input is required from the parser, and that parsing can therefore be abandoned early (but without signaling any error to the user)
  Random | This class implements extension functions in the http://exslt.org/random namespace.
  RandomNumberGenerator | This class implements the function random-number-generator(), which is a standard function in XPath 3.1
  RangeExpression | A RangeExpression is an expression that represents an integer sequence as a pair of end-points (for example "x to y").
  RangeExpressionCompiler | Generate bytecode for an integer range expression (X to Y)
  RangeIterator | An Iterator that produces numeric values in a monotonic sequence, ascending or descending.
  RangeKey | This class implements an XPath map item as a view of an XSLT key index.
  RawDestination | An `RawDestination` is a `Destination` that accepts a sequence output by a stylesheet or query and returns it directly as an `XdmValue`, without constructing an XML tree, and without serialization.
  RawResult | This class is an implementation of the JAXP Result interface.
  RebasedDocument | A `RebasedDocument` represents a view of a real Document in which all nodes are mapped to a different base URI and/or system ID using supplied mapping functions.
  RebasedNode | A RebasedNode is a view of a node, in a virtual tree that maps the base URI and/or system ID to new values
  RebindingMap | A map from old bindings to new bindings, maintained during a copy() operation applied to an expression tree.
  Receiver | Receiver: This interface represents a recipient of XML tree-walking (push) events.
  ReceiverOption | ReceiverOption defines a set of constants representing boolean flags, which can be used in calls to methods on the Receiver interface.
  ReceiverToXMLStreamWriter | ReceiverToXMLStreamWriter is a Receiver writes XML by using the XMLStreamWriter
  ReceiverWithOutputProperties | Marker interface attached to a `Outputter` that retains serialization properties (typically, a Receiver that forms part of the serialization pipeline).
  ReceivingContentHandler | ReceivingContentHandler is a glue class that provides a standard SAX ContentHandler interface to a Saxon Receiver.
  ReceivingContentHandler.LocalLocator | An implementation of the Saxon `Location` interface that wraps the SAX Locator information.
  ReceivingDestination | An implementation of `Destination` that simply wraps a supplied `Receiver`
  RECompiler | A regular expression compiler class.
  RecoveryPolicy |
  RedirectHandler |
  REFlags | Class representing a set of regular expression flags (some combination of i, m, s, x, q).
  RefSelectorWatch | This class watches the selector for a keyref constraint
  RegexFunction | This class implements any of the functions matches(), replace(), tokenize(), analyze-string(), in the version where a flags argument is present in the argument list
  RegexFunctionSansFlags | This class implements any of the functions matches(), replace(), tokenize(), analyze-string(), in which the final "flags" argument is omitted.
  RegexGroup |
  RegexIterator | This interface defines an iterator that supports the evaluation of xsl:analyze-string.
  RegexIterator.MatchHandler | Interface defining a call-back action for processing captured groups
  RegexPrecondition | A precondition that must be true if a regular expression is to match
  RegularExpression | This interface represents a compiled regular expression.
  RegularGroupFormatter | A RegularGroupFormatter is a NumericGroupFormatter that inserts a separator at constant intervals through a number: for example, a comma after every three digits counting from the right.
  RegularSequenceChecker | A `RegularSequenceChecker` is a filter that can be inserted into a Receiver pipeline to check that the sequence of events passed in is a regular event sequence.
  RegularSequenceChecker.State |
  RelativeURIResolver | The standard JAXP URIResolver is given a relative URI and a base URI and returns the resource identified by this combination.
  REMatcher | RE is an efficient, lightweight regular expression evaluator/matcher class.
  REMatcher.State |
  Remove | The XPath 2.0 remove() function
  Remove.RemoveIterator | An implementation of SequenceIterator that returns all items except the one at a specified position.
  RemoveStreamer | Generate streaming code for a remove() function call.
  RenameAction | A pending update action representing the effect of a rename expression
  RenameExpression | A rename expression in XQuery Update
  RepairingContentHandler | A RepairingContentHandler is a SAX filter that can be placed on the input pipeline in front of a `ReceivingContentHandler` for use in cases where the events supplied by the XML parser are not guaranteed to satisfy all the consistency constraints.
  Replace | This class implements the replace() function for replacing substrings that match a regular expression
  ReplaceAttributeAction | A pending update action representing a replace node expression applied to an attribute.
  ReplaceNodeAction | A pending update action representing the effect of a "replace node" expression
  ReplaceNodeExpression | A "replace node" expression in XQuery Update
  ReplaceValueAction | A pending update action representing the effect of a "replace value" expression.
  ReplaceValueExpression | A "replace value of" expression in XQuery Update
  ReplaceWith | This class implements the saxon:replace-with() function for replacing substrings that match a regular expression by means of a callback to a user-supplied function
  REProgram | A class that holds compiled regular expressions.
  ResolveQName | This class supports the resolve-QName function in XPath 2.0
  ResolveURI | This class supports the resolve-uri() function in XPath 2.0
  Resource | This interface defines a Resource.
  ResourceCollection | This interface defines a ResourceCollection.
  ResourceFactory | A ResourceFactory is used for constructing a particular type of resource
  ResultDocument | The compiled form of an xsl:result-document element in the stylesheet.
  ResultDocumentAdjunct | Handle an xsl:result-document expression/instruction for XSLT streaming capability.
  ResultDocumentAdjunct.ResultDocumentFeed |
  ResultDocumentCompiler | Generate bytecode for the xsl:result-document instruction
  ResultDocumentResolver | The `ResultDocumentResolver` interface may be implemented by a user application; it is a callback that is called whenever an xsl:result-document instruction is executed.
  RESyntaxException | Exception thrown to indicate a syntax error in a regular expression.
  RetainedStaticContext | This class contains the part of the static context of expressions that (a) can change from one expression to another within a query or stylesheet, and (b) are potentially needed at run-time.
  ReturnClauseIterator | This iterator applies the return expression of a FLWOR expression to each of the tuples in a supplied tuple stream, returning the result as an iterator
  ReturnClausePush | The class represents the final stage in a push-mode tuple pipeline.
  Reverse | Implement XPath function fn:reverse()
  ReverseListIterator<T extends Item> | ReverseListIterator is used to enumerate items held in an array in reverse order.
  ReverseRangeIterator | Iterator that produces numeric values in a monotonic sequence, ascending or descending.
  ReverseStreamer |
  ReversibleIterator | A ReversibleIterator is an interface implemented by any SequenceIterator that is able to deliver items in reverse order (or to supply another iterator that can do so).
  RoleDiagnostic | A RoleDiagnostic (formerly RoleLocator) identifies the role in which an expression is used, for example as the third argument of the concat() function.
  Root_1 | Implement the XPath 2.0 root() function with one argument
  RootExpression | An expression whose value is always a set of nodes containing a single node, the document root.
  RootExpressionAdjunct | Streaming code for an expression that does not support streaming
  RootExpressionCompiler | Generate bytecode for a call to the RootExpression()
  RootFunctionCompiler |
  RootStreamer |
  Round | This class implements the fn:round() function
  RoundHalfToEven | This class supports the round-to-half-even() function
  RoundingCompiler | Compiler for the functions floor(), ceiling(), round(), round-half-to-even(), and abs()
  Rule | Rule: a template rule, or a strip-space rule used to support the implementation
  RuleBasedSubstringMatcher | This class wraps a RuleBasedCollator to provide a SubstringMatcher.
  RuleChain | A chain of rules: actually in this incarnation just a pointer to the first rule in the chain, the others being linked together each to the next.
  RuleEE | A Rule with associated preconditions
  RuleManager | RuleManager maintains a set of template rules, one set for each mode
  RuleSearchState | A simple class for holding stateful details of a rule search operation This is a dummy implementation for Saxon-HE which does not optimize searching a rule chain.
  RuleSetWithWarnings | A set of built-in template rules that performs the same action as an underlying set of rules, but with the addition of a warning message saying that no user-defined template rules was found.
  RuleTarget | The target of a rule, typically a TemplateRule.
  SameNameTest | NodeTest is an interface that enables a test of whether a node has a particular name and type.
  SaplingComment | A comment node in a sapling tree
  SaplingDocument | A document node in a sapling tree.
  SaplingElement | An element node on a sapling tree.
  SaplingNode | This class represents a sapling node.
  SaplingProcessingInstruction | A processing-instruction node in a sapling tree
  Saplings | This is a non-instantiable class holding a number of convenience methods for creating sapling nodes of different kinds.
  SaplingText |
  SAXDestination | This class represents a `Destination` (for example, the destination of the output of a transformation) in which events representing the XML document are sent to a user-supplied SAX2 `ContentHandler`, as if the `ContentHandler` were receiving the document directly from an XML parser.
  Saxon6ElementFactory | A Factory for the old saxon:output extension instruction (in the old Saxon6 namespace) for the benefit of people running the docbook stylesheets.
  SaxonApiException | An exception thrown by the Saxon s9api API.
  SaxonApiUncheckedException | An unchecked exception thrown by the Saxon API.
  SaxonArray | saxon:array element in stylesheet.
  SaxonArrayMemberInst | saxon:array-member element in stylesheet.
  SaxonAssign | saxon:assign element in stylesheet.
  SaxonChange | saxon:change is an XSLT version of the XQuery Update "replace value of node" expression.
  SaxonDeepUpdate | Handler for saxon:deep-update elements in stylesheet.
  SaxonDelete | saxon:delete is an XSLT version of the XQuery Update "delete node" expression.
  SaxonDo | Handler for saxon:do elements in stylesheet.
  SaxonDoctype | A saxon:doctype element in the stylesheet.
  SaxonDuration | Saxon implementation of the JAXP class javax.xml.datatype.Duration.
  SaxonElementFactory | A Factory for Saxon extension nodes in the stylesheet tree.
  SaxonElementFactoryEE | A Factory for Saxon extension nodes in the stylesheet tree.
  SaxonEntityRef | A saxon:entity-ref element in the stylesheet.
  SaxonErrorCode | The class acts as a register of Saxon-specific error codes.
  SaxonForEachMember | Handler for saxon:for-each-member elements in stylesheet.
  SaxonImportQuery | The class implements a saxon:import-query declaration in a stylesheet.
  SaxonInsert | saxon:insert is an XSLT version of the XQuery Update "insert node" expression.
  SaxonItemType | The class implements a saxon:item-type declaration in a stylesheet.
  SaxonOutputKeys | Provides string constants that can be used to set output properties for a Transformer, or to retrieve output properties from a Transformer or Templates object.
  SaxonParam | This object represents a saxon:param element in a schema document.
  SaxonPreprocess | saxon:preprocess is an implementation-defined pre-lexical facet as permitted by XML Schema 1.1.
  SaxonRename | saxon:rename is an XSLT version of the XQuery Update rename expression.
  SaxonReplace | saxon:replace is an XSLT version of the XQuery Update "replace node" expression.
  SaxonSyntaxExtension | Parser extension for syntax in XPath that is accepted only in Saxon-PE and -EE.
  SaxonSyntaxExtension.UnderscoreFunctionDetails |
  SaxonTabulateMaps | Handler for saxon:tabulate-maps elements in stylesheet.
  SaxonTransformerFactory | A SaxonTransformerFactory instance can be used to create Transformer and Template objects.
  SaxonUpdate | saxon:update is an XSLT version of the XQuery Update copy-modify expression.
  SaxonWhile | Handler for saxon:while elements in stylesheet.
  SaxonXMLGregorianCalendar | Saxon implementation of the JAXP class javax.xml.datatype.XMLGregorianCalendar.
  SaxonXQConnection | Saxon implementation of the XQL interface XQConnection.
  SaxonXQDataFactory | Saxon implementation of the XQJ interface XQDataFactory.
  SaxonXQDataSource | Saxon implementation of the XQJ XQDataSource interface.
  SaxonXQDynamicContext | Saxon implementation of the XQJ DynamicContext interface
  SaxonXQExpression | Saxon implementation of the XQJ XQExpression interface
  SaxonXQForwardSequence | The class is a Saxon implementation of the XQJ interface XQResultSequence.
  SaxonXQItem | This Saxon class is used to implement both the XQItem and XQResultItem interfaces in XQJ.
  SaxonXQItemAccessor | All Saxon implementations of XQItemAccessor must implement this interface
  SaxonXQItemType | Saxon implementation of the XQJ XQItemType interface
  SaxonXQMetaData | Saxon implementation of the XQMetaData interface
  SaxonXQPreparedExpression | Saxon implementation of the XQJ interface XQPreparedExpression.
  SaxonXQSequence | Saxon implementation of the XQSequence interface in XQJ, which represents an XDM sequence together with a current position.
  SaxonXQSequenceType | Saxon implementation of the XQJ SequenceType interface
  SaxonXQStaticContext | Saxon implementation of the XQJ XQStaticContext interface
  ScalarSystemFunction | A Scalar system function is a pure function that accepts a single item as its operand, returns a single atomic value as its result, typically returns an empty sequence if the argument is an empty sequence, and has no context dependencies.
  SchemaAttributeTest | A NodeTest of the form schema-attribute(attribute-name)
  SchemaCompiler | A SchemaCompiler is capable of reading source schema documents and converting them into collections of schema components.
  SchemaComponent | This is a marker interface that represents any "schema component" as defined in the XML Schema specification.
  SchemaComponent.ValidationStatus |
  SchemaDeclaration | This is a marker interface that acts as a surrogate for an object representing a global element or attribute declaration.
  SchemaDocument | An XML document containing a module of an XML Schema.
  SchemaDocumentTransformer | Class that applies a standard transformation to a schema document: specifically, the chameleon transformation or the override transformation
  SchemaElement | An element in an XML Schema document.
  SchemaElementTest | A NodeTest of the form schema-element(element-name)
  SchemaException | An exception that identifies an error in reading, parsing, or validating a schema.
  SchemaFactoryImpl | This is the Saxon implementation of the JAXP 1.3 SchemaFactory interface.
  SchemaFactoryImpl.ErrorReporterWrappingErrorHandler | A JAXP ErrorListener that wraps a SAX ErrorHandler
  SchemaFn | This class implements the saxon:schema() extension function.
  SchemaManager | The SchemaManager is used to load schema documents, and to set options for the way in which they are loaded.
  SchemaManagerImpl | The SchemaManager is used to load schema documents, and to set options for the way in which they are loaded.
  SchemaModelLoader | This class allows a compiled schema model in SCM format to be loaded into memory.
  SchemaModelSerializer | This class provides services enabling a compiled schema to be serialized to disk
  SchemaNodeFactory | Class SchemaNodeFactory.
  SchemaNodeTest | Marker interface for schema-element() and schema-attribute() node tests
  SchemaReader | A class for reading XML Schema documents.
  SchemaReference | A reference to a Saxon prepared schema.
  SchemaStructure | The base class for all XML Schema stuctures.
  SchemaType | SchemaType is an interface implemented by all schema types: simple and complex types, built-in and user-defined types.
  SchemaURIResolver | A SchemaURIResolver is used when resolving references to schema documents.
  SchemaValidator | A `SchemaValidator` is an object that is used for validating instance documents against a schema.
  SchemaValidatorImpl | A `SchemaValidator` is an object that is used for validating instance documents against a schema.
  ScopedBindingElement | Marker interface for elements that declare a variable which is in-scope within their body
  SearchableValue | A sequence that is held in a form that permits rapid searching, typically by use of indexes.
  SelectedElementsSpaceStrippingRule | A whitespace stripping rule that strips elected elements unless xml:space indicates that whitespace should be preserved.
  SelectionParser | This class parses the two XPath subsets defined in XML Schema for handling the "selector" and "field" attributes of the <unique>, <key>, and <keyref> elements.
  SelectorWatch | A Watch represents a class that is interested in looking at nodes for the purpose of evaluating uniqueness and key constraints.
  Sender | Sender is a helper class that sends events to a Receiver from any kind of Source object
  SendMail | This class implements the extension function saxon:send-mail().
  Sequence | This interface represents an XDM Value, that is, a sequence of items.
  SequenceCollector | This receiver is used when writing a sequence of atomic values and nodes, that is, when xsl:variable is used with content and an "as" attribute.
  SequenceCopier | Copies a sequence, supplied as a SequenceIterator, to a push pipeline, represented by a SequenceReceiver
  SequenceExtent | A sequence value implemented extensionally.
  SequenceInstr | A compiled xsl:sequence instruction.
  SequenceInstrAdjunct |
  SequenceIterator | A SequenceIterator is used to iterate over any XPath 2 sequence (of values or nodes).
  SequenceIterator.Property |
  SequenceModelGroup | A SequenceCompositor represents an xs:sequence element in the schema
  SequenceNormalizer | Implement the "sequence normalization" logic as defined in the XSLT 3.0/XQuery 3.0 serialization spec.
  SequenceNormalizerWithItemSeparator | Implement the "sequence normalization" logic as defined in the XSLT 3.0/XQuery 3.0 serialization spec.
  SequenceNormalizerWithSpaceSeparator | Implement the "sequence normalization" logic as defined in the XSLT 3.0/XQuery 3.0 serialization spec, for the case where there is no item-separator.
  SequenceReceiver | SequenceReceiver: this extension of the Receiver interface is used when processing a sequence constructor.
  SequenceSlice | A sequence value implemented extensionally.
  SequenceTool | Utility class for manipulating sequences.
  SequenceType | A SequenceType is the combination of an ItemType and an OccurrenceIndicator
  SequenceType | SequenceType: a sequence type consists of a primary type, which indicates the type of item, and a cardinality, which indicates the number of occurrences permitted.
  SequenceWrapper | This class can be used in a push pipeline: it accepts any sequence as input, and generates a document in which the items of the sequence are wrapped by elements containing information about the types of the items in the input sequence.
  SequenceWriter | The `SequenceWriter` is used when writing a sequence of items, for example, when `xsl:variable` is used with content and an "as" attribute.
  SerializableSchemaComponent | A component that can be serialized by the SchemaSerializer.
  SerializationParamsHandler | This class handles a set of serialization parameters provided in the form of an XDM instance as specified in the Serialization 3.0 definition, section 3.1
  SerializationProperties | Define a set of serialization properties.
  Serialize | This class implements the saxon:serialize() extension function, which is specially-recognized by the system because it needs access to parts of the static context
  Serialize | Implementation of fn:serialize() as defined in XPath 3.1
  Serializer | A `Serializer` takes a tree representation of XML and turns it into lexical XML markup.
  Serializer.Property | Enumeration class defining the permitted serialization properties
  SerializerFactory | Helper class to construct a serialization pipeline for a given result destination and a given set of output properties.
  SerializerFactoryPE | Saxon-PE extensions to the serializer factory
  Sets | This class implements extension functions in the http://exslt.org/sets namespace.
  ShallowCopyEventFeed | This event feed implements an implicit xsl:copy instruction used in a built-in template.
  ShallowCopyRuleSet | The built-in rule set introduced in XSLT 3.0, which is effectively an identity template.
  ShallowDescentFunctionCallAdjunct | Handle streaming for calls to user-defined functions with streamability="shallow-descent"
  ShallowSkipRuleSet | A built-in set of template rules that ignores the current node and does an apply-templates to its children.
  SiblingCountingNode | Interface that extends NodeInfo by providing a method to get the position of a node relative to its siblings.
  SignificantItemDetector | This receiver is inserted into the output pipeline whenever on-empty or on-non-empty is used (XSLT 3.0).
  SimpleArrayItem | A simple implementation of XDM array items, in which the array is backed by a Java List.
  SimpleCollation | A simple collation that just wraps a supplied Comparator
  SimpleComponentReference | A reference to a named schema group within the content model of a complex type
  SimpleContentFeed | This class is used when a streaming template requests evaluation of a simple content constructor in streaming mode (that is, when it constructs a text, attribute, comment, or PI node based on the contents of the streamed document).
  SimpleContentValidator | This class is a filter that is used to validate that an element has simple content conforming to a given simple type.
  SimpleExpression | An abstract implementation of Expression designed to make it easy to implement new expressions, in particular, expressions to support extension instructions.
  SimpleMode | A Mode is a collection of rules; the selection of a rule to apply to a given element is determined by a Pattern.
  SimpleMode.RuleGroupAction | Interface used around a group of rules - principally at the group start and the group end
  SimpleNodeConstructor | Common superclass for XSLT instructions whose content template produces a text value: xsl:attribute, xsl:comment, xsl:processing-instruction, xsl:namespace, and xsl:text, and their XQuery equivalents
  SimpleNodeConstructorAdjunct | Generate streaming code for an xsl:value-of, xsl:comment, xsl:processing-instruction instruction, etc
  SimpleNodeConstructorCompiler |
  SimpleNodeConstructorFeed | This class is used when a streaming template requests evaluation of a simple content constructor in streaming mode (that is, when it constructs a text, attribute, comment, or PI node based on the contents of the streamed document).
  SimplePositionalPattern | A SimplePositionalPattern is a pattern of the form A[N] where A is an axis expression using the child axis and P is a numeric literal.
  SimpleStepExpression | A SimpleStepExpression is a special case of a SlashExpression in which the start expression selects a single item (or nothing), and the step expression is a simple AxisExpression.
  SimpleStepExpressionCompiler | Generate bytecode for a call to the SimpleStepExpression, which is a SlashExpression in which the lhs operand is known to return a singleton and the rhs operand is known to be an AxisExpression
  SimpleType | This interface represents a simple type, which may be a built-in simple type, or a user-defined simple type.
  SimpleTypeDefinition | A simple type definition holds all the information about a simpleType during the course of schema processing.
  SingleAtomicIterator<T extends AtomicValue> | SingletonIterator: an iterator over a sequence of zero or one values
  SingleEntryMap | A key and a corresponding value to be held in a Map.
  SingleItemFilter | A SingleItemFilter is an expression that selects zero or one items from a supplied sequence
  SingleNamespaceSchema | A schema (collection of schema components) that has an identifiable target namespace: typically the set of components derived from a single import or include.
  SingleNodeIterator | SingleNodeIterator: an iterator over a sequence of zero or one nodes
  SingletonAtomizer | A SingletonAtomizer combines the functions of an Atomizer and a CardinalityChecker: it is used to atomize a sequence of nodes, checking that the result of the atomization contains zero or one atomic values.
  SingletonAtomizerAdjunct | Watch factory class for a singleton atomizer
  SingletonAtomizerCompiler | Generate code for a SingletonAtomizer.
  SingletonAttributeMap | An implementation of AttributeMap for use when there is exactly one attribute
  SingletonCharacterClass | A character class represents a set of characters for regex matching purposes.
  SingletonClosure | A SingletonClosure represents a value that has not yet been evaluated: the value is represented by an expression, together with saved values of all the context variables that the expression depends on.
  SingletonIntersectExpression | This expression is equivalent to (A intersect B) in the case where A has cardinality zero-or-one.
  SingletonIntersectExpressionCompiler | Bytecode generation for an expression of the form (A intersect B) where A is a singleton
  SingletonIterator<T extends Item> | SingletonIterator: an iterator over a sequence of zero or one values
  SingularityPull | The "singularity" tuple stream delivers a single empty tuple.
  Sink | A Sink is a Receiver that discards all information passed to it
  SinkFeed | An ItemFeed that swallows (discards) all input passed to it
  SinkOutputter | An Outputter that swallows (discards) all input supplied to it
  SkipValidator | This class is a filter that passes all Receiver events through unchanged, except that it removes all type annotations from element and attribute nodes.
  SlashExpression | A slash expression is any expression using the binary slash operator "/".
  SlashExpressionCompiler | Generate bytecode for a call to a SlashExpression or an xsl:for-each instruction (These have the same run-time semantics)
  SlotManager | A SlotManager supports functions, templates, etc: specifically, any executable code that requires a stack frame containing local variables.
  SlotManagerEE |
  SmallAttributeMap | An implementation of AttributeMap suitable for small collections of attributes (typically, up to five).
  SnapshotFeed | This class provides streamed implementation of the snapshot() function
  SnapshotFn | XSLT 3.0 function snapshot().
  SnapshotFnStreamer | Generate streaming code for the snapshot() function
  SnapshotNode | This class represents a node within a tree produced by the snapshot() function, as a virtual copy of the relevant nodes in another tree.
  Sort_1 | This class implements the function fn:sort#1, which is a standard function in XPath 3.1
  Sort_1.ItemToBeSorted |
  Sort_2 | This class implements the function fn:sort#2, according to the new XPath 3.1 spec in bug 29792
  Sort_3 | This class implements the function fn:sort#2, which is a higher-order function in XPath 3.1 available only in Saxon-PE and above
  SortedGroupIterator | A SortedGroupIterator is a modified SortedIterator.
  SortedIterator | Class to do a sorted iteration
  SortExpression | Expression equivalent to the imaginary syntax expr sortby (sort-key)+
  SortExpressionAdjunct | Streaming code for sort expression.
  SortExpressionCompiler |
  SortKeyDefinition | A SortKeyDefinition defines one component of a sort key.
  SortKeyDefinitionList | The class represents a list of sort key definitions in major-to-minor sort key order.
  SortKeyEvaluator | Callback interface used to evaluate sort keys.
  SourceBinding | Helper class for xsl:variable and xsl:param elements.
  SourceBinding.BindingProperty |
  SourceDocument | Non-streamable implementation of the xsl:source-document instruction
  SourceResolver | This interface defines a SourceResolver.
  SpaceStrippedDocument | A SpaceStrippedDocument represents a view of a real Document in which selected whitespace text nodes are treated as having been stripped.
  SpaceStrippedNode | A StrippedNode is a view of a node, in a virtual tree that has whitespace text nodes stripped from it.
  SpaceStrippingRule | Interface for deciding whether a particular element is to have whitespace text nodes stripped
  SpecificFunctionType | An instance of this class represents a specific function item type, for example function(xs:int) as xs:boolean
  SQLClose | An sql:close element in the stylesheet.
  SQLColumn | An sql:column element in the stylesheet.
  SQLConnect | An sql:connect element in the stylesheet.
  SQLConnect.ConnectInstruction |
  SQLConnectFn | This class implements the sql:connect() extension function.
  SQLDelete | An sql:delete element in the stylesheet.
  SQLDeleteFn | This class implements the sql:delete() extension function.
  SQLElementFactory | Class SQLElementFactory.
  SQLExecute | An sql:execute element in the stylesheet.
  SQLExecuteFn | This class implements the sql:execute() extension function.
  SQLFunctionSet | The SQLFunctionSet is a set of Saxon vendor-supplied extension functions designed to enable access to SQL databases
  SQLInsert | An sql:insert element in the stylesheet.
  SQLInsertFn | This class implements the sql:insert() extension function.
  SQLPreparedQueryFn | This class implements the sql:prepared-query() extension function.
  SQLPreparedStatementFn | This class implements the sql:prepared-statement() extension function.
  SQLQuery | An sql:query element in the stylesheet.
  SQLQueryFn | This class implements the sql:query() extension function.
  SQLTable |
  SQLTableFn | This class implements the sql:table() extension function.
  SQLUpdate | An sql:update element in the stylesheet.
  SQLUpdateFn | This class implements the `sql:update()` extension function.
  SquareArrayConstructor | An expression that delivers a fixed size array whose members are the result of evaluating corresponding expressions: [a,b,c,d]
  SquareArrayConstructorCompiler | Generate bytecode for an SquareArrayConstructor expression.
  StackFrame | This class represents a stack frame holding details of the variables used in a function or in an XSLT template.
  StandardCollationURIResolver | StandardCollationURIResolver allows a Collation to be created given a URI starting with "http://saxon.sf.net/collation" followed by a set of query parameters.
  StandardCollectionFinder | Default implementation of the CollectionFinder interface.
  StandardDiagnostics | This class is an abstract superclass of classes such as the `StandardErrorListener` and `StandardInvalidityHandler`, and exists to provide common utility methods for these classes, and for similar user-written classes if required
  StandardEntityResolver | This class is an EntityResolver used to resolve references to common DTDs and entity files, using local copies provided with the Saxon product.
  StandardEnvironmentVariableResolver | Default implementation of the `EnvironmentVariableResolver`.
  StandardErrorHandler | A default implementation of the SAX ErrorHandler interface.
  StandardErrorListener | StandardErrorListener is the standard error handler for XSLT and XQuery processing errors, used if no other ErrorListener is nominated.
  StandardErrorReporter | StandardErrorReporter is the standard error handler for processing XSLT and XQuery static errors, used if no other error handler is nominated.
  StandardInvalidityHandler | This class `StandardInvalidityHandler`, despite its name, is not directly used by Saxon, and in particular it is NOT the default InvalidityHandler.
  StandardLogger | The default Logger used by Saxon on the Java platform.
  StandardModuleURIResolver | This class is the standard ModuleURIResolver used to implement the "import module" declaration in a Query Prolog.
  StandardNames | Well-known names used in XSLT processing.
  StandardObjectConverter | This class provides all the conversion methods used to convert data between XDM values and Java values in the XQJ API.
  StandardOutputResolver | This class defines the default OutputURIResolver.
  StandardResultDocumentResolver | This class defines the default ResultDocumentResolver.
  StandardSchemaResolver | The default schema resolver used when no other is requested
  StandardUnparsedTextResolver | Default implementation of the UnparsedTextURIResolver, used if no other implementation is nominated to the Configuration.
  StandardURIChecker | This class checks whether a string is a valid URI.
  StandardURIResolver | This class provides the service of converting a URI into an `Source`.
  Starting | This class supports the two extension functions saxon:items-from and saxon:items-after.
  Starting.ItemsAfter |
  Starting.ItemsFrom |
  StartsWith | Implements the fn:starts-with() function, with the collation already known
  StartsWithCompiler | Generate bytecode for a call on fn:starts-with or fn:ends-with, with a statically known collation
  State | A State is a dynamic state of the finite state machine.
  StatefulSystemFunction |
  StaticBaseUri | Implement the XPath function static-base-uri()
  StaticContext | A StaticContext contains the information needed while an expression or pattern is being parsed.
  StaticContextAccessor | A StaticContextAccessor is a function that takes no arguments, but operates implicitly on the static context.
  StaticContextAccessor.DefaultCollation | Implement the XPath function default-collation()
  StaticError | The StaticError interface is retained in Saxon 10.0 as a marker interface so that the methods `XsltCompiler.setErrorList(List)` and `XQueryCompiler.setErrorList(List)` continue to function.
  StaticFunctionCall | A call to a function that is known statically.
  StaticFunctionCallCompiler | Compiler for a static function call.
  StaticProperty | This class contains constants identifying dependencies that an XPath expression might have on its context.
  StaticQueryContext | StaticQueryContext contains information used to build a StaticContext for use when processing XQuery expressions.
  StaticQueryContextEE | A version of StaticQueryContext for Saxon-EE, that extends the capability by allowing compilation of library modules.
  StaticQueryContextFactory | Factory class for creating a customized instance of StaticQueryContext
  StaticQueryContextPE | A version of StaticQueryContext for Saxon-PE
  Statistics | Statistics on the size of TinyTree instances, kept so that the system can learn how much space to allocate to new trees
  StatisticsReporter | Generates statistics relating to a validation episode
  StaxBridge | This class implements the Saxon PullProvider API on top of a standard StAX parser (or any other StAX XMLStreamReader implementation)
  StAXResultHandler | StAxResultHandler is a helper class
  StAXResultHandlerImpl | StAxResultHandler is used to allow a transformation result to be supplied as a StAXResult.
  Step<T extends XdmItem> | A `Step` is a function that can be applied to an item to return a stream of items.
  SteppingNavigator | The SteppingNavigator is a utility class containing methods to assist with navigating a tree whose nodes implement the `SteppingNode` interface
  SteppingNavigator.DescendantAxisIterator<N extends SteppingNode<N>> | An iterator over the descendant or descendant-or-self axis
  SteppingNode<N extends SteppingNode> | This interface can be implemented by an implementation of NodeInfo to take advantage of a generic implementation of the descendant axis found in class `SteppingNavigator`
  Steps | This non-instantiable class provides a number of useful implementations of the `Step` interface, used to navigate XDM trees, typically as an argument to `XdmValue.select(net.sf.saxon.s9api.streams.Step<T>)`.
  Streamability | Supporting class for assessing the streamability of expressions.
  StreamableUserFunction | Represents a used-defined XSLT function whose declared streamability is other than "unclassified"
  StreamAvailable | This class implements the XSLT 3.0 function stream-available()
  StreamerMap |
  StreamFn | This class implements the saxon:stream() extension function.
  StreamingAdjunct | This abstract class supplements an `Expression` with methods used at compile-time to support streaming, by generating a `Watch` that allows the expression to be evaluated in push mode.
  StreamingFilterImpl | StreamingFilterImpl is an XMLFilter (a SAX2 filter) that performs a transformation taking a SAX stream as input and producing a SAX stream as output, using XSLT 3.0 streaming to process the source
  StreamingFunctionArgumentPattern | This is a special pattern that matches the node supplied as the first argument of a call to a streamable stylesheet function; it corresponds to the pattern match="$arg" where $arg is the first argument of the function.
  StreamingPatternMaker | Factory class to make a streaming pattern from an expression.
  StreamingSequenceWriter | A SequenceWriter that can be used on a streaming pipeline to direct the output of an operation to the next expression in the pipeline
  StreamingTransformerFactory | The is a customized JAXP TransformerFactory implementation for the enterprise edition of Saxon.
  StreamingTransformerImpl | Saxon implementation of the JAXP Transformer interface.
  StreamInstr | Implementation of the xsl:source-document (streamable="yes") instruction
  StreamWatch |
  StreamWriterToReceiver | This class implements the XmlStreamWriter interface, translating the events into Saxon Receiver events.
  String_1 | Implement XPath function string() with a single argument
  StringCollator | This interface represents a "collation" as defined in XPath, that is, a set of rules for comparing strings
  StringConverter | A `Converter` that accepts a string as input.
  StringConverter.StringToAnyURI | Converts string to anyURI
  StringConverter.StringToBase64Binary | Converts string to base64
  StringConverter.StringToBoolean | Converts a string to a boolean
  StringConverter.StringToDate | Converts a string to a date
  StringConverter.StringToDateTime | Converts a string to a dateTime
  StringConverter.StringToDateTimeStamp | Converts a string to a dateTimeStamp
  StringConverter.StringToDayTimeDuration | Converts a string to a dayTimeDuration
  StringConverter.StringToDecimal | Converts a string to an xs:decimal
  StringConverter.StringToDerivedStringSubtype | Converts from xs;string to a user-defined type derived from a built-in subtype of xs:string
  StringConverter.StringToDuration | Converts a string to a duration
  StringConverter.StringToFloat | Converts a string to xs:float
  StringConverter.StringToGDay | Converts a string to a gDay
  StringConverter.StringToGMonth | Converts a string to a gMonth
  StringConverter.StringToGMonthDay | Converts a string to a gMonthDay
  StringConverter.StringToGYear | Converts a string to a gYear
  StringConverter.StringToGYearMonth | Converts a string to a gYearMonth
  StringConverter.StringToHexBinary | Converts a string to hexBinary
  StringConverter.StringToInteger | Converts a string to an integer
  StringConverter.StringToIntegerSubtype | Converts a string to a built-in subtype of integer
  StringConverter.StringToLanguage | Converts from xs:string to xs:language
  StringConverter.StringToName | Converts from xs:string to xs:Name
  StringConverter.StringToNCName | Converts from xs:string to xs:NCName, xs:ID, xs:IDREF, or xs:ENTITY
  StringConverter.StringToNMTOKEN | Converts from xs:string to xs:NMTOKEN
  StringConverter.StringToNonStringDerivedType | Converter from string to a derived type (derived from a type other than xs:string), where the derived type needs to retain the original string for validating against lexical facets such as pattern.
  StringConverter.StringToNormalizedString | Converts from xs:string to xs:normalizedString
  StringConverter.StringToNotation | Converts String to NOTATION
  StringConverter.StringToQName | Converts String to QName
  StringConverter.StringToString | Converts from xs:string or xs:untypedAtomic to xs:String
  StringConverter.StringToStringSubtype | Converts from xs:string to a user-defined type derived directly from xs:string
  StringConverter.StringToTime | Converts a string to a time
  StringConverter.StringToToken | Converts from xs:string to xs:token
  StringConverter.StringToUnionConverter | Converter from string to plain union types
  StringConverter.StringToUntypedAtomic | Converts from xs:string or xs:untypedAtomic to xs:untypedAtomic
  StringConverter.StringToYearMonthDuration | Converts a string to a yearMonthDuration
  StringFnCompiler | Generate bytecode for evaluation of a call to the string() function
  StringFnStreamer | Streaming code to implement the XPath string() function
  StringJoin | fn:string-join(string* $sequence, string $separator)
  StringJoinCompiler |
  StringLength_1 | Implement the XPath string-length() function
  StringLengthCompiler | Generate bytecode for a call to the StringLength Function
  StringLiteral | Subclass of Literal used specifically for string literals, as this is a common case
  StringToBooleanCompiler | Generate code for a String to Boolean CastExpression
  StringToCodepoints | This class supports the function string-to-codepoints()
  StringToDouble | This class converts a string to an xs:double according to the rules in XML Schema 1.0
  StringToDouble11 | Convert a string to a double using the rules of XML Schema 1.1
  StringToDoubleCompiler | Generate code for a String to Double CastExpression
  StringToFloatCompiler | Generate code for a String to Float CastExpression
  StringToIntegerCompiler | Generate code for a String to Integer CastExpression
  StringToUntypedAtomicCompiler | Generate code for a String to Untyped Atomic CastExpression
  StringValue | An atomic value of type xs:string.
  StringValue.Builder |
  StringValue.CharacterIterator | CharacterIterator is used to iterate over the characters in a string, returning them as integers representing the Unicode code-point.
  StringValue.UnicodeCharacterIterator |
  StringValueFeed | This class is used when a streamed template requests evaluation of the string value of the nodes selected by a path expression, typically in response to an xsl:value-of instruction.
  StringValueGatherer | A StringValueGatherer is a Receiver that computes the string value of an element in streaming mode, by copying all the text nodes to a supplied receiver.
  Stripper | The RuleBasedStripper class performs whitespace stripping according to the rules of the xsl:strip-space and xsl:preserve-space instructions.
  Stripper.StripRuleTarget |
  StructuredQName | This class provides an economical representation of a QName triple (prefix, URI, and localname).
  StyleElement | Abstract superclass for all element nodes in the stylesheet.
  StyleElement.OnFailure |
  StyleNodeFactory | Class StyleNodeFactory.
  StyleNodeFactoryEE | Class StyleNodeFactoryEE: Subclass of StyleNodeFactory used for Saxon-EE.
  StyleNodeFactoryPE | Class StyleNodeFactoryPE: Subclass of StyleNodeFactory used for Saxon-PE.
  StylesheetCache | A cache of the stylesheets (as XsltExecutables) used in calls to the fn:transform function, in a stylesheet or query.
  StylesheetComponent | This interface is implemented by all top-level XSL elements that can contain local variable declarations.
  StylesheetFunctionLibrary | A StylesheetFunctionLibrary contains functions defined by the user in a stylesheet.
  StylesheetModule | A stylesheet module represents a module of a stylesheet.
  StylesheetPackage | A (compiled) stylesheet package.
  StylesheetPackageEE | Subclass of StylesheetPackage for Saxon-EE
  StylesheetSpaceStrippingRule | A whitespace stripping rule that strips whitespace according to the rules defined for XSLT stylesheets
  SubscriptExpression | A SubscriptExpression represents a FilterExpression of the form EXPR[n] where n is known to be singleton numeric and to be independent of the focus; it does not need to be constant
  SubscriptExpressionAdjunct | Streaming code for a subscript expression
  SubscriptExpressionCompiler | Bytecode generator for the saxon:item-at() function
  Subsequence_2 | Implements the XPath 2.0 subsequence() function with two arguments
  Subsequence_3 | Implements the XPath 2.0 subsequence() function with three arguments
  SubsequenceIterator | A SubsequenceIterator selects a subsequence of a sequence
  SubsequenceStreamer | Generate streaming code for a subsequence() function call.
  SubsequenceStreamer.SubsequenceFilter |
  Substring | This class implements the XPath substring() function
  SubstringAfter | Implements the fn:substring-after() function with the collation already known
  SubstringAfterCompiler | Generate bytecode for evaluation of a call to the substring-after() function
  SubstringBefore | Implements the fn:substring-before() function with the collation already known
  SubstringBeforeCompiler | Generate bytecode for evaluation of a call to the substring-before() function
  SubstringCompiler | Generate bytecode for evaluation of a call to the substring() function
  SubstringMatcher | This interface is implemented by a collation that is capable of supporting the XPath functions that require matching of a substring: namely contains(), starts-with, ends-with, substring-before, and substring-after.
  SuffixState | The state of a finite state machine that is processing "suffix" open content.
  Sum | Implementation of the fn:sum function
  SumCompiler | Generate bytecode for the sum function
  SuperId | The XPath id() or element-with-id() function XPath 2.0 version: accepts any sequence as the first parameter; each item in the sequence is taken as an IDREFS value, that is, a space-separated list of ID values.
  SuperId.ElementWithId |
  SuperId.Id |
  SuppliedParameterReference | Supplied parameter reference: this is an internal expression used to refer to the value of the n'th parameter supplied on a template call or a call to an inline function.
  SuppliedParameterReferenceCompiler | Compiler for LocalParam instructions in XSLT (representing an xsl:param in a template)
  Sweep | The posture of an expression defines the relationship of the result to a streamed input document, as defined in the XSLT 3.0 specification.
  SwitchAdjunct | Streaming code to implement a switch expression, which results from optimizing a choose where all the branches have similar test conditions.
  SwitchExpression | An optimized Choose expression in which all the branches are tests of the same expression for equality with some value.
  SwitchExpression.SwitchCaseInfo | Data structure used for holding details of a switch expression
  SwitchExpressionCompiler | compiler for switch expression in XQuery 3.0, whether explicitly written as such, or the result of optimizing an xsl:choose or a sequence of if/then/elseif/then expressions
  SymbolicName | The symbolic name of a component consists of the component kind (e.g.
  SymbolicName.F | Subclass of SymbolicName used for function names (including the arity)
  SymbolSpace | This class holds constants used to identify the various symbol spaces defined in XML Schema: element declarations, attribute declarations, types, groups, and so on.
  SystemFunction | Abstract superclass for calls to functions in the standard function library
  SystemFunctionCall | A call to a system-defined function (specifically, a function implemented as an instance of `SystemFunction`)
  SystemFunctionCall.Optimized | Subclass representing a system function call that has been optimized; this overrides the optimize() method to do nothing, thus ensuring that optimization converges.
  SystemFunctionWithBoundContextItem | A Callable that wraps another Callable and a Dynamic Context, in effect acting as a closure that executes the original callable with a saved context.
  SystemIdMap | System IDs are not held in nodes in the tree, because they are usually the same for a whole document.
  SystemLogger | An implementation of Saxon's `Logger` interface that writes all messages through to a supplied `java.util.logging.Logger`.
  SystemProperty | Implementation of the XSLT system-property() function
  TabulateMaps | Handler for a saxon:tabulate-maps instruction in an XSLT stylesheet.
  TailCall | Interface representing a Tail Call.
  TailCallLoop | A TailCallLoop wraps the body of a function that contains tail-recursive function calls.
  TailCallLoop.TailCallComponent |
  TailCallLoop.TailCallFunction |
  TailCallLoop.TailCallInfo |
  TailCallLoopCompiler |
  TailCallReturner | This interface represents an expression that is capable of being processed leaving tail calls for the calling instruction to deal with.
  TailExpression | A TailExpression represents a FilterExpression of the form `EXPR[position() > n]` Here n is usually 2, but we allow other values
  TailExpressionAdjunct |
  TailExpressionCompiler | Generate bytecode for evaluation of a TailExpression
  TailFn | This class implements the function fn:tail(), which is a standard function in XPath 3.0
  TailIterator | TailIterator iterates over a base sequence starting at an element other than the first.
  Talker | Interface for a simple line-based question/answer dialog with the user
  TeeDestination | A TeeDestination allows writing to two destinations at once.
  TeeOutputter | TeeOutputter: a SequenceReceiver that duplicates received events to two different destinations
  TemplateRule | The runtime object corresponding to an xsl:template element in the stylesheet.
  TemplateRuleEE | Saxon-EE version of the TemplateRule class, with added code for JIT compilation and streamability analysis
  TemplateRuleInitializer | A TemplateRuleInitializer is used to prepare a template rule for execution the first time that its match pattern is matched, in cases where JIT template rule compilation is in force.
  TemplatesHandlerImpl | TemplatesHandlerImpl implements the javax.xml.transform.sax.TemplatesHandler interface.
  TemplatesImpl | Saxon implementation of the JAXP Templates interface.
  Term | Represents a Term in a content model as defined by XML Schema.
  TerminationException | An exception thrown by xsl:message terminate="yes".
  Terminator | A Terminator provides a method that can be called to cause early termination of a streaming pass over an input document, in the case where no more information from the document is needed.
  TextComparer | A Comparer used for comparing sort keys when data-type="text".
  TEXTEmitter | This class generates TEXT output
  TextFragmentValue | This class represents a temporary tree whose root document node owns a single text node.
  TextImpl | A node in the XML parse tree representing character content.
  TextLinesIterator | An iterator that iterates over a file line by line, returning each line as a `StringValue`
  TextOnlyCopyRuleSet | The built-in rule set used for 1.0 and 2.0, which for document and element nodes does an apply-templates to children, and for text nodes and attribute nodes copies the node.
  TextOverAttrInfo | This class represents a DOM text node that is the child of a DOM attribute node.
  TextOverNodeInfo | This class is an implementation of the DOM Text and Comment interfaces that wraps a Saxon NodeInfo representation of a text or comment node.
  TextValueTemplateContext | Define the static context for expressions appearing between curly braces in a text value template.
  TextValueTemplateNode | A text node in an XSLT 3.0 stylesheet that may or may not contain a text value template
  ThreadManagerEE | The ThreadManager is used to manage asynchronous execution of xsl:result-document instructions in Saxon-EE.
  Timer | Utility class for collecting and reporting timing information, used only under diagnostic control
  TimestampFn | This class implements the saxon:timestamp() function which returns the date/time at the moment of execution
  TimeValue | A value of type xs:time
  TimingCodeInjector | A code injector that wraps the body of a template or function in a TraceExpression, which causes the TimingTraceListener to be notified at the start and end of the function/template evaluation
  TimingTraceListener | A trace listener that records timing information for templates and functions, outputting this information as an HTML report to a specified destination when the transformation completes.
  TinyAttributeImpl | A node in the XML parse tree representing an attribute.
  TinyAttributeMap | An implementation of the AttributeMap interface based directly on the TinyTree data structure.
  TinyBuilder | The TinyBuilder class is responsible for taking a stream of SAX events and constructing a Document tree, using the "TinyTree" implementation.
  TinyBuilderCondensed | Variant of the TinyBuilder to create a tiny tree in which multiple text nodes or attribute nodes sharing the same string value economize on space by only holding the value once.
  TinyBuilderMonitor | Monitor construction of a TinyTree.
  TinyDocumentImpl | A node in the XML parse tree representing the Document itself (or equivalently, the root node of the Document).
  TinyElementImpl | A node in the XML parse tree representing an XML element.
  TinyNodeImpl | A node in a TinyTree representing an XML element, character content, or attribute.
  TinyParentNodeImpl | TinyParentNodeImpl is an implementation of a non-leaf node (specifically, an Element node or a Document node)
  TinyTextImpl | A node in the XML parse tree representing character content
  TinyTextualElement | An element node in the TinyTree that has no attributes or namespace declarations and that has a single text node child.
  TinyTree | A data structure to hold the contents of a tree.
  ToBooleanCompiler | Abstract superclass for expression compilers that handle boolean expressions, that is, expressions that return a boolean result.
  ToItemCompiler | Abstract superclass for expression compilers that handle expressions returning a single item (or nothing).
  ToIteratorCompiler | Abstract superclass for expression compilers of expressions that return a general sequence.
  Token | This class holds static constants and methods defining the lexical tokens used in XPath and XQuery, and associated keywords.
  Tokenize_1 | This class implements the single-argument tokenize() function introduced in XPath 3.1
  Tokenize_3 | This class implements the 3-argument tokenize() function for regular expression matching.
  Tokenizer | Tokenizer for expressions and inputs.
  TokenMatchOperand | Given an expression, this characteristic evaluates the set of hash keys corresponding to the whitespace-separated tokens in the string values of the items selected by that expression.
  ToPushCompiler |
  ToStringCompiler | Generate bytecode for evaluation of expressions that return a single string (or an empty sequence)
  TotalDigitsFacet | Eepresents the value of the totalDigits facet
  Trace | This class supports the XPath 2.0 function trace().
  Traceable | A construct whose execution can be notified to a TraceListener.
  TraceableComponent | A construct whose execution can be notified to a TraceListener.
  TraceClause | A "trace" clause in a FLWOR expression, added by a TraceCodeInjector for diagnostic tracing, debugging, profiling or similar purposes.
  TraceClausePull | This class represents the tuple stream delivered as the output of a trace clause in a FLWOR expression.
  TraceClausePush | This class represents the tuple stream delivered as the output of a trace clause in a FLWOR expression.
  TraceCodeInjector | A code injector that wraps every expression (other than a literal) in a TraceExpression, which causes a TraceListener to be notified when the expression is evaluated
  TraceEventMulticaster | A class which implements efficient and thread-safe multi-cast event dispatching for the TraceListener evants.
  TraceExprAdjunct | Implement streaming of the trace instruction injected into the code when compiled with tracing enabled.
  TraceExpression | A wrapper expression used to trace expressions in XSLT and XQuery.
  TraceExpressionCompiler |
  TraceListener | This interface defines methods that are called by Saxon during the execution of a stylesheet, if tracing is switched on.
  TraceStreamer | Implement streaming of fn:trace instruction.
  TracingFilter | A filter that can be inserted into a Receiver pipeline to trace the events that pass through.
  Transform | This is a synonym of the command line interface net.sf.saxon.Transform for running XSLT transformations.
  Transform | This Transform class is the command-line entry point to the Saxon XSLT Processor.
  TransformerFactoryImpl | A TransformerFactory instance can be used to create Transformer and Template objects.
  TransformerHandlerImpl | TransformerHandlerImpl implements the javax.xml.transform.sax.TransformerHandler interface.
  TransformerImpl | Saxon implementation of the JAXP Transformer interface.
  TransformerReceiver | TransformerReceiver is similar in concept to the JAXP TransformerHandler, except that it implements Saxon's Receiver interface rather than the standard SAX2 interface.
  TransformFn | This class implements the `saxon:transform()` extension function (not to be confused with the standard `fn:transform()` function in XPath 3.1)
  TransformFn | This class implements the function transform(), which is a standard function in XPath 3.1
  Translate | Implement the XPath translate() function
  TranslateCompiler | Generate bytecode for evaluation of a call to the translate() function
  TransmissionAdjunct | A subclass of StreamingAdjunct used for expressions that have a sequence-valued operand with usage transmission.
  TreatExpression | Treat Expression: implements "treat as data-type ( expression )".
  TreatFn | This class supports the XPath 2.0 functions exactly-one(), one-or-more(), zero-or-one().
  TreatFn.ExactlyOne |
  TreatFn.OneOrMore |
  TreatFn.ZeroOrOne |
  TreatFnStreamer | Generate streaming code for a "treat" function call (for example one-or-more)
  TreeInfo | This interface represents information about a tree as a whole.
  TreeModel | A TreeModel represents an implementation of the Saxon NodeInfo interface, which itself is essentially an implementation of the XDM model defined in W3C specifications (except that Saxon's NodeInfo understands the 13 XPath axes, rather than merely supporting parent and child properties).
  TreeReceiver | A TreeReceiver acts as a bridge between a SequenceReceiver, which can receive events for constructing any kind of sequence, and an ordinary Receiver, which only handles events relating to the building of trees.
  TreeStatistics |
  TreeWalker | This implementation of the Saxon pull interface starts from any NodeInfo, and returns the events corresponding to that node and its descendants (including their attributes and namespaces).
  Trigger | A Trigger is a Watch that contains a pattern used for matching streamed nodes, and a WatchAction which is invoked when a matching node is found.
  TryCatch | This class implements a try/catch expression.
  TryCatch.CatchClause |
  TryCatchAdjunct | Streaming code for a try/catch expression
  TryCatchAdjunct.TryCatchFeed |
  Tuple | A tuple, as it appears in an XQuery tuple stream handled by extended FLWOR expressions.
  Tuple2<T1,​T2> |
  TupleExpression | A tuple expression is an expression that returns a tuple.
  TupleItemType | An instance of this class represents a specific tuple item type, for example tuple(x as xs:double, y as element(employee)).
  TuplePull | Abtract class representing a tuple stream (used to evaluate a FLWOR expression) in pull mode (where the consumer of tuples activates the provider of those tuples)
  TuplePush | Abtract class representing a tuple stream (used to evaluate a FLWOR expression) in push mode (where the provider of tuples activates the consumer of those tuples)
  TupleType | An instance of this class represents a specific tuple item type, for example tuple(x as xs:double, y as element(employee)).
  Type | This class contains static information about types and methods for constructing type codes.
  TypeAliasManager | Manager for saxon:type-alias declarations in a stylesheet.
  TypeAliasManagerPE | Manager for saxon:type-alias declarations in a stylesheet.
  TypeAlternative | A TypeAlternative schema component (See XML Schema 1.1 Part 1 Working Draft)
  TypeAvailable | This class supports the XSLT fn:type-available() function.
  TypeChecker | This class provides Saxon's type checking capability.
  TypeChecker10 | This class provides type checking capability with XPath 1.0 backwards compatibility enabled.
  TypeCheckingFilter | A filter on the push pipeline that performs type checking, both of the item type and the cardinality.
  TypedContentHandler | This class is an extension of ContentHandlerProxy that provides access to type information, using the DOM Level 3 TypeInfo interfaces.
  TypedValueFeed | This class is used when a streamed template requests evaluation of the typed value of the nodes selected by a path expression.
  TypeHierarchy | This class exists to provide answers to questions about the type hierarchy.
  TypeHierarchyEE | Refinement of the TypeHierarchy class to handle function items and schema-aware types such as schema-element(A).
  TypeInfoImpl | This class implements the DOM TypeInfo interface as a wrapper over the Saxon SchemaType interface.
  TypeReference | A reference to a simple or complex type
  TypeStrippedDocument | A TypeStrippedDocument represents a view of a real Document in which all nodes are untyped
  TypeStrippedNode | A TypeStrippedNode is a view of a node, in a virtual tree that has type annotations stripped from it.
  UcaCollationKeyUsingIcu | This class is an implementation of Saxon collation keys based on the functionality of collation keys supplied by the ICU library.
  UcaCollatorUsingIcu | This class represents a collation (for comparing strings) implemented using the ICU library.
  UcaCollatorUsingIcu.Strength |
  UcaCollatorUsingJava | This class implements (an approximation to) the UCA Collation Algorithm relying solely on the built-in Java support (that is, without using the ICU library).
  UnaryExpression | Unary Expression: an expression taking a single operand expression
  UnboundFunctionLibrary | An UnboundFunctionLibrary is not a real function library; rather, it is used to keep track of function calls that cannot yet be bound to a known declared function, but will have to be bound when all user-declared functions are available.
  UncheckedXPathException | When implementing certain interfaces Saxon is not able to throw a checked exception because the interface definition does not allow it.
  UncommittedSerializer | This class is used when the decision on which serialization method to use has to be delayed until the first element is read.
  UndeclaredVariable | An UndeclaredVariable object is created when a reference is encountered to a variable that has not yet been declared.
  UnfailingIterator | A SequenceIterator is used to iterate over a sequence.
  UnfailingPullProvider | PullProvider is Saxon's pull-based interface for reading XML documents and XDM sequences.
  UnicodeBlocks | This class provides knowledge of the names and contents of Unicode character blocks, as referenced using the \p{IsXXXXX} construct in a regular expression.
  UnicodeNormalizer | UnicodeNormalizer: This ProxyReceiver performs unicode normalization on the contents of attribute and text nodes.
  UnicodeString | An abstract class that efficiently handles Unicode strings including non-BMP characters; it has three subclasses, respectively handling strings whose maximum character code is 255, 65535, or 1114111.
  UnionCastableFunction | Function to test castability to a union type
  UnionConstructorFunction | Function to perform a cast to a union type
  UnionEnumeration | An enumeration representing a nodeset that is a union of two other NodeSets.
  UnionIterator | A multi-way union delivering the sorted results obtained from a number of sorted input iterators
  UnionPattern | A pattern formed as the union (or) of two other patterns
  UnionQNameTest | A QNameTest that is the union of a number of supplied QNameTests
  UnionType | Interface representing a union type.
  Unique | This class represents an xs:unique identity constraint
  UniversalPattern | The UniversalPattern matches everything
  UnknownElement | An unknown element in an XML Schema document.
  UnknownResource | The class is an implementation of the generic Resource object (typically an item in a collection) representing a resource whose type is not yet known - typically because it uses an unregistered file extension.
  Unordered | XPath 2.0 unordered() function
  UnparsedEntity | Implements the unparsed-entity-uri() function defined in XSLT 1.0 and the unparsed-entity-public-id() function defined in XSLT 2.0
  UnparsedEntity | This class is used to represent unparsed entities in the PullProvider interface
  UnparsedEntity.UnparsedEntityPublicId |
  UnparsedEntity.UnparsedEntityUri |
  UnparsedText | Implementation of fn:unparsed-text() - with one argument or two
  UnparsedTextAvailable |
  UnparsedTextFunction | Abstract superclass containing common code supporting the functions unparsed-text(), unparsed-text-lines(), and unparsed-text-available()
  UnparsedTextIterator | Class UnparsedTextIterator, iterates over a file line by line
  UnparsedTextLines |
  UnparsedTextResource | This class implements th interface Resource.
  UnparsedTextURIResolver | An UnparsedTextURIResolver accepts an absolute URI and optionally an encoding name as input, and returns a Reader as its result.
  UnprefixedElementMatchingPolicy | An enumeration defining possible strategies for resolving unprefixed element names appearing as name tests in the steps of a path expression or XSLT match pattern
  UnresolvedXQueryFunctionItem |
  Untyped | This class has a singleton instance which represents the complex type xdt:untyped, used for elements that have not been validated.
  UntypedAtomicValue | An Untyped Atomic value.
  UntypedAtomizingIterator | AtomizingIterator returns the atomization of an underlying sequence supplied as an iterator.
  UntypedNumericComparer | A specialist comparer that implements the rules for comparing an untypedAtomic value (always the first operand) to a numeric value (always the second operand)
  UntypedSequenceConverter | An UntypedSequenceConverter is an expression that performs a cast on each member of a supplied sequence that is an untypedAtomic value, while leaving other items unchanged
  UntypedSequenceConverter.UntypedConverter | A Converter that converts untyped atomic values to the required type, while leaving other values unchanged
  UpdateAgent | An UpdateAgent is a callback class that is called to handle a document after it has been updated.
  UpdateParser | Parser utility methods for the XQuery Update extensions
  UpperCase | This class implements the fn:upper-case() function
  URIChecker | This interface defines a method for checking whether a string is considered to be a valid URI.
  UriCollection | Implement the fn:uri-collection() function (new in XQuery 3.0/XSLT 3.0).
  URIQueryParameters | A set of query parameters on a URI passed to the collection() or document() function
  URIQueryParameters.RegexFilter | A FilenameFilter that tests file names against a regular expression
  URIResourceResolver | This class implements the JAXP URIResolver as a wrapper around a DOM Level 3 LSResourceResolver.
  UseAttributeSet | This instruction corresponds to a single QName appearing within a use-attribute-sets attribute on a literal result element, xsl:element, or xsl:copy instruction.
  UseAttributeSetAdjunct |
  UseAttributeSetCompiler | Generate bytecode for the XSLT use-attribute-sets pseudo-instruction.
  UsePack | Describes an xsl:use-package requirement from within a package, in terms of a name and a set of version ranges
  UserAtomicType | An object belonging to this class represents an atomic type: either a built-in atomic type, or a user-defined atomic type.
  UserComplexType | A user-defined complex type (that is, any complex type other than xs:anyType)
  UserDefinedType | This class represents a user-defined simple type or complex type as defined in XML Schema.
  UserFunction | This object represents the compiled form of a user-written function (the source can be either an XSLT stylesheet function or an XQuery function).
  UserFunction.Determinism |
  UserFunctionCall | This class represents a call to a user-defined function in the stylesheet or query.
  UserFunctionCallAdjunct | Handle streaming for calls to user-defined functions Used only for XSLT streaming capability.
  UserFunctionCallCompiler | Generate bytecode for evaluation of an UserFunctionCall
  UserFunctionParameter | Run-time object representing a formal argument to a user-defined function
  UserFunctionReference | A UserFunctionReference is an expression in the form local:f#1 where local:f is a user-defined function.
  UserFunctionReference.BoundUserFunction | A BoundUserFunction represents a user-defined function seen as a component.
  UserFunctionResolvable | A reference to a function; typically a forwards reference to a user-defined function in XQuery that has not yet been compiled.
  UserListType | Represents a SimpleType that is a list of a given SimpleType, known as its itemType.
  UserSchemaComponent | A SchemaComponent is an object in a schema.
  UserSimpleType | This class represents a used-defined simple type, as defined in the XML Schema specification.
  UserUnionType | A class that represents the XML Schema simple-type with variety union.
  UseWhen30FunctionSet | Function signatures (and pointers to implementations) of the functions available for use in static expressions (including use-when expressions) in XSLT 3.0 stylesheets
  UseWhenFilter | This is a filter inserted into the input pipeline for processing stylesheet modules, whose task is to evaluate use-when expressions and discard those parts of the stylesheet module for which the use-when attribute evaluates to false.
  UseWhenStaticContext | This class implements the static context used for evaluating use-when and other static expressions in XSLT 3.0 A new instance of this class is created for each use-when expression encountered; there are therefore no issues with reusability.
  UTF16CharacterSet | A class to hold some static constants and methods associated with processing UTF16 and surrogate pairs
  UTF8CharacterSet | This class defines properties of the UTF-8 character set
  UTF8Writer | Specialized buffering UTF-8 writer.
  UType | A UType is a union of primitive (atomic, node, or function) item types.
  Validate | This Validate class provides a command line interface that allows validation of a source document against a schema, and/or checking that a source schema is a valid schema.
  ValidateFn | This class implements the saxon:validate() extension function.
  ValidatingFilter | This class is used for a filter on the validation pipeline.
  ValidatingInstruction | Interface implemented by instructions that have validation and type attributes
  ValidatingReader | This class is a Saxon implementation of XMLReader that performs schema validation using Saxon's schema processor.
  Validation | This class contains constants and static methods to manipulate the validation property of a type.
  ValidationContext | This class defines information about a validation episode
  ValidationException | This exception indicates a failure when validating an instance against a type defined in a schema.
  ValidationFailure | This exception indicates a failure when validating an instance against a type defined in a schema.
  ValidationMode | Enumeration class defining different schema validation (or construction) modes
  ValidationParams | This class represents a collection of parameter values for use in schema validation; it defines values for the parameters declared using the saxon:param XSD extension.
  ValidationStack | This class manages the receivers that do element content validation.
  ValidationStatistics | Class for collection validation statistics produced via s9api processing
  ValidationStatisticsRecipient | Defines a class that is notified of validation statistics at the end of a validation episode
  ValidatorHandlerImpl | The is the Saxon implementation of the JAXP 1.3 ValidatorHandler interface.
  ValidatorImpl | This class in the Saxon implementation of the JAXP 1.3 Validator "interface" (which is actually defined as an abstract class).
  ValidatorImpl.InvalidityHandlerWrappingErrorHandler | Interface for reporting validation errors found during validation of an instance document against a schema.
  ValueComparison | ValueComparison: a boolean expression that compares two atomic values for equals, not-equals, greater-than or less-than.
  ValueComparisonCompiler | Generate code for a ValueComparison
  ValueConstraint | A value constraint represents the default or fixed value of an element declaration, attribute declaration, or attribute use
  ValueConstraint.Variety |
  ValueOf | An xsl:value-of element in the stylesheet.
  ValueOfCompiler | Generate code for a ValueOf instruction
  ValueRangeFacet | Represents any of the facets minInclusive, maxInclusive, minExclusive, maxExclusive
  ValueTailIterator | `ValueTailIterator` iterates over a base sequence starting at an element other than the first.
  Valve | A Valve is a general-purpose component for use in a pipeline of receivers.
  VariableReference | Variable reference: a reference to a variable.
  VariableReferenceAdjunct |
  VariableReferenceCompiler | Generate bytecode for evaluation of a VariableReference
  VendorFunctionSetEE | The VendorFunctionLibraryEE represents additions to the set of Saxon vendor-supplied extension functions that are available only with the Saxon-EE edition
  VendorFunctionSetHE | Implementation of vendor functions in the Saxon namespace, available in Saxon-HE because they are used internally.
  VendorFunctionSetHE.DynamicErrorInfoFn | Implement saxon:dynamic-error-info
  VendorFunctionSetHE.HasLocalNamespaces | Implement saxon:has-local-namespaces.
  VendorFunctionSetHE.HasUniformNamespaces | Implement saxon:has-uniform-namespaces.
  VendorFunctionSetHE.IsWholeNumberFn | Implement saxon:is-whole-number
  VendorFunctionSetPE | The VendorFunctionLibraryPE represents additions to the set of Saxon vendor-supplied extension functions that are available only with the Saxon-PE and Saxon-EE editions
  VennExpression | An expression representing a nodeset that is a union, difference, or intersection of two other NodeSets
  VennExpressionAdjunct |
  VennExpressionCompiler |
  VennPattern | Abstract pattern formed as the union, intersection, or difference of two other patterns; concrete subclasses are used for the different operators
  Verifier | A helper class for EnterpriseConfiguration that handles license keys as issued for the Java platform.
  Version | The Version class holds the SAXON version information.
  VersionControlFilter | This is a filter inserted into the input pipeline for processing schema documents, whose task is to examine attributes such as vc:maxVersion and discard those parts of the schema document that are to be ignored because of those attributes.
  VersionedPackageName | This class represents the combination of an XSLT package name (that is, a URI) and a version number
  VirtualAccumulatorData | Holds the values of an accumulator function for a virtual copy of a document (where the accumulator values are copies of those on the underlying document)
  VirtualCopy | This class represents a node that is a virtual copy of another node: that is, it behaves as a node that's the same as another node, but has different identity.
  VirtualNode | This interface is implemented by NodeInfo implementations that act as wrappers on some underlying tree.
  VirtualTreeInfo | Implementation of TreeInfo for a Virtual Copy tree
  VirtualUntypedCopy | This class represents a virtual copy of a node with type annotations stripped
  Visibility | Enumeration class giving the different visibility levels defined for components in XSLT 3.0
  VisibilityProvenance | Indicates where the visibility property of a component came from
  Watch | A Watch represents a class that is interested in looking at nodes passing down a push pipeline.
  WatchMaker | A WatchMaker is a factory class for creating a `Watch`.
  WatchManager | This class sits on a push pipeline and evaluates the passing element and attribute nodes.
  WatchManager.GroupingScope |
  WhereClause | A "where" clause in a FLWOR expression
  WhereClausePull | This class represents the tuple stream delivered as the output of a where clause in a FLWOR expression: that is, it returns all the tuples in its input stream that satisfy a specified predicate.
  WhereClausePush | This class represents the tuple stream delivered as the output of a where clause in a FLWOR expression: that is, it supplies all the tuples in its input stream that satisfy a specified predicate.
  WherePopulated | A compiled xsl:where-populated instruction (formerly xsl:conditional-content).
  WherePopulatedAdjunct | Generate streaming code for an xsl:where-populated instruction.
  WherePopulatedOutputter | This class acts as a filter on a push pipeline, allowing through only those items that are deemed non-empty according to the rules of the xsl:where-populated instruction.
  While | Handler for saxon:while elements in stylesheet.
  Whitespace | This class provides helper methods and constants for handling whitespace
  Whitespace.Tokenizer | An iterator that splits a string on whitespace boundaries, corresponding to the XPath 3.1 function tokenize#1
  WhitespaceFacet | Represents a whitespace facet on a schema-defined simple type
  WhitespaceStrippingPolicy | WhitespaceStrippingPolicy is class defining the possible policies for handling whitespace text nodes in a source document.
  WhitespaceTextImpl | A node in the XML parse tree representing a text node with compressed whitespace content
  Wildcard | A class that represents an XML Schema Wildcard.
  WindowClause | Implements an XQuery 3.0 sliding or tumbling window clause within a FLWOR expression
  WindowClause.Window | Information about a window: the items making up the window, as well as the variables relating to the start and end of the window, and the status of the winoow in relation to the processing of the current input sequence.
  WindowClausePull | Implement a sliding or tumbling window clause of a FLWOR expression in tuple-pull mode.
  WindowClausePush | Implement a sliding or tumbling window clause of a FLWOR expression in tuple-push mode.
  WithParam | An object derived from a xsl:with-param element in the stylesheet.
  WithPedigree | The saxon:with-pedigree function, new in Saxon 9.9.
  WrappingFunction | Callback to create a VirtualNode that wraps a given NodeInfo
  WrappingIterator | A WrappingIterator delivers wrappers for the nodes delivered by its underlying iterator.
  XdmArray | An array in the XDM data model.
  XdmAtomicValue | The class XdmAtomicValue represents an item in an XPath 2.0 sequence that is an atomic value.
  XdmCollectors | This class contains a number of static methods that deliver implementations of the `Collector` interface suitable for use with streams processing XDM nodes and other items.
  XdmCollectors.MultipleItemException | Unchecked exception that occurs when a collector method such as `XdmCollectors.asAtomic()` or `XdmCollectors.asOptionalNode()` is called, and the sequence contains more than one item.
  XdmDestination | An `XdmDestination` is a `Destination` in which an `XdmNode` is constructed to hold the output of a query or transformation: that is, a tree using Saxon's implementation of the XDM data model
  XdmEmptySequence | The class `XdmEmptySequence` represents an empty sequence in the XDM Data Model.
  XdmExternalObject | The class XdmExternalObject represents an XDM item that wraps an external (Java or .NET) object.
  XdmFunctionItem | The class XdmFunctionItem represents a function item
  XdmItem | The class XdmItem represents an item in a sequence, as defined by the XDM data model.
  XdmMap | A map in the XDM data model.
  XdmNode | This class represents a node in the XDM data model.
  XdmNodeKind | Enumeration class defining the seven kinds of node defined in the XDM model
  XdmSequenceIterator<T extends XdmItem> | An iterator over an XPath sequence.
  XdmStream<T extends XdmItem> | XdmStream extends the capabilities of the standard JDK `Stream`.
  XdmValue | A value in the XDM data model.
  XHTML1Emitter | XHTMLEmitter is an Emitter that generates XHTML 1 output.
  XHTML5Emitter | XHTML5Emitter is an Emitter that generates XHTML 5 output.
  XHTMLPrefixRemover | Filter to change elements in the XHTML, SVG, or MathML namespaces so they have no prefix (that is, to make these the default namespace).
  XHTMLURIEscaper | This class performs URI escaping for the XHTML output method.
  XML10ContentChecker | This class is used on the serialization pipeline to check that the document conforms to XML 1.0 rules.
  XmlCatalogResolver | Provides the interface to the Apache catalog resolver.
  XMLCharacterData | This module contains data regarding the classification of characters in XML 1.0 and XML 1.1, and a number of interrogative methods to support queries on this data.
  XMLEmitter | XMLEmitter is an Emitter that generates XML output to a specified destination.
  XMLIndenter | XMLIndenter: This ProxyReceiver indents elements, by adding character data where appropriate.
  XMLIndenterPE | XMLIndenter with extra functionality for Saxon-PE and Saxon-EE
  XMLNamespaceSchema | This module constructs synthetically (that is, without reading an XML schema document) the schema components for the XML namespace
  XmlProcessingAbort | An unchecked exception, triggered when a user-supplied `ErrorReporter` requests that processing should be aborted
  XmlProcessingError | The XmlProcessingError class contains information about an error detected during compilation or execution of a stylesheet, query, XPath expression, or schema
  XmlProcessingException | The XmlProcessingException class is a concrete implementation of the `XmlProcessingError` interface that wraps an `XPathException` object.
  XmlProcessingIncident | The XmlProcessingIncident class is a concrete implementation of the `XmlProcessingError` interface that holds all the required information internally.
  XmlResource | The class is an implementation of the generic Resource object (typically an item in a collection) representing an XML document
  XMLStreamWriterDestination | XMLStreamWriterDestination is a s9api `Destination` that writes output to a supplied XMLStreamWriter
  XMLToJsonFn | Implement the XML to JSON conversion as a built-in function - fn:xml-to-json()
  XmlToJsonFnStreamer | Streaming code for the xml-to-json() function
  XOMDocumentWrapper | The root node of an XPath tree.
  XOMNodeWrapper | A node in the XML parse tree representing an XML element, character content, or attribute.
  XOMObjectModel | This interface must be implemented by any third-party object model that can be wrapped with a wrapper that implements the Saxon Object Model (the NodeInfo interface).
  XomUriResolver | This class is a URI resolver that loads an XML document found at the relevant URI and builds a XOM tree from it; the XOM tree is then returned as a source object.
  XOMWriter | XOMWriter is a Receiver that constructs a XOM document from the stream of events
  XPath20FunctionSet | Function signatures (and pointers to implementations) of the functions defined in XPath 2.0
  XPath30FunctionSet | Function signatures (and pointers to implementations) of the functions defined in XPath 3.0 without the Higher-Order-Functions feature
  XPath31FunctionSet | Function signatures (and pointers to implementations) of the functions defined in XPath 3.1 without the Higher-Order-Functions feature
  XPathCompiler | An `XPathCompiler` object allows XPath queries to be compiled.
  XPathContext | This class represents a context in which an XPath expression is evaluated.
  XPathContextMajor | This class represents a "major context" in which an XPath expression is evaluated: a "major context" object allows all aspects of the dynamic context to change, whereas a "minor context" only allows changes to the focus and the destination for push output.
  XPathContextMajor.ThreadManager | The ThreadManager is used to manage asynchronous execution of xsl:result-document instructions in Saxon-EE.
  XPathContextMinor | This class represents a minor change in the dynamic context in which an XPath expression is evaluated: a "major context" object allows all aspects of the dynamic context to change, whereas a "minor context" only allows changes to the focus and the destination for push output.
  XPathContextMinor.LastValue | Container for cached value of the last() function.
  XPathDynamicContext | This object represents the dynamic XPath execution context for use in the free-standing Saxon XPath API.
  XPathEvaluator | This class provides a native Saxon API for free-standing evaluation of XPath expressions.
  XPathEvaluator | XPathEvaluator implements the JAXP API for standalone XPath processing (that is, executing XPath expressions in the absence of an XSLT stylesheet).
  XPathException | XPathException is used to indicate an error (static or dynamic) in an XPath expression, or in a query or stylesheet.
  XPathException.Circularity | Subclass of XPathException used to report circularities
  XPathException.StackOverflow | Subclass of XPathException used to report stack overflow
  XPathExecutable | An XPathExecutable represents the compiled form of an XPath expression.
  XPathExpression | This class is a representation of an XPath Expression for use with the `XPathEvaluator` class.
  XPathExpressionImpl | The JAXP XPathExpression interface represents a compiled XPath expression that can be repeatedly evaluated.
  XPathFactoryImpl | Saxon implementation of the JAXP 1.3 XPathFactory
  XPathFunctionCall | This class is an expression that calls an external function supplied using the JAXP XPathFunction interface
  XPathFunctionLibrary | The XPathFunctionLibrary is a FunctionLibrary that supports binding of XPath function calls to instances of the JAXP XPathFunction interface returned by an XPathFunctionResolver.
  XPathParser | Parser for XPath expressions and XSLT patterns.
  XPathParser.Accelerator |
  XPathParser.NestedLocation | A nested location: for use with XPath expressions and queries nested within some larger document.
  XPathParser.ParsedLanguage |
  XPathSelector | An XPathSelector represents a compiled and loaded XPath expression ready for execution.
  XPathStaticContext | This interface defines methods that must be provided when Saxon's free-standing XPath API is used.
  XPathVariable | An object representing an XPath variable for use in the standalone XPath API.
  XQCancelledException | `XQCancelledException` is an exception to indicate that the current XQuery processing is cancelled by the application through a `cancel()` request.
  XQConnection | A connection (session) with a specific XQuery engine.
  XQConnectionEvent | An event object that provides information about the source of a connection-related event.
  XQConnectionEventListener | An object that registers to be notified of events generated by a `PooledXQConnection` object.
  XQConstants | `XQConstants` class provides constants that can be used in the XQJ API.
  XQDataFactory | This interface represents a factory to obtain sequences, item objects and types.
  XQDataSource | An `XQDataSource` is a factory for `XQConnection` objects.
  XQDynamicContext | `XQDynamicContext` provides access to the dynamic context as defined in 2.1.2 Dynamic Context, XQuery 1.0: An XML Query Language.
  XQException | An exception that provides information on XQJ, XQuery or other errors reported by an XQJ implementation.
  XQExpression | This interface describes the execute immediate functionality for expressions.
  XQItem | This interface represents an item in the XDM.
  XQItemAccessor | This interface represents a common interface for accessing the values of an XQuery item.
  XQItemType | The `XQItemType` interface represents an item type as defined in XQuery 1.0: An XML Query language.
  XQMetaData | `XQMetaData` interface provides information about the data source, in various aspects, such as the product name and version identification, supported features, specific behaviors, user information, product limits and so forth.
  XQPreparedExpression | This interface describes an expression that can be prepared for multiple subsequent executions.
  XQQueryException | An exception that provides information on errors occurring during the evaluation of an xquery.
  XQResultItem | This interface represents an immutable item object obtained from an `XQResultSequence` using the `getItem` method.
  XQResultSequence | This interface represents a sequence of items obtained as a result of evaluation XQuery expressions.
  XQSequence | This interface represents a sequence of items as defined in the XDM.
  XQSequenceType | The `XQSequenceType` interface represents a sequence type as XQuery 1.0: An XML Query language.
  XQStackTraceElement | This class represents a frame in a stack trace, akin to the `java.lang.StackTraceElement` but for XQuery callstacks instead of Java.
  XQStackTraceVariable | This class represents the list of variables and their values in an error stack.
  XQStaticContext | An `XQStaticContext` represents default values for various XQuery Static Context Components.
  XQueryCompiler | An `XQueryCompiler` object allows XQuery 1.0 queries to be compiled.
  XQueryEmitter | The XQueryEmitter is designed to serialize an XQuery that was originally embedded in an XML document.
  XQueryEvaluator | An `XQueryEvaluator` represents a compiled and loaded query ready for execution.
  XQueryExecutable | An XQueryExecutable represents the compiled form of a query.
  XQueryExpression | XQueryExpression represents a compiled query.
  XQueryExpressionEE | Saxon-EE version of XQueryExpression.
  XQueryFunction | A user-defined function in an XQuery module
  XQueryFunctionAnnotationHandler | Function annotation handler for annotations in the built-in namespace http://www.w3.org/2012/xquery.
  XQueryFunctionBinder | XQueryFunctionBinder is an extension of the FunctionLibrary interface used for function libraries that contain user-written XQuery functions.
  XQueryFunctionLibrary | An XQueryFunctionLibrary is a function library containing all the user-defined functions available for use within a particular XQuery module: that is, the functions declared in that module, and the functions imported from other modules.
  XQueryFunctionLibrary.UnresolvedCallable | Inner class containing information about a reference to a function whose declaration has not yet been encountered.
  XQueryParser | This class defines extensions to the XPath parser to handle the additional syntax supported in XQuery
  XQueryParser.Unescaper |
  XQueryParserExtensionEE | Parser extension for syntax in XQuery Update and/or XQuery 3.0 that is supported only in -EE.
  XQueryParserExtensionPE | Parser extension for syntax in XQuery Update and/or XQuery 3.0 that is supported only in Saxon-PE or -EE.
  XQueryTraceCodeInjector | A code injector designed to support the -T tracing option in XQuery
  XQueryTraceListener | A Simple trace listener for XQuery that writes messages (by default) to System.err
  XQUpdate10FunctionSet | Function signatures (and pointers to implementations) of the functions defined in XQuery Update 1.0
  XSDAlternative | An xs:alternative element in a schema (see draft XML Schema 1.1 Part 1)
  XSDAnnotation | An xs:annotation element in an XML Schema document
  XSDAny | An xs:any element in an XML Schema document
  XSDAnyAttribute | An xs:anyAttribute element in an XML Schema document
  XSDAssert | An xs:assert or xs:assertion element in a schema (see draft XML Schema 1.1 Part 1)
  XSDAssert.CustomizedXPath | Define a customized XPath evaluator which injects code into the XPath code generation; this has the effect for a complex-type XSDAssert of modifying the expression so that instead of returning a boolean, it returns a list of nodes that contribute to the invalidity of the assertion.
  XSDAttribute | An xs:attribute element in a schema document
  XSDAttributeGroup | An xs:attributeGroup element in an XML Schema document
  XSDComplexContent | An xs:complexContent element in an XML Schema Document
  XSDComplexContentRestriction | An xs:restriction element that is a child of xs:complexContent within an XML Schema document
  XSDComplexType | An xs:complexType element in an XML Schema document
  XSDCompositor | An xs:sequence, xs:choice, or xs:all element in an XML Schema document
  XSDDefaultOpenContent | An element in an XML Schema document defining the default open content
  XSDDocumentation | An xs:documentation or xs:appinfo element in an XML Schema document
  XSDElement | An xs:element element in a schema document
  XSDExtension | An xs:extension element in a schema document
  XSDFacet | An element in an XML Schema document representing a facet, for example minLength or pattern or enumeration: any facet except assertion, which is represented by the `XSDAssert` class
  XSDFieldOrSelector | An xs:field or xs:selector element in an XML Schema document
  XSDGroup | An xs:group element in an XML Schema document
  XSDIdentityConstraint | An xs:unique, xs:key, or xs:keyref element in an XML Schema document
  XSDImport | An xs:import element in an XML Schema document
  XSDInclude | An xs:include element in an XML Schema document
  XSDList | This class represents an xs:list element in a schema document.
  XSDNotation | An element in an XML Schema document representing a notation declaration
  XSDOpenContent | An element in an XML Schema document defining the default open content
  XSDOverride | An xs:override element in an XML Schema Document
  XSDRedefine | An xs:redefine element in an XML Schema Document
  XSDSchema | An xs:schema element in an XML Schema document
  XSDSimpleContent | An xs:simpleContent element in an XML Schema document
  XSDSimpleContentRestriction | An xs:restriction element in an XML Schema document that appears as a child of an xs:simpleContent element
  XSDSimpleType | An xs:simple-type element in an XML Schema document
  XSDSimpleTypeRestriction | An xs:restriction element in an XML Schema Document, whose parent element is an xs:simpleType
  XSDUnion | An xs:union element in an XML Schema document
  XSIAttributeHandler | This class processes attributes such as xsi:schemaLocation and xsi:type.
  XSINamespaceSchema | This module constructs synthetically (that is, without reading an XML schema document) the schema components for the XML namespace
  XSLAccept | Represents an xsl:accept element in an XSLT 3.0 package manifest.
  XSLAcceptExpose | Handler for xsl:accept and xsl:expose elements in stylesheet.
  XSLAccumulator | Handler for xsl:accumulator elements in a stylesheet (XSLT 3.0).
  XSLAccumulatorRule | Handler for xsl:accumulator-rule elements in a stylesheet (XSLT 3.0).
  XSLAnalyzeString | An xsl:analyze-string elements in the stylesheet.
  XSLApplyImports | An xsl:apply-imports element in the stylesheet
  XSLApplyTemplates | An xsl:apply-templates element in the stylesheet
  XSLAssert | An xsl:assert element in an XSLT 3.0 stylesheet.
  XSLAttribute | xsl:attribute element in stylesheet.
  XSLAttributeSet | An xsl:attribute-set element in the stylesheet.
  XSLBreak | A xsl:break element in the stylesheet
  XSLBreakOrContinue | Abstract class containing functionality common to xsl:break and xsl:next-iteration
  XSLCallTemplate | An xsl:call-template element in the stylesheet
  XSLCatch | Handler for xsl:catch elements in stylesheet.
  XSLCharacterMap | An xsl:character-map declaration in the stylesheet.
  XSLChoose | An xsl:choose elements in the stylesheet.
  XSLComment | An xsl:comment elements in the stylesheet.
  XSLContextItem | An xsl:context-item element in the stylesheet.
  XSLCopy | Handler for xsl:copy elements in stylesheet.
  XSLCopyOf | An xsl:copy-of element in the stylesheet.
  XSLDecimalFormat | Handler for xsl:decimal-format elements in stylesheet.
  XSLDocument | An xsl:document instruction in the stylesheet.
  XSLElement | An xsl:element element in the stylesheet.
  XSLEvaluate | Handler for xsl:evaluate elements in XSLT 3.0 stylesheet.
  XSLExpose | Represents an xsl:expose element in an XSLT 3.0 package manifest.
  XSLFallback | xsl:fallback element in stylesheet.
  XSLForEach | Handler for xsl:for-each elements in stylesheet.
  XSLForEachGroup | Handler for xsl:for-each-group elements in stylesheet.
  XSLFork | Handler for xsl:fork elements in XSLT 3.0 stylesheet.
  XSLFunction | Handler for xsl:function elements in stylesheet (XSLT 2.0).
  XSLGeneralIncorporate | Abstract class to represent an xsl:include or xsl:import element in the stylesheet.
  XSLGeneralVariable | This class defines common behaviour across xsl:variable, xsl:param, and xsl:with-param
  XSLGlobalContextItem | An xsl:global-context-item declaration in the stylesheet
  XSLGlobalParam | An xsl:param element representing a global parameter (stylesheet parameter) in the stylesheet.
  XSLGlobalVariable | Handler for xsl:variable elements appearing as a child of xsl:stylesheet.
  XSLIf | Handler for xsl:if elements in stylesheet.
  XSLImport | xsl:import element in the stylesheet.
  XSLImportSchema | Compile-time representation of an xsl:import-schema declaration in a stylesheet
  XSLInclude | xsl:include element in the stylesheet.
  XSLIterate | Handler for xsl:iterate elements in stylesheet.
  XSLKey | Handler for xsl:key elements in stylesheet.
  XSLLeafNodeConstructor | Common superclass for XSLT elements whose content template produces a text value: xsl:text, xsl:value-of, xsl:attribute, xsl:comment, xsl:namespace, and xsl:processing-instruction
  XSLLocalParam | An xsl:param element representing a local parameter (template or function parameter) in the stylesheet.
  XSLLocalVariable | Handler for xsl:variable elements acting as local variable declarations in a stylesheet.
  XSLMap | Handler for xsl:map instructions in an XSLT 3.0 stylesheet.
  XSLMapEntry | Handler for xsl:map-entry instructions in an XSLT 3.0 stylesheet.
  XSLMatchingSubstring | Handler for xsl:matching-substring and xsl:non-matching-substring elements in stylesheet.
  XSLMerge | Handler for xsl:merge elements in stylesheet.
  XSLMergeAction |
  XSLMergeKey | An xsl:merge-key element in the stylesheet.
  XSLMergeSource | Implements the xsl:merge-source element available in XSLT 3.0 as a child of xsl:merge.
  XSLMessage | An xsl:message element in the stylesheet.
  XSLMode | Handler for xsl:mode elements in stylesheet.
  XSLModuleRoot | Class representing xsl:stylesheet, xsl:transform, or xsl:package
  XSLNamespace | An xsl:namespace element in the stylesheet.
  XSLNamespaceAlias | An xsl:namespace-alias element in the stylesheet.
  XSLNextIteration | An xsl:next-iteration element in the stylesheet
  XSLNextMatch | An xsl:next-match element in the stylesheet
  XSLNumber | An xsl:number element in the stylesheet.
  XSLOnCompletion | An xsl:on-completion element in the stylesheet (XSLT 3.0).
  XSLOnEmpty | An xsl:on-empty element in the stylesheet.
  XSLOnNonEmpty | An xsl:on-non-empty element in the stylesheet.
  XSLOriginalLibrary | A function library that recognizes the function name "xsl:original", which may appear within xsl:override
  XSLOtherwise | Handler for xsl:otherwise elements in stylesheet.
  XSLOutput | An xsl:output element in the stylesheet.
  XSLOutputCharacter | An xsl:output-character element in the stylesheet.
  XSLOverride | Represents an xsl:override element in a package manifest.
  XSLPackage | Handler for xsl:package elements.
  XSLPerformSort | Handler for xsl:perform-sort elements in stylesheet (XSLT 2.0).
  XSLPreserveSpace | An xsl:preserve-space or xsl:strip-space elements in stylesheet.
  XSLProcessingInstruction | An xsl:processing-instruction element in the stylesheet.
  XSLResultDocument | An xsl:result-document element in the stylesheet.
  XSLSequence | An xsl:sequence element in the stylesheet.
  XSLSort | An xsl:sort element in the stylesheet.
  XSLSortOrMergeKey |
  XSLSourceDocument | Handler for xsl:source-document element in XSLT 3.0 stylesheet.
  XSLStylesheet | An xsl:stylesheet or xsl:transform element in the stylesheet.
  XSLT30FunctionSet | Function signatures (and pointers to implementations) of the functions defined in XSLT 3.0.
  Xslt30Transformer | An `Xslt30Transformer` represents a compiled and loaded stylesheet ready for execution.
  XsltCompiler | An XsltCompiler object allows XSLT 2.0 and XSLT 3.0 stylesheets to be compiled.
  XsltController | This class is an extension of the Controller class, used when executing XSLT stylesheets.
  XSLTemplate | An xsl:template element in the style sheet.
  XsltExecutable | An XsltExecutable represents the compiled form of a stylesheet.
  XSLText | Handler for xsl:text elements in stylesheet.
  XsltPackage | An XsltPackage object represents the result of compiling an XSLT 3.0 package, as represented by an XML document containing an `xsl:package` element.
  XSLTry | Handler for xsl:try elements in stylesheet.
  XSLTTraceCodeInjector | A code injector that wraps every expression (other than a literal) in a TraceExpression, which causes a TraceListener to be notified when the expression is evaluated
  XSLTTraceListener | A Simple trace listener for XSLT that writes messages (by default) to System.err
  XsltTransformer | An `XsltTransformer` represents a compiled and loaded stylesheet ready for execution.
  XSLUsePackage | Handler for xsl:use-package elements in stylesheet.
  XSLValueOf | An xsl:value-of element in the stylesheet.
  XSLWhen | Handler for xsl:when elements in stylesheet.
  XSLWherePopulated | An xsl:where-populated element in the stylesheet.
  XSLWithParam | An xsl:with-param element in the stylesheet.
  YearMonthDurationValue | A value of type xs:yearMonthDuration.
  ZeroOrMore<T extends Item> | A value that is a sequence containing one or more items.
  ZeroOrOne<T extends Item> | A value that is a sequence containing zero or one items.