Update POCO library.

vendor/POCO/XML/include/Poco/DOM/Attr.h

@@ -31,7 +31,7 @@ namespace XML {
 class XML_API Attr: public AbstractNode
 	/// The Attr interface represents an attribute in an Element object. Typically
 	/// the allowable values for the attribute are defined in a document type definition.
-	/// 
+	///
 	/// Attr objects inherit the Node interface, but since they are not actually
 	/// child nodes of the element they describe, the DOM does not consider them
 	/// part of the document tree. Thus, the Node attributes parentNode, previousSibling,
@@ -44,7 +44,7 @@ class XML_API Attr: public AbstractNode
 	/// nodes contained within a DocumentFragment. In short, users and implementors
 	/// of the DOM need to be aware that Attr nodes have some things in common with
 	/// other objects inheriting the Node interface, but they also are quite distinct.
-	/// 
+	///
 	/// The attribute's effective value is determined as follows: if this attribute
 	/// has been explicitly assigned any value, that value is the attribute's effective
 	/// value; otherwise, if there is a declaration for this attribute, and that
@@ -53,7 +53,7 @@ class XML_API Attr: public AbstractNode
 	/// in the structure model until it has been explicitly added. Note that the
 	/// nodeValue attribute on the Attr instance can also be used to retrieve the
 	/// string version of the attribute's value(s).
-	/// 
+	///
 	/// In XML, where the value of an attribute can contain entity references, the
 	/// child nodes of the Attr node provide a representation in which entity references
 	/// are not expanded. These child nodes may be either Text or EntityReference
@@ -74,7 +74,7 @@ public:
 		/// attribute. The implementation will then make a new attribute available with
 		/// specified set to false and the default value (if one exists).
 		/// In summary:
-		/// 
+		///
 		///     * If the attribute has an assigned value in the document then specified
 		///       is true, and the value is the assigned value.
 		///     * If the attribute has no assigned value in the document and has a default
@@ -106,7 +106,7 @@ public:
 
 	// DOM Level 2
 	Element* ownerElement() const;
-		/// The Element node this attribute is attached to or null 
+		/// The Element node this attribute is attached to or null
 		/// if this attribute is not in use.
 
 	// Node
@@ -127,7 +127,7 @@ protected:
 	Attr(Document* pOwnerDocument, Element* pOwnerElement, const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const XMLString& value, bool specified = true);
 	Attr(Document* pOwnerDocument, const Attr& attr);
 	~Attr();
-	
+
 	Node* copyNode(bool deep, Document* pOwnerDocument) const;
 
 private:

vendor/POCO/XML/include/Poco/DOM/AttrMap.h

@@ -54,7 +54,7 @@ private:
 	AttrMap();
 
 	Element* _pElement;
-	
+
 	friend class Element;
 };
 

vendor/POCO/XML/include/Poco/DOM/CDATASection.h

@@ -32,17 +32,17 @@ class XML_API CDATASection: public Text
 	/// in a CDATA section is the "]]>" string that ends the CDATA section. CDATA
 	/// sections cannot be nested. Their primary purpose is for including material
 	/// such as XML fragments, without needing to escape all the delimiters.
-	/// 
+	///
 	/// The DOMString attribute of the Text node holds the text that is contained
 	/// by the CDATA section. Note that this may contain characters that need to
 	/// be escaped outside of CDATA sections and that, depending on the character
 	/// encoding ("charset") chosen for serialization, it may be impossible to write
 	/// out some characters as part of a CDATA section.
-	/// 
+	///
 	/// The CDATASection interface inherits from the CharacterData interface through
 	/// the Text interface. Adjacent CDATASection nodes are not merged by use of
 	/// the normalize method on the Element interface.
-	/// 
+	///
 	/// Note: Because no markup is recognized within a CDATASection, character numeric
 	/// references cannot be used as an escape mechanism when serializing. Therefore,
 	/// action needs to be taken when serializing a CDATASection with a character
@@ -73,7 +73,7 @@ protected:
 
 private:
 	static const XMLString NODE_NAME;
-	
+
 	friend class Document;
 };
 

vendor/POCO/XML/include/Poco/DOM/CharacterData.h

@@ -33,18 +33,18 @@ class XML_API CharacterData: public AbstractNode
 	/// here rather than on each object that uses these attributes and methods.
 	/// No DOM objects correspond directly to CharacterData, though Text and others
 	/// do inherit the interface from it. All offsets in this interface start from 0.
-	/// 
+	///
 	/// Text strings in the DOM are represented in either UTF-8 (if XML_UNICODE_WCHAR_T is
 	/// not defined) or in UTF-16 (if XML_UNICODE_WCHAR_T is defined).
 	/// Indexing on character data is done in XMLChar units.
 {
 public:
 	const XMLString& data() const;
-		/// Returns the character data of the node that 
+		/// Returns the character data of the node that
 		/// implements the interface.
-	
+
 	const XMLString& getData() const;
-		/// Returns the character data of the node that 
+		/// Returns the character data of the node that
 		/// implements the interface.
 
 	void setData(const XMLString& data);

vendor/POCO/XML/include/Poco/DOM/ChildNodesList.h

@@ -39,12 +39,12 @@ public:
 protected:
 	ChildNodesList(const Node* pParent);
 	~ChildNodesList();
-	
+
 private:
 	ChildNodesList();
 
 	const Node* _pParent;
-	
+
 	friend class AbstractNode;
 };
 

vendor/POCO/XML/include/Poco/DOM/Comment.h

@@ -47,7 +47,7 @@ protected:
 
 private:
 	static const XMLString NODE_NAME;
-	
+
 	friend class Document;
 };
 

vendor/POCO/XML/include/Poco/DOM/DOMBuilder.h

@@ -47,7 +47,7 @@ class XML_API DOMBuilder: protected DTDHandler, protected ContentHandler, protec
 {
 public:
 	DOMBuilder(XMLReader& xmlReader, NamePool* pNamePool = 0);
-		/// Creates a DOMBuilder using the given XMLReader. 
+		/// Creates a DOMBuilder using the given XMLReader.
 		/// If a NamePool is given, it becomes the Document's NamePool.
 
 	virtual ~DOMBuilder();
@@ -87,10 +87,10 @@ protected:
 	void endEntity(const XMLString& name);
 	void startCDATA();
 	void endCDATA();
-	void comment(const XMLChar ch[], int start, int length); 
+	void comment(const XMLChar ch[], int start, int length);
 
 	void appendNode(AbstractNode* pNode);
-	
+
 	void setupParse();
 
 private:

vendor/POCO/XML/include/Poco/DOM/DOMException.h

@@ -32,7 +32,7 @@ class XML_API DOMException: public XMLException
 	/// because data is lost, or because the implementation has become unstable).
 	/// In general, DOM methods return specific error values in ordinary processing
 	/// situations, such as out-of-bound errors when using NodeList.
-	/// 
+	///
 	/// Implementations should raise other exceptions under other circumstances.
 	/// For example, implementations should raise an implementation-dependent exception
 	/// if a null argument is passed when null was not expected.
@@ -55,19 +55,19 @@ public:
 		INVALID_MODIFICATION_ERR,    /// an attempt is made to modify the type of the underlying object
 		NAMESPACE_ERR,               /// an attempt is made to create or change an object in a way which is incorrect with regard to namespaces
 		INVALID_ACCESS_ERR,          /// an attempt is made to use an object that is not, or is no longer, usable
-		
+
 		_NUMBER_OF_MESSAGES
 	};
 
 	DOMException(unsigned short code);
 		/// Creates a DOMException with the given error code.
-		
+
 	DOMException(const DOMException& exc);
 		/// Creates a DOMException by copying another one.
-		
+
 	~DOMException() noexcept;
 		/// Destroys the DOMException.
-		
+
 	DOMException& operator = (const DOMException& exc);
 
 	const char* name() const noexcept;
@@ -78,7 +78,7 @@ public:
 
 	Poco::Exception* clone() const;
 		/// Creates an exact copy of the exception.
-		
+
 	void rethrow() const;
 		/// (Re)Throws the exception.
 
@@ -87,12 +87,12 @@ public:
 
 protected:
 	static const std::string& message(unsigned short code);
-	
+
 private:
 	DOMException();
-	
+
 	unsigned short _code;
-	
+
 	static const std::string MESSAGES[_NUMBER_OF_MESSAGES];
 };
 

vendor/POCO/XML/include/Poco/DOM/DOMImplementation.h

@@ -40,20 +40,20 @@ class XML_API DOMImplementation
 public:
 	DOMImplementation();
 		/// Creates the DOMImplementation.
-		
+
 	~DOMImplementation();
 		/// Destroys the DOMImplementation.
 
 	bool hasFeature(const XMLString& feature, const XMLString& version) const;
 		/// Tests if the DOM implementation implements a specific feature.
 		///
-		/// The only supported features are "XML", version "1.0" and "Core", 
+		/// The only supported features are "XML", version "1.0" and "Core",
 		/// "Events", "MutationEvents" and "Traversal", version "2.0".
-	
+
 	// DOM Level 2
 	DocumentType* createDocumentType(const XMLString& name, const XMLString& publicId, const XMLString& systemId) const;
-		/// Creates an empty DocumentType node. Entity declarations and notations 
-		/// are not made available. Entity reference expansions and default attribute 
+		/// Creates an empty DocumentType node. Entity declarations and notations
+		/// are not made available. Entity reference expansions and default attribute
 		/// additions do not occur.
 
 	Document* createDocument(const XMLString& namespaceURI, const XMLString& qualifiedName, DocumentType* doctype) const;
@@ -64,7 +64,7 @@ public:
 	static const DOMImplementation& instance();
 		/// Returns a reference to the default DOMImplementation
 		/// object.
-		
+
 private:
 	static const XMLString FEATURE_XML;
 	static const XMLString FEATURE_CORE;
@@ -72,7 +72,7 @@ private:
 	static const XMLString FEATURE_MUTATIONEVENTS;
 	static const XMLString FEATURE_TRAVERSAL;
 	static const XMLString VERSION_1_0;
-	static const XMLString VERSION_2_0;	
+	static const XMLString VERSION_2_0;
 };
 
 

vendor/POCO/XML/include/Poco/DOM/DOMObject.h

@@ -62,7 +62,7 @@ public:
 		/// Decreases the object's reference count.
 		/// If the reference count reaches zero,
 		/// the object is deleted.
-		
+
 	virtual void autoRelease() = 0;
 		/// Adds the object to an appropriate
 		/// AutoReleasePool, which is usually the
@@ -76,7 +76,7 @@ protected:
 private:
 	DOMObject(const DOMObject&);
 	DOMObject& operator = (const DOMObject&);
-	
+
 	mutable int _rc;
 };
 

vendor/POCO/XML/include/Poco/DOM/DOMParser.h

@@ -39,13 +39,13 @@ class XML_API DOMParser
 {
 public:
 	explicit DOMParser(NamePool* pNamePool = 0);
-		/// Creates a new DOMParser. 
+		/// Creates a new DOMParser.
 		/// If a NamePool is given, it becomes the Document's NamePool.
-		
+
 	explicit DOMParser(unsigned long namePoolSize);
 		/// Creates a new DOMParser, using the given NamePool size.
 		///
-		/// The given namePoolSize should be a suitable prime number, 
+		/// The given namePoolSize should be a suitable prime number,
 		/// e.g. 251, 509, 1021 or 4093, depending on the expected
 		/// size of the document.
 
@@ -55,7 +55,7 @@ public:
 	void setEncoding(const XMLString& encoding);
 		/// Sets the encoding used by the parser if no
 		/// encoding is specified in the XML document.
-		
+
 	const XMLString& getEncoding() const;
 		/// Returns the name of the encoding used by
 		/// the parser if no encoding is specified in
@@ -100,7 +100,7 @@ public:
 		/// Sets the entity resolver on the underlying SAXParser.
 
 	static const XMLString FEATURE_FILTER_WHITESPACE;
-	
+
 private:
 	SAXParser _saxParser;
 	NamePool* _pNamePool;

vendor/POCO/XML/include/Poco/DOM/DOMSerializer.h

@@ -52,10 +52,10 @@ class XML_API DOMSerializer: public XMLReader
 public:
 	DOMSerializer();
 		/// Creates the DOMSerializer.
-		
+
 	~DOMSerializer();
 		/// Destroys the DOMSerializer.
-		
+
 	void serialize(const Node* pNode);
 		/// Serializes a DOM node and its children
 		/// into a sequence of SAX events, which are
@@ -82,7 +82,7 @@ protected:
 	void parse(InputSource* pSource);
 		/// The DOMSerializer cannot parse an InputSource,
 		/// so this method simply throws an XMLException when invoked.
-		
+
 	void parse(const XMLString& systemId);
 		/// The DOMSerializer cannot parse from a system identifier,
 		/// so this method simply throws an XMLException when invoked.
@@ -111,7 +111,7 @@ private:
 	ErrorHandler*   _pErrorHandler;
 	DeclHandler*    _pDeclHandler;
 	LexicalHandler* _pLexicalHandler;
-	
+
 	static const XMLString CDATA;
 };
 

vendor/POCO/XML/include/Poco/DOM/DOMWriter.h

@@ -40,7 +40,7 @@ class XML_API DOMWriter
 public:
 	DOMWriter();
 		/// Creates a DOMWriter.
-		
+
 	~DOMWriter();
 		/// Destroys a DOMWriter.
 
@@ -61,7 +61,7 @@ public:
 	void setNewLine(const std::string& newLine);
 		/// Sets the line ending characters for the internal
 		/// XMLWriter. See XMLWriter::setNewLine() for a list
-		/// of supported values. 
+		/// of supported values.
 
 	const std::string& getNewLine() const;
 		/// Returns the line ending characters used by the
@@ -74,7 +74,7 @@ public:
 		/// The given string should only contain TAB or SPACE
 		/// characters (e.g., a single TAB character, or
 		/// two to four SPACE characters).
-		
+
 	const std::string& getIndent() const;
 		/// Returns the string used for one indentation step.
 

vendor/POCO/XML/include/Poco/DOM/DTDMap.h

@@ -32,7 +32,7 @@ class DocumentType;
 class XML_API DTDMap: public NamedNodeMap
 	/// This implementation of NamedNodeMap
 	/// is returned by DocumentType::entities()
-	/// and DocumentType::notations(). 
+	/// and DocumentType::notations().
 {
 public:
 	Node* getNamedItem(const XMLString& name) const;
@@ -53,10 +53,10 @@ protected:
 
 private:
 	DTDMap();
-	
+
 	const DocumentType* _pDocumentType;
 	unsigned short _type;
-	
+
 	friend class DocumentType;
 };
 

vendor/POCO/XML/include/Poco/DOM/Document.h

@@ -47,14 +47,14 @@ class Notation;
 
 
 class XML_API Document: public AbstractContainerNode, public DocumentEvent
-	/// The Document interface represents the entire HTML or XML document. Conceptually, 
-	/// it is the root of the document tree, and provides the primary access to the 
+	/// The Document interface represents the entire HTML or XML document. Conceptually,
+	/// it is the root of the document tree, and provides the primary access to the
 	/// document's data.
 	///
-	/// Since elements, text nodes, comments, processing instructions, etc. cannot exist 
-	/// outside the context of a Document, the Document interface also contains the 
-	/// factory methods needed to create these objects. The Node objects created have a 
-	/// ownerDocument attribute which associates them with the Document within whose 
+	/// Since elements, text nodes, comments, processing instructions, etc. cannot exist
+	/// outside the context of a Document, the Document interface also contains the
+	/// factory methods needed to create these objects. The Node objects created have a
+	/// ownerDocument attribute which associates them with the Document within whose
 	/// context they were created.
 {
 public:
@@ -65,7 +65,7 @@ public:
 		/// creates its own name pool, otherwise it uses the given name pool.
 		/// Sharing a name pool makes sense for documents containing instances
 		/// of the same schema, thus reducing memory usage.
-		
+
 	explicit Document(unsigned long namePoolSize);
 		/// Creates a new document using a name pool with the given size, which
 		/// should be a prime number (e.g., 251, 509, 1021, 4093).
@@ -141,9 +141,9 @@ public:
 	ProcessingInstruction* createProcessingInstruction(const XMLString& target, const XMLString& data) const;
 		/// Creates a ProcessingInstruction node given the specified target and data strings.
 
-	Attr* createAttribute(const XMLString& name) const;	
+	Attr* createAttribute(const XMLString& name) const;
 		/// Creates an Attr of the given name. Note that the Attr instance can then
-		/// be set on an Element using the setAttributeNode method.	
+		/// be set on an Element using the setAttributeNode method.
 
 	EntityReference* createEntityReference(const XMLString& name) const;
 		/// Creates an EntityReference object. In addition, if the referenced entity
@@ -181,18 +181,18 @@ public:
 		/// Creates an attribute of the given qualified name and namespace URI.
 
 	NodeList* getElementsByTagNameNS(const XMLString& namespaceURI, const XMLString& localName) const;
-		/// Returns a NodeList of all the Elements with a given local name and 
-		/// namespace URI in the order in which they are encountered in a 
+		/// Returns a NodeList of all the Elements with a given local name and
+		/// namespace URI in the order in which they are encountered in a
 		/// preorder traversal of the Document tree.
 
 	Element* getElementById(const XMLString& elementId) const;
-		/// Returns the Element whose ID is given by elementId. If no such 
+		/// Returns the Element whose ID is given by elementId. If no such
 		/// element exists, returns null. Behavior is not defined if more
-		/// than one element has this ID. 
+		/// than one element has this ID.
 		///
-		/// Note: The DOM implementation must have information that says 
+		/// Note: The DOM implementation must have information that says
 		/// which attributes are of type ID. Attributes with the name "ID"
-		/// are not of type ID unless so defined. Implementations that do 
+		/// are not of type ID unless so defined. Implementations that do
 		/// not know whether attributes are of type ID or not are expected to
 		/// return null. This implementation therefore returns null.
 		///
@@ -208,7 +208,7 @@ public:
 
 	// EventTarget
 	bool dispatchEvent(Event* evt);
-	
+
 	// Extensions
 	Entity* createEntity(const XMLString& name, const XMLString& publicId, const XMLString& systemId, const XMLString& notationName) const;
 		/// Creates an Entity with the given name, publicId, systemId and notationName.
@@ -222,13 +222,13 @@ public:
 
 	Element* getElementById(const XMLString& elementId, const XMLString& idAttribute) const;
 		/// Returns the first Element whose ID attribute (given in idAttribute)
-		/// has the given elementId. If no such element exists, returns null. 
+		/// has the given elementId. If no such element exists, returns null.
 		///
 		/// This method is an extension to the W3C Document Object Model.
 
 	Element* getElementByIdNS(const XMLString& elementId, const XMLString& idAttributeURI, const XMLString& idAttributeLocalName) const;
 		/// Returns the first Element whose ID attribute (given in idAttributeURI and idAttributeLocalName)
-		/// has the given elementId. If no such element exists, returns null. 
+		/// has the given elementId. If no such element exists, returns null.
 		///
 		/// This method is an extension to the W3C Document Object Model.
 
@@ -236,7 +236,7 @@ protected:
 	~Document();
 
 	Node* copyNode(bool deep, Document* pOwnerDocument) const;
-	
+
 	DocumentType* getDoctype();
 	void setDoctype(DocumentType* pDoctype);
 
@@ -247,7 +247,7 @@ private:
 	int             _eventSuspendLevel;
 
 	static const XMLString NODE_NAME;
-	
+
 	friend class DOMBuilder;
 };
 

vendor/POCO/XML/include/Poco/DOM/DocumentFragment.h

@@ -37,12 +37,12 @@ class XML_API DocumentFragment: public AbstractContainerNode
 	/// could fulfill this role, a Document object can potentially be a heavyweight
 	/// object, depending on the underlying implementation. What is really needed
 	/// for this is a very lightweight object. DocumentFragment is such an object.
-	/// 
+	///
 	/// Furthermore, various operations -- such as inserting nodes as children of
 	/// another Node -- may take DocumentFragment objects as arguments; this results
 	/// in all the child nodes of the DocumentFragment being moved to the child
 	/// list of this node.
-	/// 
+	///
 	/// The children of a DocumentFragment node are zero or more nodes representing
 	/// the tops of any sub-trees defining the structure of the document. DocumentFragment
 	/// nodes do not need to be well-formed XML documents (although they do need
@@ -50,7 +50,7 @@ class XML_API DocumentFragment: public AbstractContainerNode
 	/// can have multiple top nodes). For example, a DocumentFragment might have
 	/// only one child and that child node could be a Text node. Such a structure
 	/// model represents neither an HTML document nor a well-formed XML document.
-	/// 
+	///
 	/// When a DocumentFragment is inserted into a Document (or indeed any other
 	/// Node that may take children) the children of the DocumentFragment and not
 	/// the DocumentFragment itself are inserted into the Node. This makes the DocumentFragment
@@ -68,12 +68,12 @@ protected:
 	DocumentFragment(Document* pOwnerDocument);
 	DocumentFragment(Document* pOwnerDocument, const DocumentFragment& fragment);
 	~DocumentFragment();
-	
+
 	Node* copyNode(bool deep, Document* pOwnerDocument) const;
 
 private:
 	static const XMLString NODE_NAME;
-	
+
 	friend class Document;
 };
 

vendor/POCO/XML/include/Poco/DOM/DocumentType.h

@@ -35,12 +35,12 @@ class XML_API DocumentType: public AbstractContainerNode
 	/// interface to the list of entities that are defined for the document, and
 	/// little else because the effect of namespaces and the various XML scheme
 	/// efforts on DTD representation are not clearly understood as of this writing.
-	/// 
+	///
 	/// The DOM Level 1 doesn't support editing DocumentType nodes.
 {
 public:
 	const XMLString& name() const;
-		/// The name of the DTD; i.e., the name immediately following the 
+		/// The name of the DTD; i.e., the name immediately following the
 		/// DOCTYPE keyword.
 
 	NamedNodeMap* entities() const;
@@ -52,7 +52,7 @@ public:
 		/// external entities are reported.
 		/// Every node in this map also implements the
 		/// Entity interface.
-		/// 
+		///
 		/// The returned NamedNodeMap must be released with a call
 		/// to release() when no longer needed.
 
@@ -61,7 +61,7 @@ public:
 		/// are discarded. Every node in this map also implements the Notation interface.
 		/// The DOM Level 1 does not support editing notations, therefore notations
 		/// cannot be altered in any way.
-		/// 
+		///
 		/// The returned NamedNodeMap must be released with a call
 		/// to release() when no longer needed.
 
@@ -91,7 +91,7 @@ private:
 	XMLString _name;
 	XMLString _publicId;
 	XMLString _systemId;
-	
+
 	friend class DOMImplementation;
 	friend class Document;
 	friend class DOMBuilder;

vendor/POCO/XML/include/Poco/DOM/Element.h

@@ -40,19 +40,19 @@ class XML_API Element: public AbstractContainerNode
 	/// methods on the Element interface to retrieve either an Attr object by name
 	/// or an attribute value by name. In XML, where an attribute value may contain
 	/// entity references, an Attr object should be retrieved to examine the possibly
-	/// fairly complex sub-tree representing the attribute value. 
+	/// fairly complex sub-tree representing the attribute value.
 {
 public:
 	const XMLString& tagName() const;
 		/// Returns the name of the element.
 		///
 		/// For example, in
-		/// 
-		///     <elementExample id="demo"> 
-        ///         ... 
+		///
+		///     <elementExample id="demo">
+		///         ...
 		///     </elementExample>
 		///
-		/// tagName has the value "elementExample". Note that this is case-preserving in XML, 
+		/// tagName has the value "elementExample". Note that this is case-preserving in XML,
 		/// as are all of the operations of the DOM.
 
 	const XMLString& getAttribute(const XMLString& name) const;
@@ -68,7 +68,7 @@ public:
 		/// markup (such as syntax to be recognized as an entity reference) is treated
 		/// as literal text, and needs to be appropriately escaped by the implementation
 		/// when it is written out.
- 
+
 	void removeAttribute(const XMLString& name);
 		/// Removes an attribute by name.
 
@@ -107,7 +107,7 @@ public:
 		/// used to ensure that the DOM view of a document is the same as if it were
 		/// saved and re-loaded, and is useful when operations (such as XPointer
 		/// lookups) that depend on a particular document tree structure are to be used.
-		/// 
+		///
 		/// Note: In cases where the document contains CDATASections, the normalize
 		/// operation alone may not be sufficient, since XPointers do not differentiate
 		/// between Text nodes and CDATASection nodes.
@@ -141,7 +141,7 @@ public:
 		/// Returns true if and only if the element has the specified attribute.
 
 	NodeList* getElementsByTagNameNS(const XMLString& namespaceURI, const XMLString& localName) const;
-		/// Returns a NodeList of all the descendant Elements with a given local name and namespace URI 
+		/// Returns a NodeList of all the descendant Elements with a given local name and namespace URI
 		/// in the order in which they are encountered in a preorder traversal of this Element tree.
 		///
 		/// The special value "*" matches all namespaces, or local names respectively.
@@ -166,19 +166,19 @@ public:
 		/// or null if such an element does not exist.
 		///
 		/// This method is an extension to the W3C Document Object Model.
-	
+
 	Element* getElementById(const XMLString& elementId, const XMLString& idAttribute) const;
 		/// Returns the first Element whose ID attribute (given in idAttribute)
-		/// has the given elementId. If no such element exists, returns null. 
+		/// has the given elementId. If no such element exists, returns null.
 		///
 		/// This method is an extension to the W3C Document Object Model.
 
 	Element* getElementByIdNS(const XMLString& elementId, const XMLString& idAttributeURI, const XMLString& idAttributeLocalName) const;
 		/// Returns the first Element whose ID attribute (given in idAttributeURI and idAttributeLocalName)
-		/// has the given elementId. If no such element exists, returns null. 
+		/// has the given elementId. If no such element exists, returns null.
 		///
 		/// This method is an extension to the W3C Document Object Model.
-	
+
 	// Node
 	const XMLString& nodeName() const;
 	NamedNodeMap* attributes() const;

vendor/POCO/XML/include/Poco/DOM/ElementsByTagNameList.h

@@ -46,7 +46,7 @@ protected:
 	const Node* _pParent;
 	XMLString   _name;
 	mutable unsigned long _count;
-	
+
 	friend class AbstractContainerNode;
 	friend class Element;
 	friend class Document;
@@ -73,7 +73,7 @@ protected:
 	XMLString   _localName;
 	XMLString   _namespaceURI;
 	mutable unsigned long _count;
-	
+
 	friend class AbstractContainerNode;
 	friend class Element;
 	friend class Document;

vendor/POCO/XML/include/Poco/DOM/Entity.h

@@ -32,14 +32,14 @@ class XML_API Entity: public AbstractContainerNode
 	/// document. Note that this models the entity itself not the entity declaration.
 	/// Entity declaration modeling has been left for a later Level of the DOM
 	/// specification.
-	/// 
+	///
 	/// The nodeName attribute that is inherited from Node contains the name of
 	/// the entity.
-	/// 
+	///
 	/// An XML processor may choose to completely expand entities before the structure
 	/// model is passed to the DOM; in this case there will be no EntityReference
 	/// nodes in the document tree.
-	/// 
+	///
 	/// XML does not mandate that a non-validating XML processor read and process
 	/// entity declarations made in the external subset or declared in external
 	/// parameter entities. This means that parsed entities declared in the external
@@ -47,17 +47,17 @@ class XML_API Entity: public AbstractContainerNode
 	/// replacement value of the entity may not be available. When the replacement
 	/// value is available, the corresponding Entity node's child list represents
 	/// the structure of that replacement text. Otherwise, the child list is empty.
-	/// 
+	///
 	/// The resolution of the children of the Entity (the replacement value) may
 	/// be lazily evaluated; actions by the user (such as calling the childNodes
 	/// method on the Entity Node) are assumed to trigger the evaluation.
-	/// 
+	///
 	/// The DOM Level 1 does not support editing Entity nodes; if a user wants to
 	/// make changes to the contents of an Entity, every related EntityReference
 	/// node has to be replaced in the structure model by a clone of the Entity's
 	/// contents, and then the desired changes must be made to each of those clones
 	/// instead. Entity nodes and all their descendants are readonly.
-	/// 
+	///
 	/// An Entity node does not have any parent.
 {
 public:
@@ -84,7 +84,7 @@ protected:
 	Entity(Document* pOwnerDocument, const XMLString& name, const XMLString& publicId, const XMLString& systemId, const XMLString& notationName);
 	Entity(Document* pOwnerDocument, const Entity& entity);
 	~Entity();
-	
+
 	Node* copyNode(bool deep, Document* pOwnerDocument) const;
 
 private:

vendor/POCO/XML/include/Poco/DOM/EntityReference.h

@@ -39,10 +39,10 @@ class XML_API EntityReference: public AbstractNode
 	/// node, it may be that there is no Entity node representing the referenced
 	/// entity. If such an Entity exists, then the child list of the EntityReference
 	/// node is the same as that of the Entity node.
-	/// 
+	///
 	/// As for Entity nodes, EntityReference nodes and all their descendants are
 	/// readonly.
-	/// 
+	///
 	/// The resolution of the children of the EntityReference (the replacement value
 	/// of the referenced Entity) may be lazily evaluated; actions by the user (such
 	/// as calling the childNodes method on the EntityReference node) are assumed
@@ -62,7 +62,7 @@ protected:
 
 private:
 	XMLString _name;
-	
+
 	friend class Document;
 };
 

vendor/POCO/XML/include/Poco/DOM/Event.h

@@ -43,9 +43,9 @@ class XML_API Event: public DOMObject
 public:
 	enum PhaseType
 	{
-		CAPTURING_PHASE = 1, /// The event is currently being evaluated at the target EventTarget. 
-		AT_TARGET       = 2, /// The current event phase is the bubbling phase. 
-		BUBBLING_PHASE  = 3  /// The current event phase is the capturing phase. 
+		CAPTURING_PHASE = 1, /// The event is currently being evaluated at the target EventTarget.
+		AT_TARGET       = 2, /// The current event phase is the bubbling phase.
+		BUBBLING_PHASE  = 3  /// The current event phase is the capturing phase.
 	};
 
 	const XMLString& type() const;
@@ -55,59 +55,59 @@ public:
 		/// Used to indicate the EventTarget to which the event was originally dispatched.
 
 	EventTarget* currentTarget() const;
-		/// Used to indicate the EventTarget whose EventListeners are currently being 
+		/// Used to indicate the EventTarget whose EventListeners are currently being
 		/// processed. This is particularly useful during capturing and bubbling.
 
 	PhaseType eventPhase() const;
 		/// Used to indicate which phase of event flow is currently being evaluated.
 
 	bool bubbles() const;
-		/// Used to indicate whether or not an event is a bubbling event. 
+		/// Used to indicate whether or not an event is a bubbling event.
 		/// If the event can bubble the value is true, else the value is false.
 
 	bool cancelable() const;
-		/// Used to indicate whether or not an event can have its default action 
+		/// Used to indicate whether or not an event can have its default action
 		/// prevented. If the default action can be prevented the value is
 		/// true, else the value is false.
 
 	Poco::UInt64 timeStamp() const;
-		/// Used to specify the time (in milliseconds relative to the epoch) at 
+		/// Used to specify the time (in milliseconds relative to the epoch) at
 		/// which the event was created. Due to the fact that some
-		/// systems may not provide this information the value of timeStamp may 
+		/// systems may not provide this information the value of timeStamp may
 		/// be not available for all events. When not available, a
-		/// value of 0 will be returned. Examples of epoch time are the time of the 
+		/// value of 0 will be returned. Examples of epoch time are the time of the
 		/// system start or 0:0:0 UTC 1st January 1970.
 		/// This implementation always returns 0.
 
 	void stopPropagation();
-		/// The stopPropagation method is used prevent further propagation of an 
+		/// The stopPropagation method is used prevent further propagation of an
 		/// event during event flow. If this method is called by
-		/// any EventListener the event will cease propagating through the tree. 
+		/// any EventListener the event will cease propagating through the tree.
 		/// The event will complete dispatch to all listeners on the
-		/// current EventTarget before event flow stops. This method may be used 
-		/// during any stage of event flow. 
+		/// current EventTarget before event flow stops. This method may be used
+		/// during any stage of event flow.
 
 	void preventDefault();
-		/// If an event is cancelable, the preventDefault method is used to signify 
+		/// If an event is cancelable, the preventDefault method is used to signify
 		/// that the event is to be canceled, meaning any default
-		/// action normally taken by the implementation as a result of 
+		/// action normally taken by the implementation as a result of
 		/// the event will not occur. If, during any stage of event flow, the
-		/// preventDefault method is called the event is canceled. Any default 
+		/// preventDefault method is called the event is canceled. Any default
 		/// action associated with the event will not occur. Calling
-		/// this method for a non-cancelable event has no effect. Once 
+		/// this method for a non-cancelable event has no effect. Once
 		/// preventDefault has been called it will remain in effect throughout
-		/// the remainder of the event's propagation. This method may be 
-		/// used during any stage of event flow. 
+		/// the remainder of the event's propagation. This method may be
+		/// used during any stage of event flow.
 
 	void initEvent(const XMLString& eventType, bool canBubble, bool isCancelable);
-		/// The initEvent method is used to initialize the value of an 
+		/// The initEvent method is used to initialize the value of an
 		/// Event created through the DocumentEvent interface. This method
-		/// may only be called before the Event has been dispatched via the 
+		/// may only be called before the Event has been dispatched via the
 		/// dispatchEvent method, though it may be called multiple
-		/// times during that phase if necessary. If called multiple 
-		/// times the final invocation takes precedence. If called from 
-		/// a subclass of Event interface only the values specified in the 
-		/// initEvent method are modified, all other attributes are left unchanged. 
+		/// times during that phase if necessary. If called multiple
+		/// times the final invocation takes precedence. If called from
+		/// a subclass of Event interface only the values specified in the
+		/// initEvent method are modified, all other attributes are left unchanged.
 
 	void autoRelease();
 
@@ -141,7 +141,7 @@ private:
 	bool         _cancelable;
 	bool         _canceled;
 	bool         _stopped;
-	
+
 	friend class AbstractNode;
 };
 

vendor/POCO/XML/include/Poco/DOM/EventDispatcher.h

@@ -43,13 +43,13 @@ class XML_API EventDispatcher
 public:
 	EventDispatcher();
 		/// Creates the EventDispatcher.
-		
+
 	~EventDispatcher();
 		/// Destroys the EventDispatcher.
-		
+
 	void addEventListener(const XMLString& type, EventListener* listener, bool useCapture);
 		/// Adds an EventListener to the internal list.
-		
+
 	void removeEventListener(const XMLString& type, EventListener* listener, bool useCapture);
 		/// Removes an EventListener from the internal list.
 		///
@@ -61,19 +61,19 @@ public:
 	void dispatchEvent(Event* evt);
 		/// Dispatches the event.
 		///
-		/// Also removes all EventListeners marked for deletion from the 
+		/// Also removes all EventListeners marked for deletion from the
 		/// event dispatcher list.
-		
+
 	void captureEvent(Event* evt);
 		/// Dispatches the event in its capturing phase.
 		///
-		/// Also removes all EventListeners marked for deletion from the 
+		/// Also removes all EventListeners marked for deletion from the
 		/// event dispatcher list.
-		
+
 	void bubbleEvent(Event* evt);
 		/// Dispatches the event in its bubbling phase.
 		///
-		/// Also removes all EventListeners marked for deletion from the 
+		/// Also removes all EventListeners marked for deletion from the
 		/// event dispatcher list.
 
 private:
@@ -85,7 +85,7 @@ private:
 	};
 
 	typedef std::list<EventListenerItem> EventListenerList;
-	
+
 	int               _inDispatch;
 	EventListenerList _listeners;
 };

vendor/POCO/XML/include/Poco/DOM/EventException.h

@@ -27,15 +27,15 @@ namespace XML {
 
 
 class XML_API EventException: public XMLException
-	/// Event operations may throw an EventException as 
+	/// Event operations may throw an EventException as
 	/// specified in their method descriptions.
 {
 public:
 	enum
 	{
-		UNSPECIFIED_EVENT_TYPE_ERR = 0  /// If the Event's type was not specified by initializing the 
+		UNSPECIFIED_EVENT_TYPE_ERR = 0  /// If the Event's type was not specified by initializing the
 		                                /// event before the method was called. Specification of the Event's
-                                        /// type as null or an empty string will also trigger this exception. 
+                                        /// type as null or an empty string will also trigger this exception.
 	};
 
 	EventException(int code);
@@ -60,7 +60,7 @@ public:
 
 protected:
 	Poco::Exception* clone() const;
-	
+
 private:
 	EventException();
 };

vendor/POCO/XML/include/Poco/DOM/EventListener.h

@@ -35,7 +35,7 @@ class XML_API EventListener
 	/// EventTarget using the AddEventListener method. The users should also remove
 	/// their EventListener from its EventTarget after they have completed using
 	/// the listener.
-	/// 
+	///
 	/// When a Node is copied using the cloneNode method the EventListeners attached
 	/// to the source Node are not attached to the copied Node. If the user wishes
 	/// the same EventListeners to be added to the newly created copy the user must
@@ -43,7 +43,7 @@ class XML_API EventListener
 {
 public:
 	virtual void handleEvent(Event* evt) = 0;
-		/// This method is called whenever an event occurs of the 
+		/// This method is called whenever an event occurs of the
 		/// type for which the EventListener interface was registered.
 
 protected:

vendor/POCO/XML/include/Poco/DOM/EventTarget.h

@@ -40,30 +40,30 @@ class XML_API EventTarget: public DOMObject
 {
 public:
 	virtual void addEventListener(const XMLString& type, EventListener* listener, bool useCapture) = 0;
-		/// This method allows the registration of event listeners on 
+		/// This method allows the registration of event listeners on
 		/// the event target. If an EventListener is added to an
-		/// EventTarget while it is processing an event, it will not 
+		/// EventTarget while it is processing an event, it will not
 		/// be triggered by the current actions but may be triggered
 		/// during a later stage of event flow, such as the bubbling phase.
-		/// If multiple identical EventListeners are registered on the same 
-		/// EventTarget with the same parameters the duplicate instances are 
+		/// If multiple identical EventListeners are registered on the same
+		/// EventTarget with the same parameters the duplicate instances are
 		/// discarded. They do not cause the EventListener to be called twice and since they are
-		/// discarded they do not need to be removed with the removeEventListener method. 	
-	
+		/// discarded they do not need to be removed with the removeEventListener method.
+
 	virtual void removeEventListener(const XMLString& type, EventListener* listener, bool useCapture) = 0;
-		/// This method allows the removal of event listeners from the event 
-		/// target. If an EventListener is removed from an EventTarget while it is 
-		/// processing an event, it will not be triggered by the current actions. 
+		/// This method allows the removal of event listeners from the event
+		/// target. If an EventListener is removed from an EventTarget while it is
+		/// processing an event, it will not be triggered by the current actions.
 		/// EventListeners can never be invoked after being removed.
-		/// Calling removeEventListener with arguments which do not identify 
-		/// any currently registered EventListener on the EventTarget has no effect. 
+		/// Calling removeEventListener with arguments which do not identify
+		/// any currently registered EventListener on the EventTarget has no effect.
 
 	virtual bool dispatchEvent(Event* evt) = 0;
-		/// This method allows the dispatch of events into the implementations 
-		/// event model. Events dispatched in this manner will have the same capturing and 
+		/// This method allows the dispatch of events into the implementations
+		/// event model. Events dispatched in this manner will have the same capturing and
 		/// bubbling behavior as events dispatched directly by the
-		/// implementation. The target of the event is the EventTarget on 
-		/// which dispatchEvent is called. 
+		/// implementation. The target of the event is the EventTarget on
+		/// which dispatchEvent is called.
 
 protected:
 	virtual ~EventTarget();

vendor/POCO/XML/include/Poco/DOM/MutationEvent.h

@@ -30,49 +30,49 @@ class Node;
 
 
 class XML_API MutationEvent: public Event
-	/// The MutationEvent interface provides specific contextual 
+	/// The MutationEvent interface provides specific contextual
 	/// information associated with Mutation events.
 {
 public:
 	enum AttrChangeType
 	{
 		MODIFICATION = 1, /// The Attr was modified in place.
-		ADDITION     = 2, /// The Attr was just added. 
-		REMOVAL      = 3  /// The Attr was just removed. 
+		ADDITION     = 2, /// The Attr was just added.
+		REMOVAL      = 3  /// The Attr was just removed.
 	};
 
 	Node* relatedNode() const;
-		/// relatedNode is used to identify a secondary node related to a mutation 
+		/// relatedNode is used to identify a secondary node related to a mutation
 		/// event. For example, if a mutation event is dispatched
-		/// to a node indicating that its parent has changed, the relatedNode is the 
+		/// to a node indicating that its parent has changed, the relatedNode is the
 		/// changed parent. If an event is instead dispatched to a
-		/// subtree indicating a node was changed within it, the relatedNode is 
+		/// subtree indicating a node was changed within it, the relatedNode is
 		/// the changed node. In the case of the DOMAttrModified
 		/// event it indicates the Attr node which was modified, added, or removed.
 
 	const XMLString& prevValue() const;
-		/// prevValue indicates the previous value of the Attr node in DOMAttrModified 
+		/// prevValue indicates the previous value of the Attr node in DOMAttrModified
 		/// events, and of the CharacterData node in DOMCharDataModified events.
 
 	const XMLString& newValue() const;
-		/// newValue indicates the new value of the Attr node in DOMAttrModified 
+		/// newValue indicates the new value of the Attr node in DOMAttrModified
 		/// events, and of the CharacterData node in DOMCharDataModified events.
 
 	const XMLString& attrName() const;
 		/// attrName indicates the name of the changed Attr node in a DOMAttrModified event.
 
 	AttrChangeType attrChange() const;
-		/// attrChange indicates the type of change which triggered the 
+		/// attrChange indicates the type of change which triggered the
 		/// DOMAttrModified event. The values can be MODIFICATION,
 		/// ADDITION, or REMOVAL.
 
-	void initMutationEvent(const XMLString& type, bool canBubble, bool cancelable, Node* relatedNode, 
+	void initMutationEvent(const XMLString& type, bool canBubble, bool cancelable, Node* relatedNode,
 	                       const XMLString& prevValue, const XMLString& newValue, const XMLString& attrName, AttrChangeType change);
-		/// The initMutationEvent method is used to initialize the value of a 
+		/// The initMutationEvent method is used to initialize the value of a
 		/// MutationEvent created through the DocumentEvent
-		/// interface. This method may only be called before the MutationEvent 
+		/// interface. This method may only be called before the MutationEvent
 		/// has been dispatched via the dispatchEvent method,
-		/// though it may be called multiple times during that phase if 
+		/// though it may be called multiple times during that phase if
 		/// necessary. If called multiple times, the final invocation takes
 		/// precedence.
 
@@ -88,7 +88,7 @@ public:
 protected:
 	MutationEvent(Document* pOwnerDocument, const XMLString& type);
 	MutationEvent(Document* pOwnerDocument, const XMLString& type, EventTarget* pTarget, bool canBubble, bool cancelable, Node* relatedNode);
-	MutationEvent(Document* pOwnerDocument, const XMLString& type, EventTarget* pTarget, bool canBubble, bool cancelable, Node* relatedNode, 
+	MutationEvent(Document* pOwnerDocument, const XMLString& type, EventTarget* pTarget, bool canBubble, bool cancelable, Node* relatedNode,
 				  const XMLString& prevValue, const XMLString& newValue, const XMLString& attrName, AttrChangeType change);
 	~MutationEvent();
 

vendor/POCO/XML/include/Poco/DOM/NamedNodeMap.h

@@ -41,7 +41,7 @@ class XML_API NamedNodeMap: public DOMObject
 	///
 	/// NamedNodeMap objects in the DOM are live.
 	///
-	/// A NamedNodeMap returned from a method must be released with a call to 
+	/// A NamedNodeMap returned from a method must be released with a call to
 	/// release() when no longer needed.
 {
 public:
@@ -69,19 +69,19 @@ public:
 	virtual unsigned long length() const = 0;
 		/// Returns the number of nodes in the map. The range of valid
 		/// child node indices is 0 to length - 1 inclusive.
-	
+
 	// DOM Level 2
 	virtual Node* getNamedItemNS(const XMLString& namespaceURI, const XMLString& localName) const = 0;
 		/// Retrieves a node specified by name.
 
 	virtual Node* setNamedItemNS(Node* arg) = 0;
 		/// Adds a node using its nodeName attribute.
-		/// If a node with that namespace URI and that local name is already 
+		/// If a node with that namespace URI and that local name is already
 		/// present in this map, it is replaced by the new one.
 
 	virtual Node* removeNamedItemNS(const XMLString& namespaceURI, const XMLString& localName) = 0;
 		/// Removes a node specified by name.
-	
+
 protected:
 	virtual ~NamedNodeMap();
 };

vendor/POCO/XML/include/Poco/DOM/Node.h

@@ -40,7 +40,7 @@ class XML_API Node: public EventTarget
 	/// not all objects implementing the Node interface may have children. For
 	/// example, Text nodes may not have children, and adding children to such
 	/// nodes results in a DOMException being raised.
-	/// 
+	///
 	/// The attributes nodeName, nodeValue and attributes are included as a mechanism
 	/// to get at node information without casting down to the specific derived
 	/// interface. In cases where there is no obvious mapping of these attributes
@@ -117,7 +117,7 @@ public:
 	virtual NamedNodeMap* attributes() const = 0;
 		/// Returns a NamedNodeMap containing the attributes of this
 		/// node (if it is an Element) or null otherwise.
-		/// 
+		///
 		/// The returned NamedNodeMap must be released with a call
 		/// to release() when no longer needed.
 
@@ -143,14 +143,14 @@ public:
 
 	virtual Node* removeChild(Node* oldChild) = 0;
 		/// Removes the child node indicated by oldChild from the list of children
-		/// and returns it. 
+		/// and returns it.
 
 	virtual Node* appendChild(Node* newChild) = 0;
 		/// Appends the node newChild to the end of the list of children of this node.
 		/// If newChild is already in the tree, it is first removed.
 
 	virtual bool hasChildNodes() const = 0;
-		/// This is a convenience method to allow easy determination of whether a 
+		/// This is a convenience method to allow easy determination of whether a
 		/// node has any children.
 		/// Returns true if the node has any children, false otherwise.
 
@@ -168,7 +168,7 @@ public:
 		/// children of an EntityReference clone are readonly. In addition, clones of
 		/// unspecified Attr nodes are specified. And, cloning Document, DocumentType,
 		/// Entity, and Notation nodes is implementation dependent.
-	
+
 	// DOM Level 2
 	virtual void normalize() = 0;
 		/// Puts all Text nodes in the full depth of the sub-tree underneath this Node,
@@ -179,22 +179,22 @@ public:
 		/// of a document is the same as if it were saved and re-loaded, and is useful
 		/// when operations (such as XPointer lookups) that depend on a particular
 		/// document tree structure are to be used.
-		/// 
+		///
 		/// Note: In cases where the document contains CDATASections, the normalize
 		/// operation alone may not be sufficient, since XPointers do not differentiate
 		/// between Text nodes and CDATASection nodes.
 
 	virtual bool isSupported(const XMLString& feature, const XMLString& version) const = 0;
-		/// Tests whether the DOM implementation implements a specific 
+		/// Tests whether the DOM implementation implements a specific
 		/// feature and that feature is supported by this node.
 
 	virtual const XMLString& namespaceURI() const = 0;
 		/// Returns the namespace URI of the node.
-		/// This is not a computed value that is the result of a namespace lookup based on an 
-		/// examination of the namespace declarations in scope. It is merely the namespace URI 
+		/// This is not a computed value that is the result of a namespace lookup based on an
+		/// examination of the namespace declarations in scope. It is merely the namespace URI
 		/// given at creation time.
 		///
-		/// For nodes of any type other than ELEMENT_NODE and ATTRIBUTE_NODE and nodes created with a 
+		/// For nodes of any type other than ELEMENT_NODE and ATTRIBUTE_NODE and nodes created with a
 		/// DOM Level 1 method, such as createElement from the Document interface, this is always the
 		/// empty string.
 
@@ -206,27 +206,27 @@ public:
 
 	virtual bool hasAttributes() const = 0;
 		/// Returns whether this node (if it is an element) has any attributes.
-		
+
 	// Extensions
 	using NSMap = Poco::XML::NamespaceSupport;
 
 	virtual XMLString innerText() const = 0;
 		/// Returns a string containing the concatenated values of the node
-		/// and all its child nodes. 
+		/// and all its child nodes.
 		///
 		/// This method is not part of the W3C Document Object Model.
-		
+
 	virtual Node* getNodeByPath(const XMLString& path) const = 0;
-		/// Searches a node (element or attribute) based on a simplified XPath 
+		/// Searches a node (element or attribute) based on a simplified XPath
 		/// expression.
 		///
 		/// Only simple XPath expressions are supported. These are the slash
 		/// notation for specifying paths to elements, and the square bracket
-		/// expression for finding elements by their index, by attribute value, 
+		/// expression for finding elements by their index, by attribute value,
 		/// or finding attributes by names.
 		///
 		/// The slash at the beginning is optional, the evaluation always starts
-		/// at this element. A double-slash at the beginning recursively searches 
+		/// at this element. A double-slash at the beginning recursively searches
 		/// the entire subtree for the first element.
 		///
 		/// Examples:
@@ -241,18 +241,18 @@ public:
 		/// This method is an extension to the W3C Document Object Model.
 
 	virtual Node* getNodeByPathNS(const XMLString& path, const NSMap& nsMap) const = 0;
-		/// Searches a node (element or attribute) based on a simplified XPath 
+		/// Searches a node (element or attribute) based on a simplified XPath
 		/// expression. The given NSMap must contain mappings from namespace
-		/// prefixes to namespace URIs for all namespace prefixes used in 
+		/// prefixes to namespace URIs for all namespace prefixes used in
 		/// the path expression.
 		///
 		/// Only simple XPath expressions are supported. These are the slash
 		/// notation for specifying paths to elements, and the square bracket
-		/// expression for finding elements by their index, by attribute value, 
+		/// expression for finding elements by their index, by attribute value,
 		/// or finding attributes by names.
 		///
 		/// The slash at the beginning is optional, the evaluation always starts
-		/// at this element. A double-slash at the beginning recursively searches 
+		/// at this element. A double-slash at the beginning recursively searches
 		/// the entire subtree for the first element.
 		///
 		/// Examples:

vendor/POCO/XML/include/Poco/DOM/NodeAppender.h

@@ -37,7 +37,7 @@ class XML_API NodeAppender
 	/// In the DOM, child nodes are usually appended to a parent
 	/// node using the appendChild() method. For nodes containing
 	/// more than a few children, this method can be quite slow,
-	/// due to the way it's implemented, and because of the 
+	/// due to the way it's implemented, and because of the
 	/// requirements of the DOM specification.
 	///
 	/// While the NodeAppender is being used on an Element, no
@@ -68,7 +68,7 @@ private:
 	NodeAppender();
 	NodeAppender(const NodeAppender&);
 	NodeAppender& operator = (const NodeAppender&);
-	
+
 	Element*      _pParent;
 	AbstractNode* _pLast;
 };

vendor/POCO/XML/include/Poco/DOM/NodeFilter.h

@@ -35,10 +35,10 @@ class XML_API NodeFilter
 	/// the next node. If the filter says to accept the node, the traversal logic
 	/// returns it; otherwise, traversal looks for the next node and pretends that
 	/// the node that was rejected was not there.
-	/// 
+	///
 	/// The DOM does not provide any filters. NodeFilter is just an interface that
 	/// users can implement to provide their own filters.
-	/// 
+	///
 	/// NodeFilters do not need to know how to traverse from node to node, nor do
 	/// they need to know anything about the data structure that is being traversed.
 	/// This makes it very easy to write filters, since the only thing they have
@@ -61,7 +61,7 @@ public:
 			/// will not return this node. For both NodeIterator and TreeWalker, the children
 			/// of this node will still be considered.
 	};
-	
+
 	enum WhatToShow
 		/// These are the available values for the whatToShow parameter used in TreeWalkers
 		/// and NodeIterators. They are the same as the set of possible types for Node,
@@ -69,18 +69,18 @@ public:
 		/// value of nodeType for the equivalent node type. If a bit in whatToShow is
 		/// set false, that will be taken as a request to skip over this type of node;
 		/// the behavior in that case is similar to that of FILTER_SKIP.
-		/// 
+		///
 		/// Note that if node types greater than 32 are ever introduced, they may not
 		/// be individually testable via whatToShow. If that need should arise, it can
 		/// be handled by selecting SHOW_ALL together with an appropriate NodeFilter.
 	{
 		SHOW_ALL                    = 0xFFFFFFFF,
 			/// Show all Nodes.
-	
+
 		SHOW_ELEMENT                = 0x00000001,
 			/// Show Element nodes.
 
-		SHOW_ATTRIBUTE              = 0x00000002, 
+		SHOW_ATTRIBUTE              = 0x00000002,
 			/// Show Attr nodes. This is meaningful only when creating an iterator or tree-walker
 			/// with an attribute node as its root; in this case, it means that the attribute
 			/// node will appear in the first position of the iteration or traversal. Since
@@ -125,7 +125,7 @@ public:
 			/// notations are not part of the document tree, they do not appear when traversing
 			/// over the document tree.
 	};
-	
+
 	virtual short acceptNode(Node* node) = 0;
 		/// Test whether a specified node is visible in the logical view of a TreeWalker
 		/// or NodeIterator. This function will be called by the implementation of TreeWalker
@@ -134,7 +134,7 @@ public:
 		/// logic.)
 		///
 		/// Returns FILTER_ACCEPT, FILTER_REJECT or FILTER_SKIP.
-		
+
 protected:
 	virtual ~NodeFilter();
 };

vendor/POCO/XML/include/Poco/DOM/NodeIterator.h

@@ -48,13 +48,13 @@ class XML_API NodeIterator
 public:
 	NodeIterator(Node* root, unsigned long whatToShow, NodeFilter* pFilter = 0);
 		/// Creates a NodeIterator over the subtree rooted at the specified node.
-		
+
 	NodeIterator(const NodeIterator& iterator);
 		/// Creates a NodeIterator by copying another NodeIterator.
-		
+
 	NodeIterator& operator = (const NodeIterator& iterator);
 		/// Assignment operator.
-		
+
 	~NodeIterator();
 		/// Destroys the NodeIterator.
 
@@ -62,10 +62,10 @@ public:
 		/// The root node of the NodeIterator, as specified when it was created.
 
 	unsigned long whatToShow() const;
-		/// This attribute determines which node types are presented via the iterator. 
-		/// The available set of constants is defined in the NodeFilter interface. 
-		/// Nodes not accepted by whatToShow will be skipped, but their children may 
-		/// still be considered. Note that this skip takes precedence over the filter, 
+		/// This attribute determines which node types are presented via the iterator.
+		/// The available set of constants is defined in the NodeFilter interface.
+		/// Nodes not accepted by whatToShow will be skipped, but their children may
+		/// still be considered. Note that this skip takes precedence over the filter,
 		/// if any.
 
 	NodeFilter* filter() const;
@@ -78,7 +78,7 @@ public:
 		/// and the filter. Also note that this is currently the only situation where
 		/// NodeIterators may reject a complete subtree rather than skipping individual
 		/// nodes.
-		/// 
+		///
 		/// To produce a view of the document that has entity references expanded and
 		/// does not expose the entity reference node itself, use the whatToShow flags
 		/// to hide the entity reference node and set expandEntityReferences to true
@@ -120,7 +120,7 @@ protected:
 
 private:
 	NodeIterator();
-	
+
 	Node*         _pRoot;
 	unsigned long _whatToShow;
 	NodeFilter*   _pFilter;

vendor/POCO/XML/include/Poco/DOM/NodeList.h

@@ -34,10 +34,10 @@ class XML_API NodeList: public DOMObject
 	/// collection of nodes, without defining or constraining how this
 	/// collection is implemented.
 	///
-	/// The items in the NodeList are accessible via an integral index, 
+	/// The items in the NodeList are accessible via an integral index,
 	/// starting from 0.
 	///
-	/// A NodeList returned from a method must be released with a call to 
+	/// A NodeList returned from a method must be released with a call to
 	/// release() when no longer needed.
 {
 public:
@@ -49,7 +49,7 @@ public:
 	virtual unsigned long length() const = 0;
 		/// Returns the number of nodes in the list. The range of valid
 		/// node indices is 0 to length - 1 inclusive.
-	
+
 protected:
 	virtual ~NodeList();
 };

vendor/POCO/XML/include/Poco/DOM/Notation.h

@@ -30,15 +30,15 @@ namespace XML {
 class XML_API Notation: public AbstractNode
 	/// This interface represents a notation declared in the DTD. A notation either
 	/// declares, by name, the format of an unparsed entity (see section 4.7 of
-	/// the XML 1.0 specification <http://www.w3.org/TR/2004/REC-xml-20040204/>), 
+	/// the XML 1.0 specification <http://www.w3.org/TR/2004/REC-xml-20040204/>),
 	/// or is used for formal declaration of processing
 	/// instruction targets (see section 2.6 of the XML 1.0 specification).
 	/// The nodeName attribute inherited from Node is set to the declared name of
 	/// the notation.
-	/// 
+	///
 	/// The DOM Level 1 does not support editing Notation nodes; they are therefore
 	/// readonly.
-	/// 
+	///
 	/// A Notation node does not have any parent.
 {
 public:
@@ -60,14 +60,14 @@ protected:
 	Notation(Document* pOwnerDocument, const XMLString& name, const XMLString& publicId, const XMLString& systemId);
 	Notation(Document* pOwnerDocument, const Notation& notation);
 	~Notation();
-	
+
 	Node* copyNode(bool deep, Document* pOwnerDocument) const;
 
 private:
 	XMLString _name;
 	XMLString _publicId;
 	XMLString _systemId;
-	
+
 	friend class Document;
 };
 

vendor/POCO/XML/include/Poco/DOM/ProcessingInstruction.h

@@ -39,12 +39,12 @@ public:
 		/// the markup that begins the processing instruction.
 
 	const XMLString& data() const;
-		/// Returns the content of this processing instruction. This is from the first non 
+		/// Returns the content of this processing instruction. This is from the first non
 		/// white space character after the target to the character immediately preceding
 		/// the ?>.
 
 	const XMLString& getData() const;
-		/// Returns the content of this processing instruction. This is from the first non 
+		/// Returns the content of this processing instruction. This is from the first non
 		/// white space character after the target to the character immediately preceding
 		/// the ?>.
 
@@ -67,7 +67,7 @@ protected:
 private:
 	XMLString _target;
 	XMLString _data;
-	
+
 	friend class Document;
 };
 

vendor/POCO/XML/include/Poco/DOM/Text.h

@@ -34,7 +34,7 @@ class XML_API Text: public CharacterData
 	/// object implementing the Text interface that is the only child of the element.
 	/// If there is markup, it is parsed into the information items (elements, comments,
 	/// etc.) and Text nodes that form the list of children of the element.
-	/// 
+	///
 	/// When a document is first made available via the DOM, there is only one Text
 	/// node for each block of text. Users may create adjacent Text nodes that represent
 	/// the contents of a given element without any intervening markup, but should
@@ -68,7 +68,7 @@ protected:
 
 private:
 	static const XMLString NODE_NAME;
-	
+
 	friend class Document;
 };
 

vendor/POCO/XML/include/Poco/DOM/TreeWalker.h

@@ -35,7 +35,7 @@ class XML_API TreeWalker
 	/// the view of the document defined by their whatToShow flags and filter (if
 	/// any). Any function which performs navigation using a TreeWalker will automatically
 	/// support any view defined by a TreeWalker.
-	/// 
+	///
 	/// Omitting nodes from the logical view of a subtree can result in a structure
 	/// that is substantially different from the same subtree in the complete, unfiltered
 	/// document. Nodes that are siblings in the TreeWalker view may be children
@@ -50,22 +50,22 @@ class XML_API TreeWalker
 	/// Unlike most other DOM classes, TreeWalker supports value semantics.
 	///
 	/// If the TreeWalker's current node is removed from the document, the
-	/// result of calling any of the movement methods is undefined. This behavior 
+	/// result of calling any of the movement methods is undefined. This behavior
 	/// does not conform to the DOM Level 2 Traversal specification.
 {
 public:
 	TreeWalker(Node* root, unsigned long whatToShow, NodeFilter* pFilter = 0);
 		/// Creates a TreeWalker over the subtree rooted at the specified node.
-		
+
 	TreeWalker(const TreeWalker& walker);
 		/// Creates a TreeWalker by copying another TreeWalker.
-		
+
 	TreeWalker& operator = (const TreeWalker& walker);
 		/// Assignment operator.
-	
+
 	~TreeWalker();
 		/// Destroys the TreeWalker.
-	
+
 	Node* root() const;
 		/// The root node of the TreeWalker, as specified when it was created.
 
@@ -86,7 +86,7 @@ public:
 		/// and the filter. Also note that this is currently the only situation where
 		/// NodeIterators may reject a complete subtree rather than skipping individual
 		/// nodes.
-		/// 
+		///
 		/// To produce a view of the document that has entity references expanded and
 		/// does not expose the entity reference node itself, use the whatToShow flags
 		/// to hide the entity reference node and set expandEntityReferences to true
@@ -109,7 +109,7 @@ public:
 
 	Node* getCurrentNode() const;
 		/// See currentNode().
-		
+
 	void setCurrentNode(Node* pNode);
 		/// Sets the current node.
 
@@ -158,7 +158,7 @@ protected:
 
 private:
 	TreeWalker();
-	
+
 	Node*         _pRoot;
 	unsigned long _whatToShow;
 	NodeFilter*   _pFilter;