intermediate changes

ref:cde9a383711a11544ce7e107a78147fb96cc4029

41 files changed, 4683 insertions, 0 deletions

diff --git a/contrib/libs/poco/XML/include/Poco/DOM/AbstractContainerNode.h b/contrib/libs/poco/XML/include/Poco/DOM/AbstractContainerNode.h
new file mode 100644
index 0000000000..60dc9589d7
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/AbstractContainerNode.h
@@ -0,0 +1,78 @@
+//
+// AbstractContainerNode.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the AbstractContainerNode class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_AbstractContainerNode_INCLUDED
+#define DOM_AbstractContainerNode_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractNode.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API AbstractContainerNode: public AbstractNode
+	/// AbstractContainerNode is an implementation of Node
+	/// that stores and manages child nodes.
+	///
+	/// Child nodes are organized in a single linked list.
+{
+public:
+	// Node
+	Node* firstChild() const;
+	Node* lastChild() const;
+	Node* insertBefore(Node* newChild, Node* refChild);
+	Node* replaceChild(Node* newChild, Node* oldChild);
+	Node* removeChild(Node* oldChild);
+	Node* appendChild(Node* newChild);
+	bool hasChildNodes() const;
+	bool hasAttributes() const;
+	Node* getNodeByPath(const XMLString& path) const;
+	Node* getNodeByPathNS(const XMLString& path, const NSMap& nsMap) const;
+
+protected:
+	AbstractContainerNode(Document* pOwnerDocument);
+	AbstractContainerNode(Document* pOwnerDocument, const AbstractContainerNode& node);
+	~AbstractContainerNode();
+
+	void dispatchNodeRemovedFromDocument();
+	void dispatchNodeInsertedIntoDocument();
+	
+	static const Node* findNode(XMLString::const_iterator& it, const XMLString::const_iterator& end, const Node* pNode, const NSMap* pNSMap);
+	static const Node* findElement(const XMLString& name, const Node* pNode, const NSMap* pNSMap);
+	static const Node* findElement(int index, const Node* pNode, const NSMap* pNSMap);
+	static const Node* findElement(const XMLString& attr, const XMLString& value, const Node* pNode, const NSMap* pNSMap);
+	static const Attr* findAttribute(const XMLString& name, const Node* pNode, const NSMap* pNSMap);
+	bool hasAttributeValue(const XMLString& name, const XMLString& value, const NSMap* pNSMap) const;
+	static bool namesAreEqual(const Node* pNode1, const Node* pNode2, const NSMap* pNSMap);
+	static bool namesAreEqual(const Node* pNode, const XMLString& name, const NSMap* pNSMap);
+
+	static const XMLString WILDCARD;
+
+private:
+	AbstractNode* _pFirstChild;
+
+	friend class AbstractNode;
+	friend class NodeAppender;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_AbstractContainerNode_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/AbstractNode.h b/contrib/libs/poco/XML/include/Poco/DOM/AbstractNode.h
new file mode 100644
index 0000000000..cedcc73920
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/AbstractNode.h
@@ -0,0 +1,125 @@
+//
+// AbstractNode.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the AbstractNode class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_AbstractNode_INCLUDED
+#define DOM_AbstractNode_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/Node.h"
+#include "Poco/DOM/MutationEvent.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class AbstractContainerNode;
+class Attr;
+class EventDispatcher;
+
+
+class XML_API AbstractNode: public Node
+	/// AbstractNode provides a basic implementation
+	/// of the Node interface for all types of nodes
+	/// that do not contain other nodes.
+{
+public:
+	// Node
+	const XMLString& nodeName() const;
+	const XMLString& getNodeValue() const;
+	void setNodeValue(const XMLString& value);
+	Node* parentNode() const;
+	NodeList* childNodes() const;
+	Node* firstChild() const;
+	Node* lastChild() const;
+	Node* previousSibling() const;
+	Node* nextSibling() const;
+	NamedNodeMap* attributes() const;
+	Document* ownerDocument() const;
+	Node* insertBefore(Node* newChild, Node* refChild);
+	Node* replaceChild(Node* newChild, Node* oldChild);
+	Node* removeChild(Node* oldChild);
+	Node* appendChild(Node* newChild);
+	bool hasChildNodes() const;
+	Node* cloneNode(bool deep) const;
+	void normalize();
+	bool isSupported(const XMLString& feature, const XMLString& version) const;
+	const XMLString& namespaceURI() const;
+	XMLString prefix() const;
+	const XMLString& localName() const;
+	bool hasAttributes() const;
+
+	// EventTarget
+	void addEventListener(const XMLString& type, EventListener* listener, bool useCapture);
+	void removeEventListener(const XMLString& type, EventListener* listener, bool useCapture);
+	bool dispatchEvent(Event* evt);
+
+	// Extensions
+	XMLString innerText() const;
+	Node* getNodeByPath(const XMLString& path) const;
+	Node* getNodeByPathNS(const XMLString& path, const NSMap& nsMap) const;
+
+	virtual void autoRelease();
+
+protected:
+	AbstractNode(Document* pOwnerDocument);
+	AbstractNode(Document* pOwnerDocument, const AbstractNode& node);
+	~AbstractNode();
+
+	virtual Node* copyNode(bool deep, Document* pOwnerDocument) const = 0;
+
+	virtual bool events() const;
+	virtual bool eventsSuspended() const;
+	void captureEvent(Event* evt);
+	void bubbleEvent(Event* evt);
+	void dispatchSubtreeModified();
+	void dispatchNodeInserted();
+	void dispatchNodeRemoved();
+	virtual void dispatchNodeRemovedFromDocument();
+	virtual void dispatchNodeInsertedIntoDocument();
+	void dispatchAttrModified(Attr* pAttr, MutationEvent::AttrChangeType changeType, const XMLString& prevValue, const XMLString& newValue);
+	void dispatchCharacterDataModified(const XMLString& prevValue, const XMLString& newValue);
+	void setOwnerDocument(Document* pOwnerDocument);
+
+	static const XMLString EMPTY_STRING;
+
+private:
+	AbstractNode();
+
+	AbstractContainerNode* _pParent;
+	AbstractNode*          _pNext;
+	Document*              _pOwner;
+	EventDispatcher*       _pEventDispatcher;
+
+	static const XMLString NODE_NAME;
+
+	friend class AbstractContainerNode;
+	friend class Document;
+	friend class DocumentFragment;
+	friend class Element;
+	friend class Attr;
+	friend class CharacterData;
+	friend class DOMBuilder;
+	friend class NodeAppender;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_AbstractNode_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/Attr.h b/contrib/libs/poco/XML/include/Poco/DOM/Attr.h
new file mode 100644
index 0000000000..13ace7ecce
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/Attr.h
@@ -0,0 +1,180 @@
+//
+// Attr.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Attr class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Attr_INCLUDED
+#define DOM_Attr_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractNode.h"
+#include "Poco/DOM/Element.h"
+#include "Poco/XML/Name.h"
+
+
+namespace Poco {
+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,
+	/// and nextSibling have a null value for Attr objects. The DOM takes the view
+	/// that attributes are properties of elements rather than having a separate
+	/// identity from the elements they are associated with; this should make it
+	/// more efficient to implement such features as default attributes associated
+	/// with all elements of a given type. Furthermore, Attr nodes may not be immediate
+	/// children of a DocumentFragment. However, they can be associated with Element
+	/// 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
+	/// declaration includes a default value, then that default value is the attribute's
+	/// effective value; otherwise, the attribute does not exist on this element
+	/// 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
+	/// nodes. Because the attribute type may be unknown, there are no tokenized
+	/// attribute values.
+{
+public:
+	const XMLString& name() const;
+		/// Returns the name of this attribute.
+
+	bool specified() const;
+		/// If this attribute was explicitly given a value in the original document,
+		/// this is true; otherwise, it is false. Note that the implementation is in
+		/// charge of this attribute, not the user. If the user changes the value of
+		/// the attribute (even if it ends up having the same value as the default value)
+		/// then the specified flag is automatically flipped to true. To re-specify
+		/// the attribute as the default value from the DTD, the user must delete the
+		/// 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
+		///       value in the DTD, then specified is false, and the value is the default
+		///       value in the DTD.
+		///     * If the attribute has no assigned value in the document and has a value
+		///       of #IMPLIED in the DTD, then the attribute does not appear in the structure
+		///       model of the document.
+		///     * If the attribute is not associated to any element (i.e. because it
+		///       was just created or was obtained from some removal or cloning operation)
+		///       specified is true.
+
+	const XMLString& value() const;
+		/// Returns the value of the attribute as a string. Character
+		/// and general entity references are replaced with their values. See also the
+		/// method getAttribute on the Element interface.
+
+	const XMLString& getValue() const;
+		/// Returns the value of the attribute as a string. Character
+		/// and general entity references are replaced with their values. See also the
+		/// method getAttribute on the Element interface.
+
+	void setValue(const XMLString& value);
+		/// Sets the value of the attribute as a string.
+		/// This creates a Text node with the unparsed contents of the string.
+		/// I.e. any characters that an XML processor would recognize as markup are
+		/// instead treated as literal text. See also the method setAttribute on the
+		/// Element interface.
+
+	// DOM Level 2
+	Element* ownerElement() const;
+		/// The Element node this attribute is attached to or null 
+		/// if this attribute is not in use.
+
+	// Node
+	Node* parentNode() const;
+	const XMLString& nodeName() const;
+	const XMLString& getNodeValue() const;
+	void setNodeValue(const XMLString& value);
+	unsigned short nodeType() const;
+	Node* previousSibling() const;
+	const XMLString& namespaceURI() const;
+	XMLString prefix() const;
+	const XMLString& localName() const;
+
+	// Non-standard extensions
+	XMLString innerText() const;
+
+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:
+	const Name& _name;
+	XMLString   _value;
+	bool        _specified;
+
+	friend class Document;
+	friend class Element;
+	friend class DOMBuilder;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& Attr::name() const
+{
+	return _name.qname();
+}
+
+
+inline const XMLString& Attr::value() const
+{
+	return _value;
+}
+
+
+inline const XMLString& Attr::getValue() const
+{
+	return _value;
+}
+
+
+inline bool Attr::specified() const
+{
+	return _specified;
+}
+
+
+inline Element* Attr::ownerElement() const
+{
+	return static_cast<Element*>(_pParent);
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Attr_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/AttrMap.h b/contrib/libs/poco/XML/include/Poco/DOM/AttrMap.h
new file mode 100644
index 0000000000..41f34fd638
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/AttrMap.h
@@ -0,0 +1,65 @@
+//
+// AttrMap.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the AttrMap class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_AttrMap_INCLUDED
+#define DOM_AttrMap_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/NamedNodeMap.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Element;
+
+
+class XML_API AttrMap: public NamedNodeMap
+	// This implementation of NamedNodeMap is
+	// returned by Element::attributes()
+{
+public:
+	Node* getNamedItem(const XMLString& name) const;
+	Node* setNamedItem(Node* arg);
+	Node* removeNamedItem(const XMLString& name);
+	Node* item(unsigned long index) const;
+	unsigned long length() const;
+
+	Node* getNamedItemNS(const XMLString& namespaceURI, const XMLString& localName) const;
+	Node* setNamedItemNS(Node* arg);
+	Node* removeNamedItemNS(const XMLString& namespaceURI, const XMLString& localName);
+
+	void autoRelease();
+
+protected:
+	AttrMap(Element* pElement);
+	~AttrMap();
+
+private:
+	AttrMap();
+
+	Element* _pElement;
+	
+	friend class Element;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_AttrMap_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/AutoPtr.h b/contrib/libs/poco/XML/include/Poco/DOM/AutoPtr.h
new file mode 100644
index 0000000000..85f83d49f7
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/AutoPtr.h
@@ -0,0 +1,35 @@
+//
+// AutoPtr.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Import Poco::AutoPtr into the XML namespace.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMAutoPtr_INCLUDED
+#define DOM_DOMAutoPtr_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/AutoPtr.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+using Poco::AutoPtr;
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMAutoPtr_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/CDATASection.h b/contrib/libs/poco/XML/include/Poco/DOM/CDATASection.h
new file mode 100644
index 0000000000..7a0e82b18a
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/CDATASection.h
@@ -0,0 +1,84 @@
+//
+// CDATASection.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM CDATASection class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_CDATASection_INCLUDED
+#define DOM_CDATASection_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/Text.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API CDATASection: public Text
+	/// CDATA sections are used to escape blocks of text containing characters that
+	/// would otherwise be regarded as markup. The only delimiter that is recognized
+	/// 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
+	/// encoding where some of the contained characters cannot be represented. Failure
+	/// to do so would not produce well-formed XML.
+	/// One potential solution in the serialization process is to end the CDATA
+	/// section before the character, output the character using a character reference
+	/// or entity reference, and open a new CDATA section for any further characters
+	/// in the text node. Note, however, that some code conversion libraries at
+	/// the time of writing do not return an error or exception when a character
+	/// is missing from the encoding, making the task of ensuring that data is not
+	/// corrupted on serialization more difficult.
+{
+public:
+	// Text
+	Text* splitText(unsigned long offset);
+
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+protected:
+	CDATASection(Document* pOwnerDocument, const XMLString& data);
+	CDATASection(Document* pOwnerDocument, const CDATASection& sec);
+	~CDATASection();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	static const XMLString NODE_NAME;
+	
+	friend class Document;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_CDATASection_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/CharacterData.h b/contrib/libs/poco/XML/include/Poco/DOM/CharacterData.h
new file mode 100644
index 0000000000..af5697da7f
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/CharacterData.h
@@ -0,0 +1,123 @@
+//
+// CharacterData.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM CharacterData class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_CharacterData_INCLUDED
+#define DOM_CharacterData_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractNode.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API CharacterData: public AbstractNode
+	/// The CharacterData interface extends Node with a set of attributes and methods
+	/// for accessing character data in the DOM. For clarity this set is defined
+	/// 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 
+		/// implements the interface.
+	
+	const XMLString& getData() const;
+		/// Returns the character data of the node that 
+		/// implements the interface.
+
+	void setData(const XMLString& data);
+		/// Sets the character data of the node that
+		/// implements the interface.
+
+	unsigned long length() const;
+		/// Returns the number of XMLChars that are available
+		/// through getData and substringData. This may have the
+		/// value zero.
+
+	XMLString substringData(unsigned long offset, unsigned long count) const;
+		/// Extracts a range of data from the node.
+		/// If offset and count exceeds the length, then all
+		/// the characters to the end of the data are returned.
+
+	void appendData(const XMLString& arg);
+		/// Append the string to the end of the character data
+		/// of the node.
+
+	void insertData(unsigned long offset, const XMLString& arg);
+		/// Insert a string at the specified character offset.
+
+	void deleteData(unsigned long offset, unsigned long count);
+		/// Remove a range of characters from the node.
+
+	void replaceData(unsigned long offset, unsigned long count, const XMLString& arg);
+		/// Replace the characters starting at the specified character
+		/// offset with the specified string.
+
+	// Non-standard extensions
+	XMLString trimmedData() const;
+		/// Returns the character data of that node with
+		/// all surrounding whitespace removed.
+		///
+		/// This method is an extension to the W3C Document Object Model.
+
+	// Node
+	const XMLString& getNodeValue() const;
+	void setNodeValue(const XMLString& value);
+
+protected:
+	CharacterData(Document* pOwnerDocument, const XMLString& data);
+	CharacterData(Document* pOwnerDocument, const CharacterData& data);
+	~CharacterData();
+
+private:
+	XMLString _data;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& CharacterData::data() const
+{
+	return _data;
+}
+
+
+inline const XMLString& CharacterData::getData() const
+{
+	return _data;
+}
+
+
+inline unsigned long CharacterData::length() const
+{
+	return (unsigned long) _data.length();
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_CharacterData_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/ChildNodesList.h b/contrib/libs/poco/XML/include/Poco/DOM/ChildNodesList.h
new file mode 100644
index 0000000000..aa7ece1db8
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/ChildNodesList.h
@@ -0,0 +1,55 @@
+//
+// ChildNodesList.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the ChildNodesList class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_ChildNodesList_INCLUDED
+#define DOM_ChildNodesList_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/NodeList.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API ChildNodesList: public NodeList
+	// This implementation of NodeList is returned
+	// by Node::getChildNodes().
+{
+public:
+	Node* item(unsigned long index) const;
+	unsigned long length() const;
+
+	void autoRelease();
+
+protected:
+	ChildNodesList(const Node* pParent);
+	~ChildNodesList();
+	
+private:
+	ChildNodesList();
+
+	const Node* _pParent;
+	
+	friend class AbstractNode;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_ChildNodesList_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/Comment.h b/contrib/libs/poco/XML/include/Poco/DOM/Comment.h
new file mode 100644
index 0000000000..d1de793064
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/Comment.h
@@ -0,0 +1,58 @@
+//
+// Comment.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Comment class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Comment_INCLUDED
+#define DOM_Comment_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/CharacterData.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API Comment: public CharacterData
+	/// This interface inherits from CharacterData and represents the content of
+	/// a comment, i.e., all the characters between the starting '<!--' and ending
+	/// '-->'. Note that this is the definition of a comment in XML, and, in practice,
+	/// HTML, although some HTML tools may implement the full SGML comment structure.
+{
+public:
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+protected:
+	Comment(Document* pOwnerDocument, const XMLString& data);
+	Comment(Document* pOwnerDocument, const Comment& comment);
+	~Comment();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	static const XMLString NODE_NAME;
+	
+	friend class Document;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Comment_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/DOMBuilder.h b/contrib/libs/poco/XML/include/Poco/DOM/DOMBuilder.h
new file mode 100644
index 0000000000..ad91da45f4
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/DOMBuilder.h
@@ -0,0 +1,112 @@
+//
+// DOMBuilder.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMBuilder
+//
+// Definition of the DOMBuilder class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMBuilder_INCLUDED
+#define DOM_DOMBuilder_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/SAX/ContentHandler.h"
+#include "Poco/SAX/LexicalHandler.h"
+#include "Poco/SAX/DTDHandler.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XMLReader;
+class Document;
+class InputSource;
+class AbstractNode;
+class AbstractContainerNode;
+class NamePool;
+
+
+class XML_API DOMBuilder: protected DTDHandler, protected ContentHandler, protected LexicalHandler
+	/// This class builds a tree representation of an
+	/// XML document, according to the W3C Document Object Model, Level 1 and 2
+	/// specifications.
+	///
+	/// The actual XML parsing is done by an XMLReader, which
+	/// must be supplied to the DOMBuilder.
+{
+public:
+	DOMBuilder(XMLReader& xmlReader, NamePool* pNamePool = 0);
+		/// Creates a DOMBuilder using the given XMLReader. 
+		/// If a NamePool is given, it becomes the Document's NamePool.
+
+	virtual ~DOMBuilder();
+		/// Destroys the DOMBuilder.
+
+	virtual Document* parse(const XMLString& uri);
+		/// Parse an XML document from a location identified by an URI.
+
+	virtual Document* parse(InputSource* pInputSource);
+		/// Parse an XML document from a location identified by an InputSource.
+
+	virtual Document* parseMemoryNP(const char* xml, std::size_t size);
+		/// Parses an XML document from memory.
+
+protected:
+	// DTDHandler
+	void notationDecl(const XMLString& name, const XMLString* publicId, const XMLString* systemId);
+	void unparsedEntityDecl(const XMLString& name, const XMLString* publicId, const XMLString& systemId, const XMLString& notationName);
+
+	// ContentHandler
+	void setDocumentLocator(const Locator* loc);
+	void startDocument();
+	void endDocument();
+	void startElement(const XMLString& uri, const XMLString& localName, const XMLString& qname, const Attributes& attributes);
+	void endElement(const XMLString& uri, const XMLString& localName, const XMLString& qname);
+	void characters(const XMLChar ch[], int start, int length);
+	void ignorableWhitespace(const XMLChar ch[], int start, int length);
+	void processingInstruction(const XMLString& target, const XMLString& data);
+	void startPrefixMapping(const XMLString& prefix, const XMLString& uri);
+	void endPrefixMapping(const XMLString& prefix);
+	void skippedEntity(const XMLString& name);
+
+	// LexicalHandler
+	void startDTD(const XMLString& name, const XMLString& publicId, const XMLString& systemId);
+	void endDTD();
+	void startEntity(const XMLString& name);
+	void endEntity(const XMLString& name);
+	void startCDATA();
+	void endCDATA();
+	void comment(const XMLChar ch[], int start, int length); 
+
+	void appendNode(AbstractNode* pNode);
+	
+	void setupParse();
+
+private:
+	static const XMLString EMPTY_STRING;
+
+	XMLReader&             _xmlReader;
+	NamePool*              _pNamePool;
+	Document*              _pDocument;
+	AbstractContainerNode* _pParent;
+	AbstractNode*          _pPrevious;
+	bool                   _inCDATA;
+	bool                   _namespaces;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMBuilder_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/DOMException.h b/contrib/libs/poco/XML/include/Poco/DOM/DOMException.h
new file mode 100644
index 0000000000..456526f111
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/DOMException.h
@@ -0,0 +1,112 @@
+//
+// DOMException.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM DOMException class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMException_INCLUDED
+#define DOM_DOMException_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API DOMException: public XMLException
+	/// 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).
+	/// 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.
+{
+public:
+	enum
+	{
+		INDEX_SIZE_ERR = 1,          /// index or size is negative or greater than allowed value
+		DOMSTRING_SIZE_ERR,          /// the specified range of text does not fit into a DOMString (not used)
+		HIERARCHY_REQUEST_ERR,       /// a node is inserted somewhere it doesn't belong
+		WRONG_DOCUMENT_ERR,          /// a node is used in a different document than the one that created it
+		INVALID_CHARACTER_ERR,       /// an invalid character is specified (not used)
+		NO_DATA_ALLOWED_ERR,         /// data is specified for a node which does not support data
+		NO_MODIFICATION_ALLOWED_ERR, /// an attempt is made to modify an object where modifications are not allowed
+		NOT_FOUND_ERR,               /// an attempt was made to reference a node in a context where it does not exist
+		NOT_SUPPORTED_ERR,           /// the implementation does not support the type of object requested
+		INUSE_ATTRIBUTE_ERR,         /// an attempt is made to add an attribute that is already in use elsewhere
+		INVALID_STATE_ERR,           /// a parameter or an operation is not supported by the underlying object
+		SYNTAX_ERR,                  /// an invalid or illegal string is specified
+		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;
+		/// Returns a static string describing the exception.
+
+	const char* className() const noexcept;
+		/// Returns the name of the exception class.
+
+	Poco::Exception* clone() const;
+		/// Creates an exact copy of the exception.
+		
+	void rethrow() const;
+		/// (Re)Throws the exception.
+
+	unsigned short code() const;
+		/// Returns the DOM exception code.
+
+protected:
+	static const std::string& message(unsigned short code);
+	
+private:
+	DOMException();
+	
+	unsigned short _code;
+	
+	static const std::string MESSAGES[_NUMBER_OF_MESSAGES];
+};
+
+
+//
+// inlines
+//
+inline unsigned short DOMException::code() const
+{
+	return _code;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMException_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/DOMImplementation.h b/contrib/libs/poco/XML/include/Poco/DOM/DOMImplementation.h
new file mode 100644
index 0000000000..0c2d7af187
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/DOMImplementation.h
@@ -0,0 +1,82 @@
+//
+// DOMImplementation.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM DOMImplementation class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMImplementation_INCLUDED
+#define DOM_DOMImplementation_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class DocumentType;
+class Document;
+class NamePool;
+
+
+class XML_API DOMImplementation
+	/// The DOMImplementation interface provides a number of methods for
+	/// performing operations that are independent of any particular instance
+	/// of the document object model.
+	/// In this implementation, DOMImplementation is implemented as a singleton.
+{
+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", 
+		/// "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 
+		/// additions do not occur.
+
+	Document* createDocument(const XMLString& namespaceURI, const XMLString& qualifiedName, DocumentType* doctype) const;
+		/// Creates an XML Document object of the specified type with its document element.
+		///
+		/// Note: You can also create a Document directly using the new operator.
+
+	static const DOMImplementation& instance();
+		/// Returns a reference to the default DOMImplementation
+		/// object.
+		
+private:
+	static const XMLString FEATURE_XML;
+	static const XMLString FEATURE_CORE;
+	static const XMLString FEATURE_EVENTS;
+	static const XMLString FEATURE_MUTATIONEVENTS;
+	static const XMLString FEATURE_TRAVERSAL;
+	static const XMLString VERSION_1_0;
+	static const XMLString VERSION_2_0;	
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMImplementation_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/DOMObject.h b/contrib/libs/poco/XML/include/Poco/DOM/DOMObject.h
new file mode 100644
index 0000000000..40b29fb2cf
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/DOMObject.h
@@ -0,0 +1,103 @@
+//
+// DOMObject.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOMObject class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMObject_INCLUDED
+#define DOM_DOMObject_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API DOMObject
+	/// The base class for all objects in the Document Object Model.
+	///
+	/// DOMObject defines the rules for memory management
+	/// in this implementation of the DOM. Violation of these
+	/// rules, which are outlined in the following, results
+	/// in memory leaks or dangling pointers.
+	///
+	/// Every object created by new or by a factory
+	/// method (for example, Document::create*) must be released
+	/// with a call to release() or autoRelease() when it
+	/// is no longer needed.
+	///
+	/// Every object created by cloning or importing another
+	/// object must be released.
+	/// For every call to duplicate() there must be a matching
+	/// call to release().
+	/// An object obtained via any other way must not be
+	/// released, except ownership of it has been explicitly
+	/// taken with a call to duplicate().
+	///
+	/// While DOMObjects are safe for use in multithreaded programs,
+	/// a DOMObject or one of its subclasses must not be accessed
+	/// from multiple threads simultaneously.
+{
+public:
+	DOMObject();
+		/// Creates the DOMObject.
+		/// The object's reference count is initialized to one.
+
+	void duplicate() const;
+		/// Increases the object's reference count.
+
+	void release() const;
+		/// 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
+		/// AutoReleasePool managed by the Document
+		/// to which this object belongs.
+
+protected:
+	virtual ~DOMObject();
+		/// Destroys the DOMObject.
+
+private:
+	DOMObject(const DOMObject&);
+	DOMObject& operator = (const DOMObject&);
+	
+	mutable int _rc;
+};
+
+
+//
+// inlines
+//
+inline void DOMObject::duplicate() const
+{
+	++_rc;
+}
+
+
+inline void DOMObject::release() const
+{
+	if (--_rc == 0)
+		delete this;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMObject_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/DOMParser.h b/contrib/libs/poco/XML/include/Poco/DOM/DOMParser.h
new file mode 100644
index 0000000000..69d0f5aaac
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/DOMParser.h
@@ -0,0 +1,114 @@
+//
+// DOMParser.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMParser
+//
+// Definition of the DOMParser class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMParser_INCLUDED
+#define DOM_DOMParser_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/SAX/SAXParser.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class NamePool;
+class Document;
+class InputSource;
+class EntityResolver;
+
+
+class XML_API DOMParser
+	/// This is a convenience class that combines a
+	/// DOMBuilder with a SAXParser, with the optional
+	/// support of a WhitespaceFilter.
+{
+public:
+	explicit DOMParser(NamePool* pNamePool = 0);
+		/// 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, 
+		/// e.g. 251, 509, 1021 or 4093, depending on the expected
+		/// size of the document.
+
+	~DOMParser();
+		/// Destroys the DOMParser.
+
+	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
+		/// the XML document.
+
+	void addEncoding(const XMLString& name, Poco::TextEncoding* pEncoding);
+		/// Adds an encoding to the parser.
+
+	void setFeature(const XMLString& name, bool state);
+		/// Set the state of a feature.
+		///
+		/// If a feature is not recognized by the DOMParser, it is
+		/// passed on to the underlying XMLReader.
+		///
+		/// The only currently supported feature is
+		/// http://www.appinf.com/features/no-whitespace-in-element-content
+		/// which, when activated, causes the WhitespaceFilter to
+		/// be used.
+
+	bool getFeature(const XMLString& name) const;
+		/// Look up the value of a feature.
+		///
+		/// If a feature is not recognized by the DOMParser, the
+		/// DOMParser queries the underlying SAXParser for the feature.
+
+	Document* parse(const XMLString& uri);
+		/// Parse an XML document from a location identified by an URI.
+
+	Document* parse(InputSource* pInputSource);
+		/// Parse an XML document from a location identified by an InputSource.
+
+	Document* parseString(const std::string& xml);
+		/// Parse an XML document from a string.
+
+	Document* parseMemory(const char* xml, std::size_t size);
+		/// Parse an XML document from memory.
+
+	EntityResolver* getEntityResolver() const;
+		/// Returns the entity resolver used by the underlying SAXParser.
+
+	void setEntityResolver(EntityResolver* pEntityResolver);
+		/// Sets the entity resolver on the underlying SAXParser.
+
+	static const XMLString FEATURE_FILTER_WHITESPACE;
+	
+private:
+	SAXParser _saxParser;
+	NamePool* _pNamePool;
+	bool      _filterWhitespace;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMParser_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/DOMSerializer.h b/contrib/libs/poco/XML/include/Poco/DOM/DOMSerializer.h
new file mode 100644
index 0000000000..b535105dca
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/DOMSerializer.h
@@ -0,0 +1,122 @@
+//
+// DOMSerializer.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMSerializer
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMSerializer_INCLUDED
+#define DOM_DOMSerializer_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/SAX/XMLReader.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+class Element;
+class Text;
+class Comment;
+class ProcessingInstruction;
+class Entity;
+class CDATASection;
+class Notation;
+class Document;
+class DocumentType;
+class DocumentFragment;
+class DeclHandler;
+class LexicalHandler;
+
+
+class XML_API DOMSerializer: public XMLReader
+	/// The DOMSerializer serializes a DOM document
+	/// into a sequence of SAX events which are
+	/// reported to the registered SAX event
+	/// handlers.
+	///
+	/// The DOMWriter uses a DOMSerializer with an
+	/// XMLWriter to serialize a DOM document into
+	/// textual XML.
+{
+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
+		/// reported to the registered SAX event
+		/// handlers.
+
+	// XMLReader
+	void setEntityResolver(EntityResolver* pResolver);
+	EntityResolver* getEntityResolver() const;
+	void setDTDHandler(DTDHandler* pDTDHandler);
+	DTDHandler* getDTDHandler() const;
+	void setContentHandler(ContentHandler* pContentHandler);
+	ContentHandler* getContentHandler() const;
+	void setErrorHandler(ErrorHandler* pErrorHandler);
+	ErrorHandler* getErrorHandler() const;
+
+	void setFeature(const XMLString& featureId, bool state);
+	bool getFeature(const XMLString& featureId) const;
+	void setProperty(const XMLString& propertyId, const XMLString& value);
+	void setProperty(const XMLString& propertyId, void* value);
+	void* getProperty(const XMLString& propertyId) const;
+
+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.
+
+	void parseMemoryNP(const char* xml, std::size_t size);
+		/// The DOMSerializer cannot parse from a system identifier,
+		/// so this method simply throws an XMLException when invoked.
+
+	void iterate(const Node* pNode) const;
+	void handleNode(const Node* pNode) const;
+	void handleElement(const Element* pElement) const;
+	void handleCharacterData(const Text* pText) const;
+	void handleComment(const Comment* pComment) const;
+	void handlePI(const ProcessingInstruction* pPI) const;
+	void handleCDATASection(const CDATASection* pCDATA) const;
+	void handleDocument(const Document* pDocument) const;
+	void handleDocumentType(const DocumentType* pDocumentType) const;
+	void handleFragment(const DocumentFragment* pFragment) const;
+	void handleNotation(const Notation* pNotation) const;
+	void handleEntity(const Entity* pEntity) const;
+
+private:
+	EntityResolver* _pEntityResolver;
+	DTDHandler*     _pDTDHandler;
+	ContentHandler* _pContentHandler;
+	ErrorHandler*   _pErrorHandler;
+	DeclHandler*    _pDeclHandler;
+	LexicalHandler* _pLexicalHandler;
+	
+	static const XMLString CDATA;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMSerializer_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/DOMWriter.h b/contrib/libs/poco/XML/include/Poco/DOM/DOMWriter.h
new file mode 100644
index 0000000000..5a5132d566
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/DOMWriter.h
@@ -0,0 +1,127 @@
+//
+// DOMWriter.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMWriter
+//
+// Definition of class DOMWriter.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMWriter_INCLUDED
+#define DOM_DOMWriter_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+#include "Poco/XML/XMLStream.h"
+#include "Poco/TextEncoding.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+class Document;
+
+
+class XML_API DOMWriter
+	/// The DOMWriter uses a DOMSerializer with an
+	/// XMLWriter to serialize a DOM document into
+	/// textual XML.
+{
+public:
+	DOMWriter();
+		/// Creates a DOMWriter.
+		
+	~DOMWriter();
+		/// Destroys a DOMWriter.
+
+	void setEncoding(const std::string& encodingName, Poco::TextEncoding& textEncoding);
+		/// Sets the encoding, which will be reflected in the written XML declaration.
+
+	const std::string& getEncoding() const;
+		/// Returns the encoding name set with setEncoding.
+
+	void setOptions(int options);
+		/// Sets options for the internal XMLWriter.
+		///
+		/// See class XMLWriter for available options.
+
+	int getOptions() const;
+		/// Returns the options for the internal XMLWriter.
+
+	void setNewLine(const std::string& newLine);
+		/// Sets the line ending characters for the internal
+		/// XMLWriter. See XMLWriter::setNewLine() for a list
+		/// of supported values. 
+
+	const std::string& getNewLine() const;
+		/// Returns the line ending characters used by the
+		/// internal XMLWriter.
+
+	void setIndent(const std::string& indent);
+		/// Sets the string used for one indentation step.
+		///
+		/// The default is a single TAB character.
+		/// 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.
+
+	void writeNode(XMLByteOutputStream& ostr, const Node* pNode);
+		/// Writes the XML for the given node to the specified stream.
+
+	void writeNode(const std::string& systemId, const Node* pNode);
+		/// Writes the XML for the given node to the file specified in systemId,
+		/// using a standard file output stream (Poco::FileOutputStream).
+
+private:
+	std::string         _encodingName;
+	Poco::TextEncoding* _pTextEncoding;
+	int                 _options;
+	std::string         _newLine;
+	std::string         _indent;
+};
+
+
+//
+// inlines
+//
+inline const std::string& DOMWriter::getEncoding() const
+{
+	return _encodingName;
+}
+
+
+inline int DOMWriter::getOptions() const
+{
+	return _options;
+}
+
+
+inline const std::string& DOMWriter::getNewLine() const
+{
+	return _newLine;
+}
+
+
+inline const std::string& DOMWriter::getIndent() const
+{
+	return _indent;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMWriter_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/DTDMap.h b/contrib/libs/poco/XML/include/Poco/DOM/DTDMap.h
new file mode 100644
index 0000000000..2a475c358e
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/DTDMap.h
@@ -0,0 +1,67 @@
+//
+// DTDMap.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DTDMap class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DTDMap_INCLUDED
+#define DOM_DTDMap_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/NamedNodeMap.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class DocumentType;
+
+
+class XML_API DTDMap: public NamedNodeMap
+	/// This implementation of NamedNodeMap
+	/// is returned by DocumentType::entities()
+	/// and DocumentType::notations(). 
+{
+public:
+	Node* getNamedItem(const XMLString& name) const;
+	Node* setNamedItem(Node* arg);
+	Node* removeNamedItem(const XMLString& name);
+	Node* item(unsigned long index) const;
+	unsigned long length() const;
+
+	Node* getNamedItemNS(const XMLString& namespaceURI, const XMLString& localName) const;
+	Node* setNamedItemNS(Node* arg);
+	Node* removeNamedItemNS(const XMLString& namespaceURI, const XMLString& localName);
+
+	void autoRelease();
+
+protected:
+	DTDMap(const DocumentType* pDocumentType, unsigned short type);
+	~DTDMap();
+
+private:
+	DTDMap();
+	
+	const DocumentType* _pDocumentType;
+	unsigned short _type;
+	
+	friend class DocumentType;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DTDMap_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/Document.h b/contrib/libs/poco/XML/include/Poco/DOM/Document.h
new file mode 100644
index 0000000000..e66c0e6b51
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/Document.h
@@ -0,0 +1,285 @@
+//
+// Document.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Document class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Document_INCLUDED
+#define DOM_Document_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractContainerNode.h"
+#include "Poco/DOM/DocumentEvent.h"
+#include "Poco/DOM/Element.h"
+#include "Poco/XML/XMLString.h"
+#include "Poco/XML/NamePool.h"
+#include "Poco/AutoReleasePool.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class NamePool;
+class DocumentType;
+class DOMImplementation;
+class DocumentFragment;
+class Text;
+class Comment;
+class CDATASection;
+class ProcessingInstruction;
+class Attr;
+class EntityReference;
+class NodeList;
+class Entity;
+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 
+	/// 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 
+	/// context they were created.
+{
+public:
+	typedef Poco::AutoReleasePool<DOMObject> AutoReleasePool;
+
+	explicit Document(NamePool* pNamePool = 0);
+		/// Creates a new document. If pNamePool == 0, the document
+		/// 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).
+
+	Document(DocumentType* pDocumentType, NamePool* pNamePool = 0);
+		/// Creates a new document. If pNamePool == 0, the document
+		/// 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.
+
+	Document(DocumentType* pDocumentType, 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).
+
+	NamePool& namePool();
+		/// Returns a pointer to the documents Name Pool.
+
+	AutoReleasePool& autoReleasePool();
+		/// Returns a pointer to the documents Auto Release Pool.
+
+	void collectGarbage();
+		/// Releases all objects in the Auto Release Pool.
+
+	void suspendEvents();
+		/// Suspends all events until resumeEvents() is called.
+
+	void resumeEvents();
+		/// Resumes all events suspended with suspendEvent();
+
+	bool eventsSuspended() const;
+		/// Returns true if events are suspended.
+
+	bool events() const;
+		/// Returns true if events are not suspended.
+
+	const DocumentType* doctype() const;
+		/// The Document Type Declaration (see DocumentType) associated with this document.
+		/// For HTML documents as well as XML documents without a document type declaration
+		/// this returns null. The DOM Level 1 does not support editing the Document
+		/// Type Declaration. docType cannot be altered in any way, including through
+		/// the use of methods inherited from the Node interface, such as insertNode
+		/// or removeNode.
+
+	const DOMImplementation& implementation() const;
+		/// The DOMImplementation object that handles this document. A DOM application
+		/// may use objects from multiple implementations.
+
+	Element* documentElement() const;
+		/// This is a convenience attribute that allows direct access to the child node
+		/// that is the root element of the document. For HTML documents, this is the
+		/// element with the tagName "HTML".
+
+	Element* createElement(const XMLString& tagName) const;
+		/// Creates an element of the type specified. Note that the instance returned
+		/// implements the Element interface, so attributes can be specified directly
+		/// on the returned object.
+		///
+		/// In addition, if there are known attributes with default values, Attr nodes
+		/// representing them are automatically created and attached to the element.
+
+	DocumentFragment* createDocumentFragment() const;
+		/// Creates an empty DocumentFragment object.
+
+	Text* createTextNode(const XMLString& data) const;
+		/// Creates a text node given the specified string.
+
+	Comment* createComment(const XMLString& data) const;
+		/// Creates a comment node given the specified string.
+
+	CDATASection* createCDATASection(const XMLString& data) const;
+		/// Creates a CDATASection node whose value is the specified string.
+
+	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;	
+		/// Creates an Attr of the given name. Note that the Attr instance can then
+		/// 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
+		/// is known, the child list of the EntityReference node is made the same as
+		/// that of the corresponding Entity node.
+
+	NodeList* getElementsByTagName(const XMLString& name) const;
+		/// Returns a NodeList of all Elements with a given tag name in the order
+		/// in which they would be encountered in a preorder traversal of the
+		/// document tree.
+		///
+		/// The returned NodeList must be released with a call to release()
+		/// when no longer needed.
+
+	// DOM Level 2
+	Node* importNode(Node* importedNode, bool deep);
+		/// Imports a node from another document to this document. The returned node
+		/// has no parent; (parentNode is null). The source node is not altered or removed
+		/// from the original document; this method creates a new copy of the source
+		/// node.
+		/// For all nodes, importing a node creates a node object owned by the importing
+		/// document, with attribute values identical to the source node's nodeName
+		/// and nodeType, plus the attributes related to namespaces (prefix, localName,
+		/// and namespaceURI). As in the cloneNode operation on a Node, the source node
+		/// is not altered.
+		/// Additional information is copied as appropriate to the nodeType, attempting
+		/// to mirror the behavior expected if a fragment of XML or HTML source was
+		/// copied from one document to another, recognizing that the two documents
+		/// may have different DTDs in the XML case.
+
+	Element* createElementNS(const XMLString& namespaceURI, const XMLString& qualifiedName) const;
+		/// Creates an element of the given qualified name and namespace URI.
+
+	Attr* createAttributeNS(const XMLString& namespaceURI, const XMLString& qualifiedName) const;
+		/// 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 
+		/// preorder traversal of the Document tree.
+
+	Element* getElementById(const XMLString& elementId) const;
+		/// 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. 
+		///
+		/// 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 
+		/// not know whether attributes are of type ID or not are expected to
+		/// return null. This implementation therefore returns null.
+		///
+		/// See also the non-standard two argument variant of getElementById()
+		/// and getElementByIdNS().
+
+	// DocumentEvent
+	Event* createEvent(const XMLString& eventType) const;
+
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+	// 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.
+		///
+		/// This method is not part of the W3C Document Object Model.
+
+	Notation* createNotation(const XMLString& name, const XMLString& publicId, const XMLString& systemId) const;
+		/// Creates a Notation with the given name, publicId and systemId.
+		///
+		/// This method is not part of 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. 
+		///
+		/// 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. 
+		///
+		/// This method is an extension to the W3C Document Object Model.
+
+protected:
+	~Document();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+	
+	DocumentType* getDoctype();
+	void setDoctype(DocumentType* pDoctype);
+
+private:
+	DocumentType*   _pDocumentType;
+	NamePool*       _pNamePool;
+	AutoReleasePool _autoReleasePool;
+	int             _eventSuspendLevel;
+
+	static const XMLString NODE_NAME;
+	
+	friend class DOMBuilder;
+};
+
+
+//
+// inlines
+//
+inline NamePool& Document::namePool()
+{
+	return *_pNamePool;
+}
+
+
+inline Document::AutoReleasePool& Document::autoReleasePool()
+{
+	return _autoReleasePool;
+}
+
+
+inline const DocumentType* Document::doctype() const
+{
+	return _pDocumentType;
+}
+
+
+inline DocumentType* Document::getDoctype()
+{
+	return _pDocumentType;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Document_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/DocumentEvent.h b/contrib/libs/poco/XML/include/Poco/DOM/DocumentEvent.h
new file mode 100644
index 0000000000..14bcf270b8
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/DocumentEvent.h
@@ -0,0 +1,65 @@
+//
+// DocumentEvent.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM DocumentEvent interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DocumentEvent_INCLUDED
+#define DOM_DocumentEvent_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Event;
+
+
+class XML_API DocumentEvent
+	/// The DocumentEvent interface provides a mechanism by which the user can create
+	/// an Event of a type supported by the implementation. It is expected that
+	/// the DocumentEvent interface will be implemented on the same object which
+	/// implements the Document interface in an implementation which supports the
+	/// Event model.
+{
+public:
+	virtual Event* createEvent(const XMLString& eventType) const = 0;
+		/// Creates an event of the specified type.
+		///
+		/// The eventType parameter specifies the type of Event interface to be created.
+		/// If the Event interface specified is supported by the implementation this
+		/// method will return a new Event of the interface type requested. If the Event
+		/// is to be dispatched via the dispatchEvent method the appropriate event init
+		/// method must be called after creation in order to initialize the Event's
+		/// values. As an example, a user wishing to synthesize some kind of UIEvent
+		/// would call createEvent with the parameter "UIEvents". The initUIEvent method
+		/// could then be called on the newly created UIEvent to set the specific type
+		/// of UIEvent to be dispatched and set its context information.
+		/// The createEvent method is used in creating Events when it is either inconvenient
+		/// or unnecessary for the user to create an Event themselves. In cases where
+		/// the implementation provided Event is insufficient, users may supply their
+		/// own Event implementations for use with the dispatchEvent method.
+
+protected:
+	virtual ~DocumentEvent();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DocumentEvent_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/DocumentFragment.h b/contrib/libs/poco/XML/include/Poco/DOM/DocumentFragment.h
new file mode 100644
index 0000000000..105a2171db
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/DocumentFragment.h
@@ -0,0 +1,84 @@
+//
+// DocumentFragment.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM DocumentFragment class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DocumentFragment_INCLUDED
+#define DOM_DocumentFragment_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractContainerNode.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API DocumentFragment: public AbstractContainerNode
+	/// DocumentFragment is a "lightweight" or "minimal" Document object. It is
+	/// very common to want to be able to extract a portion of a document's tree
+	/// or to create a new fragment of a document. Imagine implementing a user command
+	/// like cut or rearranging a document by moving fragments around. It is desirable
+	/// to have an object which can hold such fragments and it is quite natural
+	/// to use a Node for this purpose. While it is true that a Document object
+	/// 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
+	/// to follow the rules imposed upon well-formed XML parsed entities, which
+	/// 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
+	/// very useful when the user wishes to create nodes that are siblings; the
+	/// DocumentFragment acts as the parent of these nodes so that the user can
+	/// use the standard methods from the Node interface, such as insertBefore and
+	/// appendChild.
+{
+public:
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+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;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DocumentFragment_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/DocumentType.h b/contrib/libs/poco/XML/include/Poco/DOM/DocumentType.h
new file mode 100644
index 0000000000..3d8909798b
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/DocumentType.h
@@ -0,0 +1,125 @@
+//
+// DocumentType.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM DocumentType class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DocumentType_INCLUDED
+#define DOM_DocumentType_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractContainerNode.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class NamedNodeMap;
+
+
+class XML_API DocumentType: public AbstractContainerNode
+	/// Each Document has a doctype attribute whose value is either null or a DocumentType
+	/// object. The DocumentType interface in the DOM Level 1 Core provides an
+	/// 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 
+		/// DOCTYPE keyword.
+
+	NamedNodeMap* entities() const;
+		/// A NamedNodeMap containing the general entities,
+		/// both external and internal, declared in the DTD.
+		/// Duplicates are discarded.
+		///
+		/// Note: In this implementation, only the
+		/// 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.
+
+	NamedNodeMap* notations() const;
+		/// A NamedNodeMap containing the notations declared in the DTD. Duplicates
+		/// 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.
+
+	// DOM Level 2
+	const XMLString& publicId() const;
+		/// Returns the public identifier of the external DTD subset.
+
+	const XMLString& systemId() const;
+		/// Returns the system identifier of the external DTD subset.
+
+	const XMLString& internalSubset() const;
+		/// Returns the internal DTD subset. This implementation
+		/// returns an empty string.
+
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+protected:
+	DocumentType(Document* pOwner, const XMLString& name, const XMLString& publicId, const XMLString& systemId);
+	DocumentType(Document* pOwner, const DocumentType& dt);
+	~DocumentType();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	XMLString _name;
+	XMLString _publicId;
+	XMLString _systemId;
+	
+	friend class DOMImplementation;
+	friend class Document;
+	friend class DOMBuilder;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& DocumentType::name() const
+{
+	return _name;
+}
+
+
+inline const XMLString& DocumentType::publicId() const
+{
+	return _publicId;
+}
+
+
+inline const XMLString& DocumentType::systemId() const
+{
+	return _systemId;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DocumentType_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/Element.h b/contrib/libs/poco/XML/include/Poco/DOM/Element.h
new file mode 100644
index 0000000000..90217baab8
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/Element.h
@@ -0,0 +1,219 @@
+//
+// Element.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Element class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Element_INCLUDED
+#define DOM_Element_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractContainerNode.h"
+#include "Poco/XML/Name.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Attr;
+class NodeList;
+class Document;
+
+
+class XML_API Element: public AbstractContainerNode
+	/// The Element interface represents an element in an XML document.
+	/// Elements may have attributes associated with them; since the Element interface
+	/// inherits from Node, the generic Node interface attribute attributes may
+	/// be used to retrieve the set of all attributes for an element. There are
+	/// 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. 
+{
+public:
+	const XMLString& tagName() const;
+		/// Returns the name of the element.
+		///
+		/// For example, in
+		/// 
+		///     <elementExample id="demo"> 
+        ///         ... 
+		///     </elementExample>
+		///
+		/// 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;
+		/// Retrieves an attribute value by name.
+		///
+		/// Returns the attribute's value, if the attribute
+		/// exists, or an empty string otherwise.
+
+	void setAttribute(const XMLString& name, const XMLString& value);
+		/// Adds a new attribute. If an attribute with that name is already present
+		/// in the element, its value is changed to be that of the value parameter.
+		/// This value is a simple string; it is not parsed as it is being set. So any
+		/// 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.
+
+	Attr* getAttributeNode(const XMLString& name) const;
+		/// Retrieves an Attr node by name.
+
+	Attr* setAttributeNode(Attr* newAttr);
+		/// Adds a new attribute. If an attribute with that name is already
+		/// present in the element, it is replaced by the new one.
+
+	Attr* addAttributeNodeNP(Attr* oldAttr, Attr* newAttr);
+		/// For internal use only.
+		/// Adds a new attribute after oldAttr.
+		/// If oldAttr is 0, newAttr is set as first attribute.
+		/// Returns newAttr.
+		/// Does not fire any events.
+
+	Attr* removeAttributeNode(Attr* oldAttr);
+		/// Removes the specified attribute.
+
+	NodeList* getElementsByTagName(const XMLString& name) const;
+		/// Returns a NodeList of all descendant elements with a given tag
+		/// name, in the order in which they would be encountered in a
+		/// preorder traversal of the Element tree.
+		///
+		/// The special name "*" matches all tags.
+		///
+		/// The returned NodeList must be released with a call
+		/// to release() when no longer needed.
+
+	void normalize();
+		/// Puts all Text nodes in the full depth of the sub-tree underneath this Element,
+		/// including attribute nodes, into a "normal" form where only markup (e.g.,
+		/// tags, comments, processing instructions, CDATA sections, and entity references)
+		/// separates Text nodes, i.e., there are no adjacent Text nodes. This can be
+		/// 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.
+
+	// DOM Level 2
+	const XMLString& getAttributeNS(const XMLString& namespaceURI, const XMLString& localName) const;
+		/// Retrieves an attribute value by name.
+		///
+		/// Returns the attribute's value, if the attribute
+		/// exists, or an empty string otherwise.
+
+	void setAttributeNS(const XMLString& namespaceURI, const XMLString& qualifiedName, const XMLString& value);
+		/// Adds a new attribute. If an attribute with that name
+		/// is already present in the element, its value is changed
+		/// to be that of the value parameter.
+
+	void removeAttributeNS(const XMLString& namespaceURI, const XMLString& localName);
+		/// Removes an attribute by name.
+
+	Attr* getAttributeNodeNS(const XMLString& namespaceURI, const XMLString& localName) const;
+		/// Retrieves an Attr node by name.
+
+	Attr* setAttributeNodeNS(Attr* newAttr);
+		/// Adds a new attribute. If an attribute with that name is already
+		/// present in the element, it is replaced by the new one.
+
+	bool hasAttribute(const XMLString& name) const;
+		/// Returns true if and only if the element has the specified attribute.
+
+	bool hasAttributeNS(const XMLString& namespaceURI, const XMLString& localName) const;
+		/// 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 
+		/// 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.
+		///
+		/// The returned NodeList must be released with a call
+		/// to release() when no longer needed.
+
+	const XMLString& namespaceURI() const;
+	XMLString prefix() const;
+	const XMLString& localName() const;
+	bool hasAttributes() const;
+	XMLString innerText() const;
+
+	Element* getChildElement(const XMLString& name) const;
+		/// Returns the first child element with the given name, or null
+		/// if such an element does not exist.
+		///
+		/// This method is an extension to the W3C Document Object Model.
+
+	Element* getChildElementNS(const XMLString& namespaceURI, const XMLString& localName) const;
+		/// Returns the first child element with the given namespaceURI and localName,
+		/// 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. 
+		///
+		/// 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. 
+		///
+		/// This method is an extension to the W3C Document Object Model.
+	
+	// Node
+	const XMLString& nodeName() const;
+	NamedNodeMap* attributes() const;
+	unsigned short nodeType() const;
+
+protected:
+	Element(Document* pOwnerDocument, const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname);
+	Element(Document* pOwnerDocument, const Element& elem);
+	~Element();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+	void dispatchNodeRemovedFromDocument();
+	void dispatchNodeInsertedIntoDocument();
+
+private:
+	const Name& _name;
+	Attr*       _pFirstAttr;
+
+	friend class Attr;
+	friend class Document;
+	friend class AttrMap;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& Element::tagName() const
+{
+	return _name.qname();
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Element_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/ElementsByTagNameList.h b/contrib/libs/poco/XML/include/Poco/DOM/ElementsByTagNameList.h
new file mode 100644
index 0000000000..98af2e8207
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/ElementsByTagNameList.h
@@ -0,0 +1,86 @@
+//
+// ElementsByTagNameList.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the ElementsByTagNameList and ElementsByTagNameListNS classes.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_ElementsByTagNameList_INCLUDED
+#define DOM_ElementsByTagNameList_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/NodeList.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API ElementsByTagNameList: public NodeList
+	// This implementation of NodeList is returned
+	// by Document::getElementsByTagName() and
+	// Element::getElementsByTagName().
+{
+public:
+	Node* item(unsigned long index) const;
+	unsigned long length() const;
+	void autoRelease();
+
+protected:
+	ElementsByTagNameList(const Node* pParent, const XMLString& name);
+	~ElementsByTagNameList();
+
+	Node* find(const Node* pParent, unsigned long index) const;
+
+	const Node* _pParent;
+	XMLString   _name;
+	mutable unsigned long _count;
+	
+	friend class AbstractContainerNode;
+	friend class Element;
+	friend class Document;
+};
+
+
+class XML_API ElementsByTagNameListNS: public NodeList
+	// This implementation of NodeList is returned
+	// by Document::getElementsByTagNameNS() and
+	// Element::getElementsByTagNameNS().
+{
+public:
+	virtual Node* item(unsigned long index) const;
+	virtual unsigned long length() const;
+	virtual void autoRelease();
+
+protected:
+	ElementsByTagNameListNS(const Node* pParent, const XMLString& namespaceURI, const XMLString& localName);
+	~ElementsByTagNameListNS();
+
+	Node* find(const Node* pParent, unsigned long index) const;
+
+	const Node* _pParent;
+	XMLString   _localName;
+	XMLString   _namespaceURI;
+	mutable unsigned long _count;
+	
+	friend class AbstractContainerNode;
+	friend class Element;
+	friend class Document;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_ElementsByTagNameList_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/Entity.h b/contrib/libs/poco/XML/include/Poco/DOM/Entity.h
new file mode 100644
index 0000000000..40c21f59cd
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/Entity.h
@@ -0,0 +1,126 @@
+//
+// Entity.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Entity class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Entity_INCLUDED
+#define DOM_Entity_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractContainerNode.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API Entity: public AbstractContainerNode
+	/// This interface represents an entity, either parsed or unparsed, in an XML
+	/// 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
+	/// subset need not be expanded by some classes of applications, and that the
+	/// 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:
+	const XMLString& publicId() const;
+		/// Returns the public identifier associated with
+		/// the entity, if specified. If the public identifier
+		/// was not specified, this is the empty string.
+
+	const XMLString& systemId() const;
+		/// Returns the system identifier associated with
+		/// the entity, if specified. If the system identifier
+		/// was not specified, this is the empty string.
+
+	const XMLString& notationName() const;
+		/// Returns, for unparsed entities, the name of the
+		/// notation for the entity. For parsed entities, this
+		/// is the empty string.
+
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+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:
+	static const XMLString NODE_NAME;
+
+	XMLString _name;
+	XMLString _publicId;
+	XMLString _systemId;
+	XMLString _notationName;
+
+	friend class Document;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& Entity::publicId() const
+{
+	return _publicId;
+}
+
+
+inline const XMLString& Entity::systemId() const
+{
+	return _systemId;
+}
+
+
+inline const XMLString& Entity::notationName() const
+{
+	return _notationName;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Entity_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/EntityReference.h b/contrib/libs/poco/XML/include/Poco/DOM/EntityReference.h
new file mode 100644
index 0000000000..5ecd044b57
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/EntityReference.h
@@ -0,0 +1,73 @@
+//
+// EntityReference.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM EntityReference class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_EntityReference_INCLUDED
+#define DOM_EntityReference_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractNode.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API EntityReference: public AbstractNode
+	/// EntityReference objects may be inserted into the structure model when an
+	/// entity reference is in the source document, or when the user wishes to insert
+	/// an entity reference. Note that character references and references to predefined
+	/// entities are considered to be expanded by the HTML or XML processor so that
+	/// characters are represented by their Unicode equivalent rather than by an
+	/// entity reference. Moreover, the XML processor may completely expand references
+	/// to entities while building the structure model, instead of providing EntityReference
+	/// objects. If it does provide such objects, then for a given EntityReference
+	/// 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
+	/// to trigger the evaluation.
+{
+public:
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+protected:
+	EntityReference(Document* pOwnerDocument, const XMLString& name);
+	EntityReference(Document* pOwnerDocument, const EntityReference& ref);
+	~EntityReference();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	XMLString _name;
+	
+	friend class Document;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_EntityReference_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/Event.h b/contrib/libs/poco/XML/include/Poco/DOM/Event.h
new file mode 100644
index 0000000000..5396aa3f5a
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/Event.h
@@ -0,0 +1,209 @@
+//
+// Event.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Definition of the DOM Event class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Event_INCLUDED
+#define DOM_Event_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+#include "Poco/DOM/DOMObject.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class EventTarget;
+class Document;
+
+
+class XML_API Event: public DOMObject
+	/// The Event interface is used to provide contextual information about an event
+	/// to the handler processing the event. An object which implements the Event
+	/// interface is generally passed as the first parameter to an event handler.
+	/// More specific context information is passed to event handlers by deriving
+	/// additional interfaces from Event which contain information directly relating
+	/// to the type of event they accompany. These derived interfaces are also implemented
+	/// by the object passed to the event listener.
+{
+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. 
+	};
+
+	const XMLString& type() const;
+		/// The name of the event (case-insensitive). The name must be an XML name.
+
+	EventTarget* target() const;
+		/// 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 
+		/// 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. 
+		/// 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 
+		/// 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 
+		/// which the event was created. Due to the fact that some
+		/// 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 
+		/// 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 
+		/// event during event flow. If this method is called by
+		/// 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. 
+
+	void preventDefault();
+		/// 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 
+		/// the event will not occur. If, during any stage of event flow, the
+		/// 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 
+		/// 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. 
+
+	void initEvent(const XMLString& eventType, bool canBubble, bool isCancelable);
+		/// 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 
+		/// 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. 
+
+	void autoRelease();
+
+protected:
+	Event(Document* pOwnerDocument, const XMLString& type);
+	Event(Document* pOwnerDocument, const XMLString& type, EventTarget* pTarget, bool canBubble, bool isCancelable);
+	~Event();
+
+	bool isCanceled() const;
+		/// returns true if and only if the event has been cancelled.
+
+	bool isStopped() const;
+		/// returns true if and only if propagation of the event has been stopped.
+
+	void setTarget(EventTarget* pTarget);
+		/// sets the target
+
+	void setCurrentPhase(PhaseType phase);
+		/// sets the current phase
+
+	void setCurrentTarget(EventTarget* pTarget);
+		/// sets the current target
+
+private:
+	Document*    _pOwner;
+	XMLString    _type;
+	EventTarget* _pTarget;
+	EventTarget* _pCurrentTarget;
+	PhaseType    _currentPhase;
+	bool         _bubbles;
+	bool         _cancelable;
+	bool         _canceled;
+	bool         _stopped;
+	
+	friend class AbstractNode;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& Event::type() const
+{
+	return _type;
+}
+
+
+inline EventTarget* Event::target() const
+{
+	return _pTarget;
+}
+
+
+inline EventTarget* Event::currentTarget() const
+{
+	return _pCurrentTarget;
+}
+
+
+inline Event::PhaseType Event::eventPhase() const
+{
+	return _currentPhase;
+}
+
+
+inline bool Event::bubbles() const
+{
+	return _bubbles;
+}
+
+
+inline bool Event::cancelable() const
+{
+	return _cancelable;
+}
+
+
+inline Poco::UInt64 Event::timeStamp() const
+{
+	return 0;
+}
+
+
+inline bool Event::isCanceled() const
+{
+	return _canceled;
+}
+
+
+inline bool Event::isStopped() const
+{
+	return _stopped;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Event_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/EventDispatcher.h b/contrib/libs/poco/XML/include/Poco/DOM/EventDispatcher.h
new file mode 100644
index 0000000000..4e825df9c4
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/EventDispatcher.h
@@ -0,0 +1,97 @@
+//
+// EventDispatcher.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Definition of the EventDispatcher class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_EventDispatcher_INCLUDED
+#define DOM_EventDispatcher_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+#include <list>
+
+
+namespace Poco {
+namespace XML {
+
+
+class Event;
+class EventListener;
+
+
+class XML_API EventDispatcher
+	/// This helper class manages event listener subscriptions
+	/// and event dispatching for AbstractNode.
+	///
+	/// The EventListener list is managed in such a way that
+	/// event listeners can be added and removed even
+	/// from within an EventListener, while events are being
+	/// dispatched.
+{
+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.
+		///
+		/// If a dispatch is currently in progress, the list
+		/// entry is only marked for deletion.
+		/// If no dispatch is currently in progress, all EventListeners
+		/// marked for deletion are removed from the list.
+
+	void dispatchEvent(Event* evt);
+		/// Dispatches the event.
+		///
+		/// 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 
+		/// event dispatcher list.
+		
+	void bubbleEvent(Event* evt);
+		/// Dispatches the event in its bubbling phase.
+		///
+		/// Also removes all EventListeners marked for deletion from the 
+		/// event dispatcher list.
+
+private:
+	struct EventListenerItem
+	{
+		XMLString      type;
+		EventListener* pListener;
+		bool           useCapture;
+	};
+
+	typedef std::list<EventListenerItem> EventListenerList;
+	
+	int               _inDispatch;
+	EventListenerList _listeners;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_EventDispatcher_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/EventException.h b/contrib/libs/poco/XML/include/Poco/DOM/EventException.h
new file mode 100644
index 0000000000..cb82441058
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/EventException.h
@@ -0,0 +1,81 @@
+//
+// EventException.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Definition of the DOM EventException class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_EventException_INCLUDED
+#define DOM_EventException_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API EventException: public XMLException
+	/// 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 
+		                                /// event before the method was called. Specification of the Event's
+                                        /// type as null or an empty string will also trigger this exception. 
+	};
+
+	EventException(int code);
+		/// Creates an EventException with the given error code.
+
+	EventException(const EventException& exc);
+		/// Creates an EventException by copying another one.
+
+	~EventException() noexcept;
+		/// Destroys the EventException.
+
+	EventException& operator = (const EventException& exc);
+
+	const char* name() const noexcept;
+		/// Returns a static string describing the exception.
+
+	const char* className() const noexcept;
+		/// Returns the name of the exception class.
+
+	unsigned short code() const;
+		/// Returns the Event exception code.
+
+protected:
+	Poco::Exception* clone() const;
+	
+private:
+	EventException();
+};
+
+
+//
+// inlines
+//
+inline unsigned short EventException::code() const
+{
+	return UNSPECIFIED_EVENT_TYPE_ERR;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_EventException_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/EventListener.h b/contrib/libs/poco/XML/include/Poco/DOM/EventListener.h
new file mode 100644
index 0000000000..f0951b10a2
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/EventListener.h
@@ -0,0 +1,57 @@
+//
+// EventListener.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Definition of the DOM EventListener interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_EventListener_INCLUDED
+#define DOM_EventListener_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Event;
+
+
+class XML_API EventListener
+	/// The EventListener interface is the primary method for handling events. Users
+	/// implement the EventListener interface and register their listener on an
+	/// 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
+	/// add them manually.
+{
+public:
+	virtual void handleEvent(Event* evt) = 0;
+		/// This method is called whenever an event occurs of the 
+		/// type for which the EventListener interface was registered.
+
+protected:
+	virtual ~EventListener();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_EventListener_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/EventTarget.h b/contrib/libs/poco/XML/include/Poco/DOM/EventTarget.h
new file mode 100644
index 0000000000..466d2151ed
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/EventTarget.h
@@ -0,0 +1,76 @@
+//
+// EventTarget.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Definition of the DOM EventTarget interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_EventTarget_INCLUDED
+#define DOM_EventTarget_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/DOMObject.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class EventListener;
+class Event;
+
+
+class XML_API EventTarget: public DOMObject
+	/// The EventTarget interface is implemented by all Nodes in an implementation
+	/// which supports the DOM Event Model. Therefore, this interface can be obtained
+	/// by using binding-specific casting methods on an instance of the Node interface.
+	/// The interface allows registration and removal of EventListeners on an EventTarget
+	/// and dispatch of events to that EventTarget.
+{
+public:
+	virtual void addEventListener(const XMLString& type, EventListener* listener, bool useCapture) = 0;
+		/// 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 
+		/// 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 
+		/// 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. 	
+	
+	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. 
+		/// 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. 
+
+	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 
+		/// bubbling behavior as events dispatched directly by the
+		/// implementation. The target of the event is the EventTarget on 
+		/// which dispatchEvent is called. 
+
+protected:
+	virtual ~EventTarget();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_EventTarget_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/MutationEvent.h b/contrib/libs/poco/XML/include/Poco/DOM/MutationEvent.h
new file mode 100644
index 0000000000..33a8521c50
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/MutationEvent.h
@@ -0,0 +1,143 @@
+//
+// MutationEvent.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Definition of the DOM MutationEvent class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_MutationEvent_INCLUDED
+#define DOM_MutationEvent_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/Event.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+
+
+class XML_API MutationEvent: public Event
+	/// 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. 
+	};
+
+	Node* relatedNode() const;
+		/// 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 
+		/// changed parent. If an event is instead dispatched to a
+		/// 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 
+		/// events, and of the CharacterData node in DOMCharDataModified events.
+
+	const XMLString& newValue() const;
+		/// 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 
+		/// DOMAttrModified event. The values can be MODIFICATION,
+		/// ADDITION, or REMOVAL.
+
+	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 
+		/// MutationEvent created through the DocumentEvent
+		/// 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 
+		/// necessary. If called multiple times, the final invocation takes
+		/// precedence.
+
+	// Event Types
+	static const XMLString DOMSubtreeModified;
+	static const XMLString DOMNodeInserted;
+	static const XMLString DOMNodeRemoved;
+	static const XMLString DOMNodeRemovedFromDocument;
+	static const XMLString DOMNodeInsertedIntoDocument;
+	static const XMLString DOMAttrModified;
+	static const XMLString DOMCharacterDataModified;
+
+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, 
+				  const XMLString& prevValue, const XMLString& newValue, const XMLString& attrName, AttrChangeType change);
+	~MutationEvent();
+
+private:
+	XMLString      _prevValue;
+	XMLString      _newValue;
+	XMLString      _attrName;
+	AttrChangeType _change;
+	Node*          _pRelatedNode;
+
+	friend class AbstractNode;
+	friend class Document;
+};
+
+
+//
+// inlines
+//
+inline Node* MutationEvent::relatedNode() const
+{
+	return _pRelatedNode;
+}
+
+
+inline const XMLString& MutationEvent::prevValue() const
+{
+	return _prevValue;
+}
+
+
+inline const XMLString& MutationEvent::newValue() const
+{
+	return _newValue;
+}
+
+
+inline const XMLString& MutationEvent::attrName() const
+{
+	return _attrName;
+}
+
+
+inline MutationEvent::AttrChangeType MutationEvent::attrChange() const
+{
+	return _change;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_MutationEvent_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/NamedNodeMap.h b/contrib/libs/poco/XML/include/Poco/DOM/NamedNodeMap.h
new file mode 100644
index 0000000000..7b42ca88f4
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/NamedNodeMap.h
@@ -0,0 +1,93 @@
+//
+// NamedNodeMap.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM NamedNodeMap interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_NamedNodeMap_INCLUDED
+#define DOM_NamedNodeMap_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/DOMObject.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+
+
+class XML_API NamedNodeMap: public DOMObject
+	/// Objects implementing the NamedNodeMap interface are used to represent collections
+	/// of nodes that can be accessed by name. Note that NamedNodeMap does not inherit
+	/// from NodeList; NamedNodeMaps are not maintained in any particular order.
+	/// Objects contained in an object implementing NamedNodeMap may also be accessed
+	/// by an ordinal index, but this is simply to allow convenient enumeration
+	/// of the contents of a NamedNodeMap, and does not imply that the DOM specifies
+	/// an order to these Nodes.
+	///
+	/// NamedNodeMap objects in the DOM are live.
+	///
+	/// A NamedNodeMap returned from a method must be released with a call to 
+	/// release() when no longer needed.
+{
+public:
+	virtual Node* getNamedItem(const XMLString& name) const = 0;
+		/// Retrieves a node specified by name.
+
+	virtual Node* setNamedItem(Node* arg) = 0;
+		/// Adds a node using its nodeName attribute. If a node with that name is already
+		/// present in this map, it is replaced by the new one.
+		/// As the nodeName attribute is used to derive the name which the node must
+		/// be stored under, multiple nodes of certain types (those that have a "special"
+		/// string value) cannot be stored as the names would clash. This is seen as
+		/// preferable to allowing nodes to be aliased.
+
+	virtual Node* removeNamedItem(const XMLString& name) = 0;
+		/// Removes a node specified by name. When this map contains the attributes
+		/// attached to an element, if the removed attribute is known to have a default
+		/// value, an attribute immediately appears containing the default value.
+
+	virtual Node* item(unsigned long index) const = 0;
+		/// Returns the index'th item in the map. If index is greater
+		/// than or equal to the number of nodes in the map, this
+		/// returns null.
+
+	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 
+		/// 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();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_NamedNodeMap_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/Node.h b/contrib/libs/poco/XML/include/Poco/DOM/Node.h
new file mode 100644
index 0000000000..f6a3c4afd4
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/Node.h
@@ -0,0 +1,285 @@
+//
+// Node.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Node interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Node_INCLUDED
+#define DOM_Node_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/EventTarget.h"
+#include "Poco/XML/XMLString.h"
+#include "Poco/SAX/NamespaceSupport.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class NamedNodeMap;
+class Document;
+class NodeList;
+
+
+class XML_API Node: public EventTarget
+	/// The Node interface is the primary datatype for the entire Document Object
+	/// Model. It represents a single node in the document tree. While all objects
+	/// implementing the Node interface expose methods for dealing with children,
+	/// 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
+	/// for a specific nodeType (e.g., nodeValue for an Element or attributes for
+	/// a Comment), this returns null. Note that the specialized interfaces may
+	/// contain additional and more convenient mechanisms to get and set the relevant
+	/// information.
+	///
+	/// This implementation differs in some ways from the W3C DOM recommendations.
+	/// For example, the DOM specifies that some methods can return null strings.
+	/// Instead of null strings, this implementation always returns empty strings.
+{
+public:
+	enum
+	{
+		ELEMENT_NODE = 1,             /// The node is an Element.
+		ATTRIBUTE_NODE,               /// The node is an Attr.
+		TEXT_NODE,                    /// The node is a Text node.
+		CDATA_SECTION_NODE,           /// The node is a CDATASection.
+		ENTITY_REFERENCE_NODE,        /// The node is an EntityReference.
+		ENTITY_NODE,                  /// The node is an Entity.
+		PROCESSING_INSTRUCTION_NODE,  /// The node is a ProcessingInstruction.
+		COMMENT_NODE,                 /// The node is a Comment.
+		DOCUMENT_NODE,                /// The node is a Document.
+		DOCUMENT_TYPE_NODE,           /// The node is a DocumentType.
+		DOCUMENT_FRAGMENT_NODE,       /// The node is a DocumentFragment.
+		NOTATION_NODE                 /// The node is a Notation.
+	};
+
+	virtual const XMLString& nodeName() const = 0;
+		/// Returns the name of this node, depending on its type.
+
+	const XMLString& nodeValue() const;
+		/// Returns the value of this node, depending on its type.
+
+	virtual const XMLString& getNodeValue() const = 0;
+		/// Returns the value of this node, depending on its type.
+
+	virtual void setNodeValue(const XMLString& value) = 0;
+		/// Sets the value of this node. Throws an exception
+		/// if the node is read-only.
+
+	virtual unsigned short nodeType() const = 0;
+		/// Returns a code representing the type of the underlying object.
+
+	virtual Node* parentNode() const = 0;
+		/// The parent of this node. All nodes, except Attr, Document, DocumentFragment,
+		/// Entity, and Notation may have a parent. However, if a node has just been
+		/// created and not yet added to the tree, or if it has been removed from the
+		/// tree, this is null.
+
+	virtual NodeList* childNodes() const = 0;
+		/// Returns a NodeList containing all children of this node.
+		///
+		/// The returned NodeList must be released with a call
+		/// to release() when no longer needed.
+
+	virtual Node* firstChild() const = 0;
+		/// Returns the first child of this node. If there is no such
+		/// node, this returns null.
+
+	virtual Node* lastChild() const = 0;
+		/// Returns the last child of this node. If there is no such
+		/// node, this returns null.
+
+	virtual Node* previousSibling() const = 0;
+		/// Returns the node immediately preceding this node. If there
+		/// is no such node, this returns null.
+
+	virtual Node* nextSibling() const = 0;
+		/// Returns the node immediately following this node. If there
+		/// is no such node, this returns null.
+
+	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.
+
+	virtual Document* ownerDocument() const = 0;
+		/// Returns the Document object associated with this node.
+		/// This is also the Document object used to create new nodes.
+		/// When this node is a Document, this is null.
+
+	virtual Node* insertBefore(Node* newChild, Node* refChild) = 0;
+		/// Inserts the node newChild before the existing child node refChild.
+		///
+		/// If refChild is null, insert newChild at the end of the list of children.
+		/// If newChild is a DocumentFragment object, all of its children are
+		/// inserted in the same order, before refChild. If the newChild is already
+		/// in the tree, it is first removed.
+
+	virtual Node* replaceChild(Node* newChild, Node* oldChild) = 0;
+		/// Replaces the child node oldChild with newChild in the list of children,
+		/// and returns the oldChild node.
+		/// If newChild is a DocumentFragment object, oldChild is replaced by all of
+		/// the DocumentFragment children, which are inserted in the same order. If
+		/// the newChild is already in the tree, it is first removed.
+
+	virtual Node* removeChild(Node* oldChild) = 0;
+		/// Removes the child node indicated by oldChild from the list of children
+		/// 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 
+		/// node has any children.
+		/// Returns true if the node has any children, false otherwise.
+
+	virtual Node* cloneNode(bool deep) const = 0;
+		/// Returns a duplicate of this node, i.e., serves as a generic copy constructor
+		/// for nodes. The duplicate node has no parent; (parentNode is null.).
+		/// Cloning an Element copies all attributes and their values, including those
+		/// generated by the XML processor to represent defaulted attributes, but this
+		/// method does not copy any text it contains unless it is a deep clone, since
+		/// the text is contained in a child Text node. Cloning an Attribute directly,
+		/// as opposed to be cloned as part of an Element cloning operation, returns
+		/// a specified attribute (specified is true). Cloning any other type of node
+		/// simply returns a copy of this node.
+		/// Note that cloning an immutable subtree results in a mutable copy, but the
+		/// 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,
+		/// including attribute nodes, into a "normal" form where only structure (e.g.,
+		/// elements, comments, processing instructions, CDATA sections, and entity
+		/// references) separates Text nodes, i.e., there are neither adjacent Text
+		/// nodes nor empty Text nodes. This can be 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.
+
+	virtual bool isSupported(const XMLString& feature, const XMLString& version) const = 0;
+		/// 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 
+		/// given at creation time.
+		///
+		/// 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.
+
+	virtual XMLString prefix() const = 0;
+		/// Returns the namespace prefix from the qualified name of the node.
+
+	virtual const XMLString& localName() const = 0;
+		/// Returns the local name of the node.
+
+	virtual bool hasAttributes() const = 0;
+		/// Returns whether this node (if it is an element) has any attributes.
+		
+	// Extensions
+	typedef Poco::XML::NamespaceSupport NSMap;
+
+	virtual XMLString innerText() const = 0;
+		/// Returns a string containing the concatenated values of the node
+		/// 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 
+		/// 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, 
+		/// 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 
+		/// the entire subtree for the first element.
+		///
+		/// Examples:
+		///     elem1/elem2/elem3
+		///     /elem1/elem2/elem3
+		///     /elem1/elem2[1]
+		///     /elem1/elem2[@attr1]
+		///     /elem1/elem2[@attr1='value']
+		///     //elem2[@attr1='value']
+		///     //[@attr1='value']
+		///
+		/// 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 
+		/// expression. The given NSMap must contain mappings from namespace
+		/// 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, 
+		/// 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 
+		/// the entire subtree for the first element.
+		///
+		/// Examples:
+		///     /ns1:elem1/ns2:elem2/ns2:elem3
+		///     /ns1:elem1/ns2:elem2[1]
+		///     /ns1:elem1/ns2:elem2[@attr1]
+		///     /ns1:elem1/ns2:elem2[@attr1='value']
+		///     //ns2:elem2[@ns1:attr1='value']
+		///     //[@ns1:attr1='value']
+		///
+		/// This method is an extension to the W3C Document Object Model.
+
+protected:
+	virtual ~Node();
+};
+
+
+//
+// inlines
+//
+inline const XMLString& Node::nodeValue() const
+{
+	return getNodeValue();
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Node_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/NodeAppender.h b/contrib/libs/poco/XML/include/Poco/DOM/NodeAppender.h
new file mode 100644
index 0000000000..2d36be2e3c
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/NodeAppender.h
@@ -0,0 +1,81 @@
+//
+// NodeAppender.h
+//
+// Library: XML
+// Package: DOM
+// Module:  NodeAppender
+//
+// Definition of the NodeAppender class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_NodeAppender_INCLUDED
+#define DOM_NodeAppender_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/Node.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class AbstractNode;
+class Element;
+
+
+class XML_API NodeAppender
+	/// The NodeAppender class provides a very fast way to
+	/// build larger DOM documents.
+	///
+	/// 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 
+	/// requirements of the DOM specification.
+	///
+	/// While the NodeAppender is being used on an Element, no
+	/// children-modifying methods of that Element must be used.
+	///
+	/// This class is not part of the DOM specification.
+{
+public:
+	NodeAppender(Element* parent);
+		/// Creates the NodeAppender for the given parent node,
+		/// which must be an Element.
+
+	~NodeAppender();
+		/// Destroys the NodeAppender.
+
+	void appendChild(Node* newChild);
+		/// Appends the node newChild to the end of the list of children of
+		/// the parent node specified in the constructor.
+		/// If the newChild is already in the tree, it is first removed.
+		///
+		/// NewChild can be a DocumentFragment. In this case, all children
+		/// of the fragment become children of the parent element.
+		///
+		/// In order to speed up the function, no DOM events
+		/// are fired.
+
+private:
+	NodeAppender();
+	NodeAppender(const NodeAppender&);
+	NodeAppender& operator = (const NodeAppender&);
+	
+	Element*      _pParent;
+	AbstractNode* _pLast;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // #include "Poco/XML/XML.h"
+
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/NodeFilter.h b/contrib/libs/poco/XML/include/Poco/DOM/NodeFilter.h
new file mode 100644
index 0000000000..ae8677bf28
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/NodeFilter.h
@@ -0,0 +1,146 @@
+//
+// NodeFilter.h
+//
+// Library: XML
+// Package: DOM
+// Module:  NodeFilter
+//
+// Definition of the DOM NodeFilter interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_NodeFilter_INCLUDED
+#define DOM_NodeFilter_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+
+
+class XML_API NodeFilter
+	/// Filters are objects that know how to "filter out" nodes. If a NodeIterator
+	/// or TreeWalker is given a NodeFilter, it applies the filter before it returns
+	/// 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
+	/// to know how to do is evaluate a single node. One filter may be used with
+	/// a number of different kinds of traversals, encouraging code reuse.
+{
+public:
+	enum
+	{
+		FILTER_ACCEPT = 1,
+			/// Accept the node. Navigation methods defined for NodeIterator or TreeWalker will return this node.
+
+		FILTER_REJECT = 2,
+			/// Reject the node. Navigation methods defined for NodeIterator or TreeWalker
+			/// will not return this node. For TreeWalker, the children of this node will
+			/// also be rejected. NodeIterators treat this as a synonym for FILTER_SKIP.
+
+		FILTER_SKIP   = 3
+			/// Skip this single node. Navigation methods defined for NodeIterator or TreeWalker
+			/// 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,
+		/// and their values are derived by using a bit position corresponding to the
+		/// 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 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
+			/// attributes are never children of other nodes, they do not appear when traversing
+			/// over the document tree.
+
+		SHOW_TEXT                   = 0x00000004,
+			/// Show Text nodes.
+
+		SHOW_CDATA_SECTION          = 0x00000008,
+			/// Show CDATASection nodes.
+
+		SHOW_ENTITY_REFERENCE       = 0x00000010,
+			/// Show EntityReference nodes.
+
+		SHOW_ENTITY                 = 0x00000020,
+			/// Show Entity nodes. This is meaningful only when creating an iterator or
+			/// tree-walker with an Entity node as its root; in this case, it means that
+			/// the Entity node will appear in the first position of the traversal. Since
+			/// entities are not part of the document tree, they do not appear when traversing
+			/// over the document tree.
+
+		SHOW_PROCESSING_INSTRUCTION = 0x00000040,
+			/// Show ProcessingInstruction nodes.
+
+		SHOW_COMMENT                = 0x00000080,
+			/// Show Comment nodes.
+
+		SHOW_DOCUMENT               = 0x00000100,
+			/// Show Document nodes.
+
+		SHOW_DOCUMENT_TYPE          = 0x00000200,
+			/// Show DocumentType nodes.
+
+		SHOW_DOCUMENT_FRAGMENT      = 0x00000400,
+			/// Show DocumentFragment nodes.
+
+		SHOW_NOTATION               = 0x00000800
+			/// Show Notation nodes. This is meaningful only when creating an iterator or
+			/// tree-walker with a Notation node as its root; in this case, it means that
+			/// the Notation node will appear in the first position of the traversal. Since
+			/// 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
+		/// and NodeIterator; it is not normally called directly from user code. (Though
+		/// you could do so if you wanted to use the same filter to guide your own application
+		/// logic.)
+		///
+		/// Returns FILTER_ACCEPT, FILTER_REJECT or FILTER_SKIP.
+		
+protected:
+	virtual ~NodeFilter();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_NodeFilter_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/NodeIterator.h b/contrib/libs/poco/XML/include/Poco/DOM/NodeIterator.h
new file mode 100644
index 0000000000..1f8e9a063b
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/NodeIterator.h
@@ -0,0 +1,167 @@
+//
+// NodeIterator.h
+//
+// Library: XML
+// Package: DOM
+// Module:  NodeIterator
+//
+// Definition of the DOM NodeIterator class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_NodeIterator_INCLUDED
+#define DOM_NodeIterator_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+class NodeFilter;
+
+
+class XML_API NodeIterator
+	/// Iterators are used to step through a set of nodes, e.g. the set of nodes
+	/// in a NodeList, the document subtree governed by a particular Node, the results
+	/// of a query, or any other set of nodes. The set of nodes to be iterated is
+	/// determined by the implementation of the NodeIterator. DOM Level 2 specifies
+	/// a single NodeIterator implementation for document-order traversal of a document
+	/// subtree.
+	///
+	/// A NodeIterator can be directly instantiated using one of its constructors -
+	/// the DocumentTraversal interface is not needed and therefore not implemented.
+	/// Unlike most other DOM classes, NodeIterator supports value semantics.
+	///
+	/// If the NodeIterator's current node is removed from the document, the
+	/// result of calling any of the movement methods is undefined. This behavior does
+	/// not conform to the DOM Level 2 Traversal specification.
+{
+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.
+
+	Node* root() const;
+		/// 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, 
+		/// if any.
+
+	NodeFilter* filter() const;
+		/// The NodeFilter used to screen nodes.
+
+	bool expandEntityReferences() const;
+		/// The value of this flag determines whether the children of entity reference
+		/// nodes are visible to the iterator. If false, they and their descendants
+		/// will be rejected. Note that this rejection takes precedence over whatToShow
+		/// 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
+		/// when creating the iterator. To produce a view of the document that has entity
+		/// reference nodes but no entity expansion, use the whatToShow flags to show
+		/// the entity reference node and set expandEntityReferences to false.
+		///
+		/// This implementation does not support entity reference expansion and
+		/// thus always returns false.
+
+	Node* nextNode();
+		/// Returns the next node in the set and advances the position of the iterator
+		/// in the set. After a NodeIterator is created, the first call to nextNode()
+		/// returns the first node in the set.
+
+	Node* previousNode();
+		/// Returns the previous node in the set and moves the position of the NodeIterator
+		/// backwards in the set.
+
+	Node* currentNodeNP() const;
+		/// Returns the current node in the set.
+		///
+		/// Leaves the NodeIterator unchanged.
+		///
+		/// Warning: This is a proprietary extension to the DOM Level 2 NodeIterator
+		/// interface.
+
+	void detach();
+		/// Detaches the NodeIterator from the set which it iterated over, releasing
+		/// any computational resources and placing the iterator in the INVALID state.
+		/// After detach has been invoked, calls to nextNode or previousNode will raise
+		/// the exception INVALID_STATE_ERR.
+
+protected:
+	bool accept(Node* pNode) const;
+	Node* next() const;
+	Node* previous() const;
+	Node* last();
+
+private:
+	NodeIterator();
+	
+	Node*         _pRoot;
+	unsigned long _whatToShow;
+	NodeFilter*   _pFilter;
+	Node*         _pCurrent;
+};
+
+
+//
+// inlines
+//
+inline Node* NodeIterator::root() const
+{
+	return _pRoot;
+}
+
+
+inline Node* NodeIterator::currentNodeNP() const
+{
+	return _pCurrent;
+}
+
+
+inline unsigned long NodeIterator::whatToShow() const
+{
+	return _whatToShow;
+}
+
+
+inline NodeFilter* NodeIterator::filter() const
+{
+	return _pFilter;
+}
+
+
+inline bool NodeIterator::expandEntityReferences() const
+{
+	return false;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_NodeIterator_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/NodeList.h b/contrib/libs/poco/XML/include/Poco/DOM/NodeList.h
new file mode 100644
index 0000000000..1f8c12f4cd
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/NodeList.h
@@ -0,0 +1,61 @@
+//
+// NodeList.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM NodeList interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_NodeList_INCLUDED
+#define DOM_NodeList_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/DOMObject.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+
+
+class XML_API NodeList: public DOMObject
+	/// The NodeList interface provides the abstraction of an ordered
+	/// collection of nodes, without defining or constraining how this
+	/// collection is implemented.
+	///
+	/// 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 
+	/// release() when no longer needed.
+{
+public:
+	virtual Node* item(unsigned long index) const = 0;
+		/// Returns the index'th item in the collection. If index is
+		/// greater than or equal to the number of nodes in the list,
+		/// this returns null.
+
+	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();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_NodeList_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/Notation.h b/contrib/libs/poco/XML/include/Poco/DOM/Notation.h
new file mode 100644
index 0000000000..c9824b0e05
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/Notation.h
@@ -0,0 +1,93 @@
+//
+// Notation.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Notation class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Notation_INCLUDED
+#define DOM_Notation_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractNode.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+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/>), 
+	/// 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:
+	const XMLString& publicId() const;
+		/// Returns the public identifier of this notation.
+		/// If not specified, this is an empty string (and not null,
+		/// as in the DOM specification).
+
+	const XMLString& systemId() const;
+		/// Returns the system identifier of this notation.
+		/// If not specified, this is an empty string (and not null,
+		/// as in the DOM specification).
+
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+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;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& Notation::publicId() const
+{
+	return _publicId;
+}
+
+
+inline const XMLString& Notation::systemId() const
+{
+	return _systemId;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Notation_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/ProcessingInstruction.h b/contrib/libs/poco/XML/include/Poco/DOM/ProcessingInstruction.h
new file mode 100644
index 0000000000..ab600ca952
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/ProcessingInstruction.h
@@ -0,0 +1,99 @@
+//
+// ProcessingInstruction.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM ProcessingInstruction class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_ProcessingInstruction_INCLUDED
+#define DOM_ProcessingInstruction_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractNode.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API ProcessingInstruction: public AbstractNode
+	/// The ProcessingInstruction interface represents a "processing instruction",
+	/// used in XML as a way to keep processor-specific information in the text
+	/// of the document.
+{
+public:
+	const XMLString& target() const;
+		/// Returns the target of this processing instruction.
+		/// XML defines this as being the first token following
+		/// the markup that begins the processing instruction.
+
+	const XMLString& data() const;
+		/// 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 
+		/// white space character after the target to the character immediately preceding
+		/// the ?>.
+
+	void setData(const XMLString& data);
+		/// Sets the content of this processing instruction.
+
+	// Node
+	const XMLString& nodeName() const;
+	const XMLString& getNodeValue() const;
+	void setNodeValue(const XMLString& data);
+	unsigned short nodeType() const;
+
+protected:
+	ProcessingInstruction(Document* pOwnerDocument, const XMLString& target, const XMLString& data);
+	ProcessingInstruction(Document* pOwnerDocument, const ProcessingInstruction& processingInstruction);
+	~ProcessingInstruction();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	XMLString _target;
+	XMLString _data;
+	
+	friend class Document;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& ProcessingInstruction::target() const
+{
+	return _target;
+}
+
+
+inline const XMLString& ProcessingInstruction::data() const
+{
+	return _data;
+}
+
+
+inline const XMLString& ProcessingInstruction::getData() const
+{
+	return _data;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_ProcessingInstruction_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/Text.h b/contrib/libs/poco/XML/include/Poco/DOM/Text.h
new file mode 100644
index 0000000000..3a7931a8b2
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/Text.h
@@ -0,0 +1,79 @@
+//
+// Text.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Text class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Text_INCLUDED
+#define DOM_Text_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/CharacterData.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API Text: public CharacterData
+	/// The Text interface inherits from CharacterData and represents the textual
+	/// content (termed character data in XML) of an Element or Attr. If there is
+	/// no markup inside an element's content, the text is contained in a single
+	/// 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
+	/// be aware that there is no way to represent the separations between these
+	/// nodes in XML or HTML, so they will not (in general) persist between DOM
+	/// editing sessions. The normalize() method on Element merges any such adjacent
+	/// Text objects into a single node for each block of text.
+{
+public:
+	Text* splitText(unsigned long offset);
+		/// Breaks this node into two nodes at the specified offset, keeping both in
+		/// the tree as siblings. This node then only contains all the content up to
+		/// the offset point. A new node of the same type, which is inserted as the
+		/// next sibling of this node, contains all the content at and after the offset
+		/// point. When the offset is equal to the length of this node, the new node
+		/// has no data.
+
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+	// Non-standard extensions
+	XMLString innerText() const;
+
+protected:
+	Text(Document* pOwnerDocument, const XMLString& data);
+	Text(Document* pOwnerDocument, const Text& text);
+	~Text();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	static const XMLString NODE_NAME;
+	
+	friend class Document;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Text_INCLUDED
diff --git a/contrib/libs/poco/XML/include/Poco/DOM/TreeWalker.h b/contrib/libs/poco/XML/include/Poco/DOM/TreeWalker.h
new file mode 100644
index 0000000000..884b37d3c7
--- /dev/null
+++ b/contrib/libs/poco/XML/include/Poco/DOM/TreeWalker.h
@@ -0,0 +1,211 @@
+//
+// TreeWalker.h
+//
+// Library: XML
+// Package: DOM
+// Module:  TreeWalker
+//
+// Definition of the DOM TreeWalker class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_TreeWalker_INCLUDED
+#define DOM_TreeWalker_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+class NodeFilter;
+
+
+class XML_API TreeWalker
+	/// TreeWalker objects are used to navigate a document tree or subtree using
+	/// 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
+	/// of different, widely separated nodes in the original view. For instance,
+	/// consider a NodeFilter that skips all nodes except for Text nodes and the
+	/// root node of a document. In the logical view that results, all text nodes
+	/// will be siblings and appear as direct children of the root node, no matter
+	/// how deeply nested the structure of the original document.
+	///
+	/// A TreeWalker can be directly instantiated using one of its constructors -
+	/// the DocumentTraversal interface is not needed and therefore not implemented.
+	/// 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 
+	/// 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.
+
+	unsigned long whatToShow() const;
+		/// This attribute determines which node types are presented via the TreeWalker.
+		/// 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;
+		/// The NodeFilter used to screen nodes.
+
+	bool expandEntityReferences() const;
+		/// The value of this flag determines whether the children of entity reference
+		/// nodes are visible to the iterator. If false, they and their descendants
+		/// will be rejected. Note that this rejection takes precedence over whatToShow
+		/// 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
+		/// when creating the iterator. To produce a view of the document that has entity
+		/// reference nodes but no entity expansion, use the whatToShow flags to show
+		/// the entity reference node and set expandEntityReferences to false.
+		///
+		/// This implementation does not support entity reference expansion and
+		/// thus always returns false.
+
+	Node* currentNode() const;
+		/// The node at which the TreeWalker is currently positioned.
+		/// Alterations to the DOM tree may cause the current node to no longer be accepted
+		/// by the TreeWalker's associated filter. currentNode may also be explicitly
+		/// set to any node, whether or not it is within the subtree specified by the
+		/// root node or would be accepted by the filter and whatToShow flags. Further
+		/// traversal occurs relative to currentNode even if it is not part of the current
+		/// view, by applying the filters in the requested direction; if no traversal
+		/// is possible, currentNode is not changed.
+
+	Node* getCurrentNode() const;
+		/// See currentNode().
+		
+	void setCurrentNode(Node* pNode);
+		/// Sets the current node.
+
+	Node* parentNode();
+		/// Moves to and returns the closest visible ancestor node of the current node.
+		/// If the search for parentNode attempts to step upward from the TreeWalker's
+		/// root node, or if it fails to find a visible ancestor node, this method retains
+		/// the current position and returns null.
+
+	Node* firstChild();
+		/// Moves the TreeWalker to the first visible child of the current node, and
+		/// returns the new node. If the current node has no visible children, returns
+		/// null, and retains the current node.
+
+	Node* lastChild();
+		/// Moves the TreeWalker to the last visible child of the current node, and
+		/// returns the new node. If the current node has no visible children, returns
+		/// null, and retains the current node.
+
+	Node* previousSibling();
+		/// Moves the TreeWalker to the previous sibling of the current node, and returns
+		/// the new node. If the current node has no visible previous sibling, returns
+		/// null, and retains the current node.
+
+	Node* nextSibling();
+		/// Moves the TreeWalker to the next sibling of the current node, and returns
+		/// the new node. If the current node has no visible next sibling, returns null,
+		/// and retains the current node.
+
+	Node* previousNode();
+		/// Moves the TreeWalker to the previous visible node in document order relative
+		/// to the current node, and returns the new node. If the current node has no
+		/// previous node, or if the search for previousNode attempts to step upward
+		/// from the TreeWalker's root node, returns null, and retains the current node.
+
+	Node* nextNode();
+		/// Moves the TreeWalker to the next visible node in document order relative
+		/// to the current node, and returns the new node. If the current node has no
+		/// next node, or if the search for nextNode attempts to step upward from the
+		/// TreeWalker's root node, returns null, and retains the current node.
+
+protected:
+	int accept(Node* pNode) const;
+	Node* next(Node* pNode) const;
+	Node* previous(Node* pNode) const;
+
+private:
+	TreeWalker();
+	
+	Node*         _pRoot;
+	unsigned long _whatToShow;
+	NodeFilter*   _pFilter;
+	Node*         _pCurrent;
+};
+
+
+//
+// inlines
+//
+inline Node* TreeWalker::root() const
+{
+	return _pRoot;
+}
+
+
+inline unsigned long TreeWalker::whatToShow() const
+{
+	return _whatToShow;
+}
+
+
+inline NodeFilter* TreeWalker::filter() const
+{
+	return _pFilter;
+}
+
+
+inline bool TreeWalker::expandEntityReferences() const
+{
+	return false;
+}
+
+
+inline Node* TreeWalker::currentNode() const
+{
+	return _pCurrent;
+}
+
+
+inline Node* TreeWalker::getCurrentNode() const
+{
+	return _pCurrent;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_TreeWalker_INCLUDED