angular-xml-editor
Version:
XML editor component for Angular
4,039 lines • 439 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs'), require('@angular/core'), require('@angular/common'), require('@angular/forms')) :
typeof define === 'function' && define.amd ? define('angular-xml-editor', ['exports', 'rxjs', '@angular/core', '@angular/common', '@angular/forms'], factory) :
(factory((global['angular-xml-editor'] = {}),global.rxjs,global.ng.core,global.ng.common,global.ng.forms));
}(this, (function (exports,rxjs,i0,i1,forms) { 'use strict';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlEditorDebugger = /** @class */ (function () {
function XmlEditorDebugger() {
this.actualCursorPosChanged$ = new rxjs.Subject();
this.inputSelectionChanged$ = new rxjs.Subject();
}
/**
* @param {?} pos
* @return {?}
*/
XmlEditorDebugger.prototype.setActualCursorPos = /**
* @param {?} pos
* @return {?}
*/
function (pos) {
this.actualCursorPosChanged$.next(pos);
};
/**
* @param {?} info
* @return {?}
*/
XmlEditorDebugger.prototype.setInputSelection = /**
* @param {?} info
* @return {?}
*/
function (info) {
this.inputSelectionChanged$.next(info);
};
/**
* @return {?}
*/
XmlEditorDebugger.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this.actualCursorPosChanged$.complete();
this.inputSelectionChanged$.complete();
};
return XmlEditorDebugger;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlToolbox = /** @class */ (function () {
function XmlToolbox() {
}
/**
* @param {?} node
* @return {?}
*/
XmlToolbox.IsTextOrCommentNode = /**
* @param {?} node
* @return {?}
*/
function (node) {
switch (node.nodeType) {
case Node.TEXT_NODE: // text node
case Node.COMMENT_NODE:
return true;
default:
return false;
}
// return ((node.nodeType === System.Xml.XmlText) || (node.nodeType === System.Xml.XmlComment));
};
/**
* @param {?} node
* @return {?}
*/
XmlToolbox.GetNodeDebugContext = /**
* @param {?} node
* @return {?}
*/
function (node) {
if (node === null || node === undefined) {
return 'NULL';
}
if (node.nodeType === Node.TEXT_NODE) {
if (node.textContent === ' ' || node.textContent === String.fromCharCode(160)) {
return "TextContent!Parent=" + XmlToolbox.GetNodeDebugContext(node.parentNode);
}
else {
return "TextContent='" + node.textContent + "'";
}
}
/** @type {?} */
var asElem = /** @type {?} */ (node);
if (asElem === undefined) {
return "localName: " + node.nodeName + ", nodeType:" + node.nodeType;
}
else {
return asElem.outerHTML;
}
};
return XmlToolbox;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var Xml2htmlAttributeWorker = /** @class */ (function () {
function Xml2htmlAttributeWorker(rules) {
this.rules = rules;
}
/** writes the given attributes to the html node in data-attribute-syntax **/
/**
* writes the given attributes to the html node in data-attribute-syntax *
* @param {?} xmlElement
* @param {?} htmlElement
* @return {?}
*/
Xml2htmlAttributeWorker.prototype.writeAllXmlAttributesToHtml = /**
* writes the given attributes to the html node in data-attribute-syntax *
* @param {?} xmlElement
* @param {?} htmlElement
* @return {?}
*/
function (xmlElement, htmlElement) {
/** @type {?} */
var attributes = xmlElement.attributes;
for (var i = 0; i < attributes.length; ++i) {
/** @type {?} */
var attr = attributes[i];
this.writeAttributeToHtml(htmlElement, attr.name, attr.value);
}
};
/** writes the given attribute value to the html node in data-attribute-syntax **/
/**
* writes the given attribute value to the html node in data-attribute-syntax *
* @param {?} htmlElement
* @param {?} key
* @param {?} value
* @return {?}
*/
Xml2htmlAttributeWorker.prototype.writeAttributeToHtml = /**
* writes the given attribute value to the html node in data-attribute-syntax *
* @param {?} htmlElement
* @param {?} key
* @param {?} value
* @return {?}
*/
function (htmlElement, key, value) {
/** @type {?} */
var name = "" + Xml2htmlAttributeWorker.DataAttribPraefix + key;
if (value && value.length > 0) {
htmlElement.setAttribute(name, value);
}
else {
htmlElement.removeAttribute(name);
}
this.updateAttributesDescriptionInHtmlElement(htmlElement);
};
/** writes the given attribute value from the html node data-attribute-syntax **/
/**
* writes the given attribute value from the html node data-attribute-syntax *
* @param {?} htmlElement
* @param {?} key
* @return {?}
*/
Xml2htmlAttributeWorker.prototype.getAttributeValueFromHtml = /**
* writes the given attribute value from the html node data-attribute-syntax *
* @param {?} htmlElement
* @param {?} key
* @return {?}
*/
function (htmlElement, key) {
/** @type {?} */
var attributes = htmlElement.attributes;
for (var i = 0; i < attributes.length; ++i) {
if (attributes[i].name === "" + Xml2htmlAttributeWorker.DataAttribPraefix + key) {
return attributes[i].value;
}
}
return undefined;
};
/** writes the given attribute value to the xml node (and gets it from the html node from data-attribute-syntax) **/
/**
* writes the given attribute value to the xml node (and gets it from the html node from data-attribute-syntax) *
* @param {?} htmlElement
* @param {?} xmlElement
* @return {?}
*/
Xml2htmlAttributeWorker.prototype.writeAllHtmlAttributesToXml = /**
* writes the given attribute value to the xml node (and gets it from the html node from data-attribute-syntax) *
* @param {?} htmlElement
* @param {?} xmlElement
* @return {?}
*/
function (htmlElement, xmlElement) {
/** @type {?} */
var attributes = htmlElement.attributes;
for (var i = 0; i < attributes.length; ++i) {
/** @type {?} */
var attr = attributes[i];
if (attr.name.startsWith(Xml2htmlAttributeWorker.DataAttribPraefix)) {
xmlElement.setAttribute(attr.name.substr(Xml2htmlAttributeWorker.DataAttribPraefix.length), attr.value);
}
}
};
/**
* updates the 'for human eyes' only description of the attributes inside a html node *
* @param {?} htmlElement
* @return {?}
*/
Xml2htmlAttributeWorker.prototype.updateAttributesDescriptionInHtmlElement = /**
* updates the 'for human eyes' only description of the attributes inside a html node *
* @param {?} htmlElement
* @return {?}
*/
function (htmlElement) {
/** @type {?} */
var attributes = htmlElement.attributes;
/** @type {?} */
var allAttributes = '';
for (var i = 0; i < attributes.length; ++i) {
/** @type {?} */
var attr = attributes[i];
if (attr.name.startsWith(Xml2htmlAttributeWorker.DataAttribPraefix)) {
allAttributes = allAttributes + " " + attr.name.substr(Xml2htmlAttributeWorker.DataAttribPraefix.length) + "=\"" + attr.value + "\"";
}
}
if (allAttributes.length > 0) {
htmlElement.setAttribute('data-attributes', allAttributes);
}
else {
htmlElement.removeAttribute('data-attributes');
}
};
Xml2htmlAttributeWorker.DataAttribPraefix = 'data-attribute-';
return Xml2htmlAttributeWorker;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var Xml2html = /** @class */ (function () {
function Xml2html(rules) {
this.rules = rules;
this.attributeWorker = new Xml2htmlAttributeWorker(rules);
}
/**
* @param {?} node
* @return {?}
*/
Xml2html.getTagNameFromNode = /**
* @param {?} node
* @return {?}
*/
function (node) {
/** @type {?} */
var elem = /** @type {?} */ (node);
/** @type {?} */
var name = '';
if (elem) {
name = elem.getAttribute(Xml2html.DataTagName);
}
if (name === undefined || name === null || name === '') {
throw new Error("node has no DataTagName attribute " + XmlToolbox.GetNodeDebugContext(node));
}
return name;
};
/**
* @param {?} node
* @return {?}
*/
Xml2html.isFloatingElement = /**
* @param {?} node
* @return {?}
*/
function (node) {
/** @type {?} */
var elem = /** @type {?} */ (node);
if (elem && elem.classList) {
return elem.classList.contains(Xml2html.FloatingTagClassName);
}
return false;
};
/**
* @param {?} node
* @return {?}
*/
Xml2html.isNoClosingElement = /**
* @param {?} node
* @return {?}
*/
function (node) {
/** @type {?} */
var elem = /** @type {?} */ (node);
if (elem && elem.classList) {
return elem.classList.contains(Xml2html.NoClosingTagClassName);
}
return false;
};
/**
* @param {?} xml
* @return {?}
*/
Xml2html.prototype.ToHtml = /**
* @param {?} xml
* @return {?}
*/
function (xml) {
if (xml === '' || xml === undefined || xml === null) {
return '';
}
// alert(xml);
// remove newline / carriage return
xml = xml.replace(/\n/g, '');
xml = xml.replace(/\r/g, '');
// remove whitespace (tabs) before tags
xml = xml.replace(/[\t]+\</g, '<');
// remove whitespace between tags
xml = xml.replace(/\>[\t]+\</g, '><');
// remove whitespace after tags
xml = xml.replace(/\>[\t]+$/g, '>');
/** @type {?} */
var domparser = new DOMParser();
/** @type {?} */
var domdoc = domparser.parseFromString(xml, 'text/xml');
/** @type {?} */
var targetDocument = new Document();
if (domdoc.documentElement === null) {
return '';
}
/** @type {?} */
var body = this.GetHtmlElementFromXmlElement(domdoc.documentElement, targetDocument);
if (body && body.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
var html = ( /** @type {?} */(body)).outerHTML;
return html;
}
else {
throw new Error("root node " + XmlToolbox.GetNodeDebugContext(body) + " is no element");
}
};
/**
* @param {?} ruleElem
* @return {?}
*/
Xml2html.prototype.createNewElementHtml = /**
* @param {?} ruleElem
* @return {?}
*/
function (ruleElem) {
/** @type {?} */
var elem = this.createNewElementByName(ruleElem.tagName);
return elem.outerHTML;
};
/**
* @param {?} tagName
* @return {?}
*/
Xml2html.prototype.createNewElementByName = /**
* @param {?} tagName
* @return {?}
*/
function (tagName) {
/** @type {?} */
var tempDoc = new Document();
/** @type {?} */
var newElement = tempDoc.createElement('div');
/** @type {?} */
var rule = this.rules.ruleElements.get(tagName);
if (rule && rule.floating === true) {
newElement.classList.add(Xml2html.FloatingTagClassName);
}
// visualize closing tag or not?
if (rule && rule.empty === true) {
newElement.classList.add(Xml2html.NoClosingTagClassName);
}
newElement.setAttribute(Xml2html.DataTagName, tagName);
return newElement;
};
/**
* @param {?} node
* @param {?} targetDocument
* @return {?}
*/
Xml2html.prototype.GetHtmlElementFromXmlElement = /**
* @param {?} node
* @param {?} targetDocument
* @return {?}
*/
function (node, targetDocument) {
switch (node.nodeType) {
case Node.ELEMENT_NODE: // element node
/** @type {?} */
var asElement = /** @type {?} */ (node);
/** @type {?} */
var nodeName = asElement.nodeName;
/** @type {?} */
var newElement = targetDocument.createElement('div');
/** @type {?} */
var rule = this.rules.ruleElements.get(nodeName);
if (rule && rule.floating) {
newElement.classList.add(Xml2html.FloatingTagClassName);
}
// visualize closing tag or not?
if (rule && rule.empty) {
newElement.classList.add(Xml2html.NoClosingTagClassName);
}
newElement.setAttribute(Xml2html.DataTagName, nodeName);
/** @type {?} */
var children = asElement.childNodes;
if (children.length === 0) {
newElement.appendChild(targetDocument.createTextNode('')); // to prevent non closing tags
}
else {
for (var i = 0; i < children.length; ++i) {
/** @type {?} */
var childAsHtml = this.GetHtmlElementFromXmlElement(children[i], targetDocument);
if (childAsHtml !== undefined) {
newElement.appendChild(childAsHtml);
}
}
}
// insert attributes
this.attributeWorker.writeAllXmlAttributesToHtml(asElement, newElement);
return newElement;
case Node.TEXT_NODE: // text node
/** @type {?} */
var content = ( /** @type {?} */(node)).textContent;
if (content.length > 0) {
return targetDocument.createTextNode(content);
}
else {
return undefined;
}
case Node.COMMENT_NODE:
// create element node
newElement = targetDocument.createElement('div');
newElement.classList.add(Xml2html.CommentTagClassName);
newElement.setAttribute(Xml2html.DataTagName, 'comment');
newElement.textContent = ( /** @type {?} */(node)).textContent;
return newElement;
/* yet not implemented types */
case Node.PROCESSING_INSTRUCTION_NODE:
console.warn("nodeType \"PROCESSING_INSTRUCTION_NODE\" " + XmlToolbox.GetNodeDebugContext(node) + " not implemented yet");
return undefined;
case Node.DOCUMENT_NODE:
throw new Error("nodeType \"Node.DOCUMENT_NODE\" " + XmlToolbox.GetNodeDebugContext(node) + " not implemented yet");
case Node.DOCUMENT_TYPE_NODE:
throw new Error("nodeType \"Node.DOCUMENT_NODE\" " + XmlToolbox.GetNodeDebugContext(node) + " not implemented yet");
case Node.DOCUMENT_FRAGMENT_NODE:
throw new Error("nodeType \"Node.DOCUMENT_FRAGMENT_NODE\" " + XmlToolbox.GetNodeDebugContext(node) + " not implemented yet");
/* Depreached node types */
case Node.ATTRIBUTE_NODE:
throw new Error("nodeType \"Node.ATTRIBUTE_NODE\" " + XmlToolbox.GetNodeDebugContext(node) + " is depreached");
case Node.CDATA_SECTION_NODE:
throw new Error("nodeType \"Node.CDATA_SECTION_NODE\" " + XmlToolbox.GetNodeDebugContext(node) + " is depreached");
case Node.ENTITY_REFERENCE_NODE:
throw new Error("nodeType \"Node.ENTITY_REFERENCE_NODE\" " + XmlToolbox.GetNodeDebugContext(node) + " is depreached");
case Node.ENTITY_NODE:
throw new Error("nodeType \"Node.ENTITY_NODE\" " + XmlToolbox.GetNodeDebugContext(node) + " is depreached");
case Node.NOTATION_NODE:
throw new Error("nodeType \"Node.NOTATION_NODE\" " + XmlToolbox.GetNodeDebugContext(node) + " is depreached");
default:
// tslint:disable-next-line:max-line-length
throw new Error("unknown xmlElement nodeType " + node.nodeType + " in value: " + XmlToolbox.GetNodeDebugContext(node));
}
};
Xml2html.DataTagName = 'data-tagname';
Xml2html.NoClosingTagClassName = 'xmlTagNoClosing';
Xml2html.FloatingTagClassName = 'floating';
Xml2html.CommentTagClassName = 'comment';
return Xml2html;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var DomDummyNodeManager = /** @class */ (function () {
function DomDummyNodeManager() {
}
/**
* @param {?} node
* @return {?}
*/
DomDummyNodeManager.IsDummyNode = /**
* @param {?} node
* @return {?}
*/
function (node) {
/** @type {?} */
var asElem = /** @type {?} */ (node);
if (asElem && node.nodeType === Node.ELEMENT_NODE) {
return asElem.classList.contains(DomDummyNodeManager.DummyNodeClassName);
}
return false;
};
/**
* @param {?} node
* @return {?}
*/
DomDummyNodeManager.IsBeforeFirstTagDummyNode = /**
* @param {?} node
* @return {?}
*/
function (node) {
if (DomDummyNodeManager.IsDummyNode(node)) {
/** @type {?} */
var asElem = /** @type {?} */ (node);
if (asElem && node.nodeType === Node.ELEMENT_NODE) {
return asElem.classList.contains(DomDummyNodeManager.DummyNodeBeforeFirstTagClassName);
}
return false;
}
else {
return false;
}
};
/**
* @param {?} node
* @return {?}
*/
DomDummyNodeManager.getPreviousSibling = /**
* @param {?} node
* @return {?}
*/
function (node) {
if (!node) {
return undefined;
}
while (node) {
node = node.previousSibling;
if (node) {
if (DomDummyNodeManager.IsDummyNode(node)) ;
else {
return node;
}
}
}
return undefined;
};
/**
* @param {?} node
* @return {?}
*/
DomDummyNodeManager.getNextSibling = /**
* @param {?} node
* @return {?}
*/
function (node) {
if (!node) {
return undefined;
}
while (node) {
node = node.nextSibling;
if (node) {
if (DomDummyNodeManager.IsDummyNode(node)) ;
else {
return node;
}
}
}
return undefined;
};
/**
* @param {?} node
* @return {?}
*/
DomDummyNodeManager.getChildNodeCount = /**
* @param {?} node
* @return {?}
*/
function (node) {
if (!node) {
return 0;
}
/** @type {?} */
var count = 0;
for (var i = 0; i < node.childNodes.length; i++) {
if (!DomDummyNodeManager.IsDummyNode(node.childNodes[i])) {
count++;
}
}
return count;
};
/**
* @param {?} node
* @return {?}
*/
DomDummyNodeManager.getFirstChild = /**
* @param {?} node
* @return {?}
*/
function (node) {
if (!node) {
return undefined;
}
/** @type {?} */
var first = /** @type {?} */ (node.firstChild);
while (DomDummyNodeManager.IsDummyNode(first)) {
first = first.nextSibling;
}
return first;
};
/**
* @param {?} node
* @return {?}
*/
DomDummyNodeManager.getLastChild = /**
* @param {?} node
* @return {?}
*/
function (node) {
if (!node) {
return undefined;
}
/** @type {?} */
var last = /** @type {?} */ (node.lastChild);
while (DomDummyNodeManager.IsDummyNode(last)) {
last = last.previousSibling;
}
return last;
};
/**
* @param {?} node
* @param {?=} nodeDepth
* @return {?}
*/
DomDummyNodeManager.prototype.RemoveAllDummyNodes = /**
* @param {?} node
* @param {?=} nodeDepth
* @return {?}
*/
function (node, nodeDepth) {
var _this = this;
if (nodeDepth === void 0) {
nodeDepth = 0;
}
/** @type {?} */
var children = [];
for (var i = 0; i < node.childNodes.length; ++i) {
children.push(node.childNodes[i]);
}
// delete all dummy node children
children.forEach(function (child) {
if (DomDummyNodeManager.IsDummyNode(child)) {
node.removeChild(child);
}
});
children = [];
for (var i = 0; i < node.childNodes.length; ++i) {
children.push(node.childNodes[i]);
}
// update child nodes
children.forEach(function (child) {
_this.RemoveAllDummyNodes(child, nodeDepth + 1);
});
};
/**
* @param {?} node
* @param {?=} nodeDepth
* @return {?}
*/
DomDummyNodeManager.prototype.UpdateDummyNodes = /**
* @param {?} node
* @param {?=} nodeDepth
* @return {?}
*/
function (node, nodeDepth) {
var _this = this;
if (nodeDepth === void 0) {
nodeDepth = 0;
}
/** @type {?} */
var document = node.ownerDocument;
/** @type {?} */
var asElement = /** @type {?} */ (node);
/** @type {?} */
var children = [];
for (var i = 0; i < node.childNodes.length; ++i) {
children.push(node.childNodes[i]);
}
if (asElement && !DomDummyNodeManager.IsDummyNode(asElement) && !DomDummyNodeManager.IsDummyNode(asElement.parentElement)) {
if (asElement.nodeType === Node.TEXT_NODE) {
/** @type {?} */
var before = asElement.previousSibling;
if (before.nodeType === Node.TEXT_NODE) ;
else {
if (!DomDummyNodeManager.IsDummyNode(before)) {
asElement.parentNode.insertBefore(this.createDummyNode(document), asElement);
}
}
}
if (asElement.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
var firstChild = node.firstChild;
if (!firstChild) {
// create dummy node in empty tag
node.appendChild(this.createDummyNode(document));
firstChild = node.firstChild;
}
if (Xml2html.isNoClosingElement(node)) ;
else {
firstChild = node.firstChild;
if (!firstChild) {
// create dummy node in empty tag
node.appendChild(this.createDummyNode(document));
firstChild = node.firstChild;
}
// Insert a dummy node before the first child
if (!DomDummyNodeManager.IsDummyNode(firstChild)) {
if (firstChild) {
node.insertBefore(this.createDummyNode(document), firstChild);
firstChild = node.firstChild;
}
else {
node.appendChild(this.createDummyNode(document));
}
}
/** @type {?} */
var lastChild = node.lastChild;
if (!DomDummyNodeManager.IsDummyNode(lastChild)) {
node.appendChild(this.createDummyNode(document));
lastChild = node.lastChild;
}
// Insert a dummy node before the first (dummy child) but optical in front of the node (to show the cursor in front of the node)
if (nodeDepth > 0) {
if (DomDummyNodeManager.IsDummyNode(firstChild) && !DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {
/** @type {?} */
var dummyNode = this.createDummyNode(document);
dummyNode.classList.add(DomDummyNodeManager.DummyNodeBeforeFirstTagClassName);
asElement.insertBefore(dummyNode, firstChild);
}
}
}
}
}
// update child nodes
children.forEach(function (child) {
_this.UpdateDummyNodes(child, nodeDepth + 1);
});
};
/**
* @param {?} targetDocument
* @param {?=} content
* @return {?}
*/
DomDummyNodeManager.prototype.createDummyNode = /**
* @param {?} targetDocument
* @param {?=} content
* @return {?}
*/
function (targetDocument, content) {
/** @type {?} */
var dummyNode = targetDocument.createElement('span');
/** @type {?} */
var dummy2TextNode;
if (content === undefined) {
dummy2TextNode = targetDocument.createTextNode(DomDummyNodeManager.DummyNodeContent);
}
else {
dummy2TextNode = targetDocument.createTextNode(content);
}
dummyNode.classList.add(DomDummyNodeManager.DummyNodeClassName);
dummyNode.appendChild(dummy2TextNode);
return dummyNode;
};
DomDummyNodeManager.DummyNodeClassName = 'dummyNode';
DomDummyNodeManager.DummyNodeBeforeFirstTagClassName = 'beforefirstTag';
DomDummyNodeManager.DummyNodeContent = String.fromCharCode(160);
return DomDummyNodeManager;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlCursorPos = /** @class */ (function () {
function XmlCursorPos() {
this.ActualNode = null; // no node selected
this.PosAtNode = XMLCursorPositions.CursorOnCompleteNode;
this.PosInTextnode = 0;
}
/**
* @param {?} position
* @return {?}
*/
XmlCursorPos.getXmlCursorPositionDebugName = /**
* @param {?} position
* @return {?}
*/
function (position) {
switch (position) {
case XMLCursorPositions.CursorOnCompleteNode:
return 'CursorOnCompleteNode';
case XMLCursorPositions.CursorBehindNode:
return 'CursorBehindNode';
case XMLCursorPositions.CursorInEmptyNode:
return 'CursorInEmptyNode';
case XMLCursorPositions.CursorInsideTextNode:
return 'CursorInsideTextNode';
case XMLCursorPositions.CursorInFrontOfNode:
return 'CursorInFrontOfNode';
default:
return "unknown cursorPos " + position;
}
};
/**
* @param {?} pos
* @return {?}
*/
XmlCursorPos.getSelectionForPos = /**
* @param {?} pos
* @return {?}
*/
function (pos) {
if (DomDummyNodeManager.IsDummyNode(pos.ActualNode)) {
throw new Error("XmlCursorPos.getSelectionForPos: pos.AktNode " + pos.getDebugDescription() + " is a dummy node!");
}
if (DomDummyNodeManager.IsDummyNode(pos.ActualNode.parentElement)) {
throw new Error("XmlCursorPos.getSelectionForPos: pos.AktNode.parentElement " + pos.getDebugDescription() + " is a dummy node!");
}
switch (pos.PosAtNode) {
case XMLCursorPositions.CursorOnCompleteNode: // (0)
/** @type {?} */
var firstChild = pos.ActualNode.firstChild;
if (DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {
return {
node: firstChild.firstChild,
// text inside BeforeFirstTagDummyNod
offset: 0
};
}
else {
return {
node: pos.ActualNode,
offset: 0
};
}
case XMLCursorPositions.CursorInFrontOfNode: // (1)
// (1)
if (pos.ActualNode.nodeType === Node.TEXT_NODE) {
/** @type {?} */
var dummyBefore = pos.ActualNode.previousSibling;
if (DomDummyNodeManager.IsDummyNode(dummyBefore)) {
return {
node: dummyBefore.firstChild,
// before text node
offset: 1
};
}
else {
throw new Error('XMLCursorPositions.CursorInFrontOfNode (1):text node: is no dummy node: ' + pos.getDebugDescription());
}
}
else {
// no text node
firstChild = pos.ActualNode.firstChild;
if (DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {
return {
node: firstChild.firstChild,
// text inside BeforeFirstTagDummyNod
offset: 1
};
}
if (Xml2html.isNoClosingElement(pos.ActualNode) && DomDummyNodeManager.IsDummyNode(firstChild)) {
return { node: firstChild.firstChild, offset: 1 };
}
throw new Error('XMLCursorPositions.CursorInFrontOfNode (1):no text node: dont know what to do! ');
}
break;
case XMLCursorPositions.CursorBehindNode: // (7, 11)
/** @type {?} */
var dummyAfter = pos.ActualNode.nextSibling;
if (DomDummyNodeManager.IsDummyNode(dummyAfter)) {
return {
node: dummyAfter.firstChild,
// before text node
offset: 0
};
}
else {
throw new Error("XMLCursorPositionen.CursorBehindNode should only be set, when the element has no next sibling.");
}
case XMLCursorPositions.CursorInEmptyNode:
/** @type {?} */
var lastChild = pos.ActualNode.lastChild;
if (!DomDummyNodeManager.IsDummyNode(firstChild) && !DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {
return {
node: lastChild.firstChild,
// text inside DummyNode
offset: 0
};
}
break;
case XMLCursorPositions.CursorInsideTextNode:
return {
node: pos.ActualNode,
offset: pos.PosInTextnode
};
}
throw new Error("showCursor.getSelectionForPos unknown CursorPos " + pos.getDebugDescription());
};
/**
* @return {?}
*/
XmlCursorPos.prototype.clone = /**
* @return {?}
*/
function () {
/** @type {?} */
var klon = new XmlCursorPos();
klon.SetCursor(this.ActualNode, this.PosAtNode, this.PosInTextnode);
return klon;
};
/**
* @param {?} otherPos
* @return {?}
*/
XmlCursorPos.prototype.equals = /**
* @param {?} otherPos
* @return {?}
*/
function (otherPos) {
if (!otherPos) {
return false;
}
if (otherPos.ActualNode !== this.ActualNode) {
return false;
}
if (otherPos.PosAtNode !== this.PosAtNode) {
return false;
}
if (this.PosAtNode === XMLCursorPositions.CursorInsideTextNode && this.PosInTextnode !== otherPos.PosInTextnode) {
return false;
}
return true;
};
/**
* @return {?}
*/
XmlCursorPos.prototype.getDebugDescription = /**
* @return {?}
*/
function () {
return "node:" + XmlToolbox.GetNodeDebugContext(this.ActualNode) + ", pos:" + XmlCursorPos.getXmlCursorPositionDebugName(this.PosAtNode) + ", posInText:" + this.PosInTextnode;
};
/**
* @param {?} actualNode
* @param {?} posAtNode
* @param {?=} posInTextnode
* @return {?}
*/
XmlCursorPos.prototype.SetCursor = /**
* @param {?} actualNode
* @param {?} posAtNode
* @param {?=} posInTextnode
* @return {?}
*/
function (actualNode, posAtNode, posInTextnode) {
if (posInTextnode === void 0) {
posInTextnode = 0;
}
if (!actualNode) {
throw new Error('actualNode is null');
}
if (actualNode !== this.ActualNode) ;
else {
if (posAtNode !== this.PosAtNode) ;
else {
if (posInTextnode !== this.PosInTextnode) ;
}
}
this.ActualNode = actualNode;
this.PosAtNode = posAtNode;
this.PosInTextnode = posInTextnode;
};
/**
* @param {?} node
* @return {?}
*/
XmlCursorPos.prototype.setCursorBehindNodeForDefaultOrRightMovement = /**
* @param {?} node
* @return {?}
*/
function (node) {
/** @type {?} */
var nextSibling = DomDummyNodeManager.getNextSibling(node);
if (nextSibling) {
this.SetCursor(nextSibling, XMLCursorPositions.CursorInFrontOfNode);
}
else {
this.SetCursor(node, XMLCursorPositions.CursorBehindNode);
}
};
/**
* @param {?} node
* @return {?}
*/
XmlCursorPos.prototype.setCursorpBehindNodeForLeftMovement = /**
* @param {?} node
* @return {?}
*/
function (node) {
if (XmlToolbox.IsTextOrCommentNode(node)) {
// For a text node, the cursor is placed after the last character.
this.SetCursor(node, XMLCursorPositions.CursorInsideTextNode, Math.max(0, node.textContent.length - 1));
}
else {
/** @type {?} */
var childNodeCount = DomDummyNodeManager.getChildNodeCount(node);
if (childNodeCount === 0) {
// There are no children in the node.
if (!Xml2html.isNoClosingElement(node)) {
// If the cursor shows a close tag, then put it in the empty node
this.SetCursor(node, XMLCursorPositions.CursorInEmptyNode);
}
else {
// If the cursor does not display a close tag, then place it before the empty node.
this.SetCursor(node, XMLCursorPositions.CursorInFrontOfNode);
}
}
else {
// There are children in node
this.SetCursor(DomDummyNodeManager.getLastChild(node), XMLCursorPositions.CursorBehindNode);
}
}
};
return XmlCursorPos;
}());
/** @enum {number} */
var XMLCursorPositions = {
CursorInFrontOfNode: 0,
CursorOnCompleteNode: 1,
CursorInEmptyNode: 2,
CursorInsideTextNode: 3,
CursorBehindNode: 4,
};
XMLCursorPositions[XMLCursorPositions.CursorInFrontOfNode] = 'CursorInFrontOfNode';
XMLCursorPositions[XMLCursorPositions.CursorOnCompleteNode] = 'CursorOnCompleteNode';
XMLCursorPositions[XMLCursorPositions.CursorInEmptyNode] = 'CursorInEmptyNode';
XMLCursorPositions[XMLCursorPositions.CursorInsideTextNode] = 'CursorInsideTextNode';
XMLCursorPositions[XMLCursorPositions.CursorBehindNode] = 'CursorBehindNode';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlCursorPosMover = /** @class */ (function () {
function XmlCursorPosMover() {
}
/**
* @param {?} pos
* @param {?} rootNode
* @param {?} xmlRules
* @return {?}
*/
XmlCursorPosMover.moveLeft = /**
* @param {?} pos
* @param {?} rootNode
* @param {?} xmlRules
* @return {?}
*/
function (pos, rootNode, xmlRules) {
if (pos === undefined) {
return false;
}
switch (pos.PosAtNode) {
case XMLCursorPositions.CursorOnCompleteNode:
// Put in front of the node
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode);
break;
case XMLCursorPositions.CursorInFrontOfNode:
if (pos.ActualNode === rootNode) {
return false;
}
else {
/** @type {?} */
var previousSibling = DomDummyNodeManager.getPreviousSibling(pos.ActualNode);
if (previousSibling) {
// Previous sibling node exists
pos.setCursorpBehindNodeForLeftMovement(previousSibling);
}
else {
// no previous sibling node available -> set before parent node
pos.SetCursor(pos.ActualNode.parentNode, XMLCursorPositions.CursorInFrontOfNode);
}
}
break;
case XMLCursorPositions.CursorBehindNode:
pos.setCursorpBehindNodeForLeftMovement(pos.ActualNode);
break;
case XMLCursorPositions.CursorInEmptyNode:
// Put in front of the node
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode);
break;
case XMLCursorPositions.CursorInsideTextNode:
if (XmlToolbox.IsTextOrCommentNode(pos.ActualNode)) {
// Node is Textnode
if (pos.PosInTextnode > 1) {
// Cursor one character to the left
pos.SetCursor(pos.ActualNode, pos.PosAtNode, pos.PosInTextnode - 1);
}
else {
// Put in front of the node
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode);
}
}
else {
/** @type {?} */
var elemt = /** @type {?} */ (pos.ActualNode);
throw new Error("XMLCursorPos.MoveLeft: CursorPos is XMLCursorPositionen.CursorInnerhalbDesTextNodes,\n but no text node has been chosen, but the node " + (elemt ? elemt.outerHTML : ''));
}
break;
default:
throw new Error("XMLCursorPos.MoveLeft: unknown CursorPos " + pos.PosAtNode);
}
return true;
};
/**
* @param {?} pos
* @param {?} rootNode
* @param {?} xmlRules
* @return {?}
*/
XmlCursorPosMover.moveRight = /**
* @param {?} pos
* @param {?} rootNode
* @param {?} xmlRules
* @return {?}
*/
function (pos, rootNode, xmlRules) {
if (pos === undefined) {
return false;
}
switch (pos.PosAtNode) {
case XMLCursorPositions.CursorOnCompleteNode:
/** @type {?} */
var tagName = Xml2html.getTagNameFromNode(pos.ActualNode);
/** @type {?} */
var rule = xmlRules.ruleElements.get(tagName);
if (rule && rule.empty === true) {
pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);
}
else {
/** @type {?} */
var firstChild = DomDummyNodeManager.getFirstChild(pos.ActualNode);
if (firstChild) {
pos.SetCursor(firstChild, XMLCursorPositions.CursorInFrontOfNode);
}
else {
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInEmptyNode);
}
}
break;
case XMLCursorPositions.CursorBehindNode:
/** @type {?} */
var nextSibling = DomDummyNodeManager.getNextSibling(pos.ActualNode);
if (nextSibling) {
/** @type {?} */
var elemt = /** @type {?} */ (pos.ActualNode);
throw new Error("XMLCursorPos.MoveRight: cursor behind node should only be set, when no other siblings are following " + (elemt ? elemt.outerHTML : ''));
}
else {
/** @type {?} */
var parentNextSibling = DomDummyNodeManager.getNextSibling(pos.ActualNode.parentElement);
if (parentNextSibling) {
pos.SetCursor(parentNextSibling, XMLCursorPositions.CursorInFrontOfNode);
}
else {
pos.SetCursor(pos.ActualNode.parentElement, XMLCursorPositions.CursorBehindNode);
}
}
break;
case XMLCursorPositions.CursorInEmptyNode:
// Place behind the node
pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);
break;
case XMLCursorPositions.CursorInFrontOfNode:
if (XmlToolbox.IsTextOrCommentNode(pos.ActualNode)) {
// Node is Textnode
if (( /** @type {?} */(pos.ActualNode)).textContent.length > 1) {
// Textnode is not empty
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, 1); // one character forward, behind the first character
}
else {
// Textnode is empty
// put behind the node
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorBehindNode);
// Because "CursorBehindNode" is not attractive, one more step
this.moveRight(pos, rootNode, xmlRules);
}
}
else {
/** @type {?} */
var childNodeCount = DomDummyNodeManager.getChildNodeCount(pos.ActualNode);
if (childNodeCount === 0) {
// no Children existing
if (Xml2html.isNoClosingElement(pos.ActualNode)) {
// If no closed tag is displayed for this node, then directly behind the node
// Place behind the node
pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);
}
else {
// Node has closing tag, so put in between
// Place in empty node
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInEmptyNode);
}
}
else {
/** @type {?} */
var firstChild = DomDummyNodeManager.getFirstChild(pos.ActualNode);
pos.SetCursor(firstChild, XMLCursorPositions.CursorInFrontOfNode);
}
}
break;
case XMLCursorPositions.CursorInsideTextNode:
if (XmlToolbox.IsTextOrCommentNode(pos.ActualNode)) {
// Node is Textnode
if (( /** @type {?} */(pos.ActualNode)).textContent.length > pos.PosInTextnode + 1) {
// there is still text in the right of the textnode
// step one character forwards: behind the first char
pos.SetCursor(pos.ActualNode, pos.PosAtNode, pos.PosInTextnode + 1);
}
else {
// no text after the textnode
// place cursor behind the node
pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);
}
}
else {
/** @type {?} */
var elemt = /** @type {?} */ (pos.ActualNode);
throw new Error("XMLCursorPos.MoveRight: CursorPos is XMLCursorPositionen.CursorInnerhalbDesTextNodes, \n but no text node has been chosen, but the node " + (elemt ? elemt.outerHTML : ''));
}
break;
default:
throw new Error("String.Format(\"XMLCursorPos.MoveRight: unknown CursorPos " + pos.PosAtNode);
}
return true;
};
return XmlCursorPosMover;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlCursor = /** @class */ (function () {
function XmlCursor() {
this.xmlDocumentRootNode = undefined;
this.domDummyNodeManager = new DomDummyNodeManager();
this.StartPos = new XmlCursorPos();
this.EndPos = new XmlCursorPos();
}
/**
* is there nothing between start and end pos?
*/
/**
* is there nothing between start and end pos?
* @return {?}
*/
XmlCursor.prototype.isEmptySelection = /**
* is there nothing between start and end pos?
* @return {?}
*/
function () {
if (this.StartPos.equals(this.EndPos)) {
return true;
}
return false;
};
/**
* @return {?}
*/
XmlCursor.prototype.sortStartAndEnd = /**
* @return {?}
*/
function () {
if (this.StartPos.ActualNode && this.EndPos.ActualNode) {
if (this.StartPos.ActualNode.isSameNode(this.EndPos.ActualNode)) {
if (this.StartPos.PosAtNode === XMLCursorPositions.CursorInsideTextNode &&
this.EndPos.PosAtNode === XMLCursorPositions.CursorInsideTextNode &&
this.StartPos.PosInTextnode > this.EndPos.PosInTextnode) {
this.swapStartAndEnd();
}
}
else {
/** @type {?} */
var compared = this.StartPos.ActualNode.compareDocumentPosition(this.EndPos.ActualNode);
// tslint:disable-next-line:no-bitwise
if (!(compared & Node.DOCUMENT_POSITION_FOLLOWING)) {
this.swapStartAndEnd();
}
}
}
};
/**
* @return {?}
*/
XmlCursor.prototype.swapStartAndEnd = /**
* @return {?}
*/
function () {
/** @type {?} */
var node = this.StartPos.ActualNode;
/** @type {?} */
var pos = this.StartPos.PosAtNode;
/** @type {?} */
var text = this.StartPos.PosInTextnode;
this.StartPos.SetCursor(this.EndPos.ActualNode, this.EndPos.PosAtNode, this.EndPos.PosInTextnode);
this.EndPos.SetCursor(node, pos, text);
};
/**
* @return {?}
*/
XmlCursor.prototype.show = /**
* @return {?}
*/
function () {
if (window.getSelection) {
/** @type {?} */
var selection = window.getSelection();
this.show2(selection);
}
else {
throw new Error('showCursor: unable to get "window.getSelection"');
}
};
/**
* @param {?} selection
* @return {?}
*/
XmlCursor.prototype.show2 = /**
* @param {?} selection
* @return {?}
*/
function (selection) {
if (!selection) {
return;
}
/** @type {?} */
var elems = document.querySelectorAll('.selected');
[].forEach.call(elems, function (el) {
el.classList.remove('selected');
});
/** @type {?} */
var startSelection = XmlCursorPos.getSelectionForPos(this.StartPos);
if (this.EndPos && this.EndPos.ActualNode && !this.EndPos.equals(this.StartPos)) {
/** @type {?} */
var endSelection = XmlCursorPos.getSelectionForPos(this.EndPos);
selection.setBaseAndExtent(startSelection.node, startSelection.offset, endSelection.node, endSelection.offset);
}
else {
// only start pos
selection.setPosition(startSelection.node, startSelection.offset);
// select tag by adding "select" class
if (this.StartPos.PosAtNode === XMLCursorPositions.CursorOnCompleteNode) {
/** @type {?} */
var asElem = /** @type {?} */ (this.StartPos.ActualNode);
if (asElem && asElem.classList) {
asElem.classList.add('selected');
console.log('selected!');
}
else {
console.error("no asElem.classList for select! " + XmlToolbox.GetNodeDebugContext(asElem));
}
}
}
};
return XmlCursor;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlCursorPosSetter = /** @class */ (function () {
function XmlCursorPosSetter() {
}
/**
* @param {?} pos
* @param {?} selectionAnchorNode
* @param {?} selectionAnchorOffset
* @param {?=} debugLog
* @return {?}
*/
XmlCursorPosSetter.setFromSelection = /**
* @param {?} pos
* @param {?} selectionAnchorNode
* @param {?} selectionAnchorOffset
* @param {?=} debugLog
* @return {?}
*/
function (pos, selectionAnchorNode, selectionAnchorOffset, debugLog) {
if (debugLog === void 0) {
debugLog = null;
}
if (selectionAnchorNode !== undefined && selectionAnchorNode !== null) {
/** @type {?} */
var node = /** @type {?} */ (selectionAnchorNode);
if (DomDummyNodeManager.IsDummyNode(selectionAnchorNode.parentElement)) {
// clicked inside a dummy node
node = /** @type {?} */ (selectionAnchorNode.parentElement);
if (DomDummyNodeManager.IsBeforeFirstTagDummyNode(node)) {
switch (selectionAnchorOffset) {
case 0:
if (debugLog) {
debugLog.setInputSelection("(1) cursor here: #<tag> pos 0");
}
pos.SetCursor(node.parentElement, XMLCursorPositions.CursorOnCompleteNode, 0);
return;
case 1:
if (debugLog) {
debugLog.setInputSelection("(2) cursor here: #<tag> pos 1");
}
pos.SetCursor(node.parentElement, XMLCursorPositions.CursorInFrontOfNode, 0);
return;
default:
throw new Error("selectionAnchorOffset=" + selectionAnchorOffset + "?!?");
}
}
if (node.parentElement.childNodes.length === 2) {
if (debugLog) {
debugLog.setInputSelection("(13, 14) cursor here: <tag>#</tag>");
}
pos.SetCursor(node.parentElement, XMLCursorPositions.CursorInEmptyNode, 0);
return;
}
if (node === node.parentElement.lastChild && selectionAnchorOffset === 1) {
if (debugLog) {
debugLog.setInputSelection("(8, 12) cursor here: #</tag>, selecting complete node");
}
pos.SetCursor(node.parentElement, XMLCursorPositions.CursorOnCompleteNode, 0);
return;
}
/** @type {?} */
var nextSibling = node.nextSibling;
if (nextSibling) {
if (debugLog) {
debugLog.setInputSelection("(3, 4, 9, 10) cursor here: #Text or here #<tag>");
}
pos.SetCursor(nextSibling, XMLCursorPositions.CursorInFrontOfNode, 0);
return;
}
/** @type {?} */
var previousSibling = node.previousSibling;
if (previousSibling) {
if (debugLog) {
debugLog.setInputSelection("(7, 11) cursor here: Text# or here <tag>#");
}
pos.SetCursor(previousSibling, XMLCursorPositions.CursorBehindNode, 0);
return;
}
}
else {
// is no dummy node
if (selectionAnchorNode.nodeType === Node.TEXT_NODE) {
if (selectionAnchorOffset === 0) {
if (debugLog) {
debugLog.setInputSelection("(6) cursor here: #Text");
}
pos.SetCursor(selectionAnchorNode, XMLCursorPositions.CursorInsideTextNode, 0);
return;
}
if (selectionAnchorOffset === selectionAnchorNode.textContent.length) {
if (debugLog) {
debugLog.setInputSelection("(7 Alternative) cursor here: Text#");
}
pos.SetCursor(selectionAnchorNode, XMLCursorPositions.CursorInsideTextNode, selectionAnchorNode.textContent.length);
return;
}
if (debugLog) {
debugLog.setInputSelection("(5) cursor here: Text#Text");
}
if (selectionAnchorOffset > selectionAnchorNode.textContent.length) {
throw new Error("selectionAnchorOffset " + selectionAnchorOffset + " is > than text-lenght " + selectionAnchorNode.textContent.length + " of text '" + selectionAnchorNode.textContent + "' ");
}
pos.SetCursor(selectionAnchorNode, XMLCursorPositions.CursorInsideTextNode, selectionAnchorOffset);
return;
}
}
// if (DomDummyNodeManager.IsDummyNode(parentElem)) {
// const dummyElement = parentElem;
// const nextSibling = parentElem.nextSibling;
// if (XmlToolbox.IstTextOderKommentarNode(nextSibling)) {
// // cursor here: #text (# = red dummyNode)
// pos.CursorSetzen(nextSibling, XMLCursorPositionen.CursorInnerhalbDesTextNodes, 0);
// return;
// }
// const previousSibling = dummyElement.previousSibling;
// if (!previousSibling) {
// // pos.CursorSetzen(dummyElement.parentElement, XMLCursorPositionen.c, 0);
// }
// }
// switch (node.nodeType) {
// case Node.TEXT_NODE:
// if (loopCount === 0) {
// const nextSibling = parentElem.nextSibling;
// if (nextSibling && nextSibling.nodeType === Node.TEXT_NODE && selectionAnchorOffset === 1) {
// // set cursor at start of following textnode
// pos.CursorSetzen(nextSibling, XMLCursorPositionen.CursorInnerhalbDesTextNodes, 0);
// } else {
// const previousSibling = parentElem.previousSibling;
// if (previousSibling && previousSibling.nodeType === Node.TEXT_NODE && selectionAnchorOffset === 0) {
// // set cursor at end of previous textnode
// pos.CursorSetzen(previousSibling, XMLCursorPositionen.CursorInnerhalbDesTextNodes, previousSibling.nodeValue.length);
// }
// }
// } else {
// node = parentElem; // up to dummy node
// }
// } else {
// pos.CursorSetzen(node, XMLCursorPositionen.CursorInnerhalbDesTextNodes, selectionAnchorOffset);
// }
// break;
// case Node.ELEMENT_NODE:
// if (DomDummyNodeManager.IsDummyNode(node)) {
// // node = parentElem; // up to parent node
// } else {
// pos.CursorSetzen(node, XMLCursorPositionen.CursorAufNodeSelbstVorderesTag);
// }
// break;
// default:
// throw new Error(`unhandled nodeType '${node.nodeType}' of node ${XmlToolbox.GetNodeDebugContext(node)}`);
// }
}
console.error("found no suiting cursor interpretation! For selectionAnchorNode=" + XmlToolbox.GetNodeDebugContext(selectionAnchorNode) + ", selectionAnchorOffset=" + selectionAnchorOffset);
};
return XmlCursorPosSetter;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlDomCleaner = /** @class */ (function () {
function XmlDomCleaner() {
}
/**
* @param {?} node
* @param {?} actualCursor
* @return {?}
*/
XmlDomCleaner.cleanUp = /**
* @param {?} node
* @param {?} actualCursor
* @return {?}
*/
function (node, actualCursor) {
this.concatTextNodes(node, actualCursor);
};
/**
*
* if two textnodes are direct siblings: concat to one textnode
* @param {?} node
* @param {?} actualCursor
* @param {?=} nodeDepth
* @return {?}
*/
XmlDomCleaner.concatTextNodes = /**
*
* if two textnodes are direct siblings: concat to one textnode
* @param {?} node
* @param {?} actualCursor
* @param {?=} nodeDepth
* @return {?}
*/
function (node, actualCursor, nodeDepth) {
if (nodeDepth === void 0) {
nodeDepth = 0;
}
/** @type {?} */
var restart = true;
while (restart === true) {
restart = false;
for (var i = 0; i < node.childNodes.length; ++i) {
/** @type {?} */
var firstToCheck = node.childNodes[i];
if (DomDummyNodeManager.IsDummyNode(firstToCheck)) {
throw new Error('Dummynodes have to be removed before using XmlDomCleaner!');
}
if (firstToCheck.nodeType === Node.TEXT_NODE) {
/** @type {?} */
var secondToCheck = firstToCheck.nextSibling;
if (secondToCheck !== null && secondToCheck.nodeType === Node.TEXT_NODE) {
// two text nodes after each other => concat
if (actualCursor.StartPos.ActualNode === secondToCheck) {
actualCursor.StartPos.SetCursor(firstToCheck, XMLCursorPositions.CursorInsideTextNode, firstToCheck.textContent.length + actualCursor.StartPos.PosInTextnode);
}
if (actualCursor.EndPos.ActualNode === secondToCheck) {
actualCursor.EndPos.SetCursor(firstToCheck, XMLCursorPositions.CursorInsideTextNode, firstToCheck.textContent.length + actualCursor.EndPos.PosInTextnode);
}
firstToCheck.textContent = firstToCheck.textContent + secondToCheck.textContent;
node.removeChild(secondToCheck);
restart = true;
}
}
}
}
// update child nodes
for (var i = 0; i < node.childNodes.length; ++i) {
this.concatTextNodes(node.childNodes[i], actualCursor, nodeDepth + 1);
}
};
return XmlDomCleaner;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlEditDelete = /** @class */ (function () {
function XmlEditDelete() {
}
/**
* @param {?} cursor
* @param {?} rootNode
* @param {?} xmlRules
* @return {?}
*/
XmlEditDelete.deleteSelection = /**
* @param {?} cursor
* @param {?} rootNode
* @param {?} xmlRules
* @return {?}
*/
function (cursor, rootNode, xmlRules) {
return true;
};
/**
* @param {?} pos
* @param {?} rootNode
* @param {?} xmlRules
* @return {?}
*/
XmlEditDelete.deleteAfter = /**
* @param {?} pos
* @param {?} rootNode
* @param {?} xmlRules
* @return {?}
*/
function (pos, rootNode, xmlRules) {
if (pos === undefined) {
return false;
}
switch (pos.PosAtNode) {
case XMLCursorPositions.CursorOnCompleteNode:
return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);
case XMLCursorPositions.CursorBehindNode:
case XMLCursorPositions.CursorInFrontOfNode:
XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);
return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);
case XMLCursorPositions.CursorInEmptyNode:
return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);
case XMLCursorPositions.CursorInsideTextNode:
XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);
return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);
default:
throw new Error("String.Format(\"XmlCursorEdit.deleteBefore: unknown CursorPos " + pos.PosAtNode);
}
return true;
};
/**
* @param {?} pos
* @param {?} rootNode
* @param {?} xmlRules
* @return {?}
*/
XmlEditDelete.deleteBefore = /**
* @param {?} pos
* @param {?} rootNode
* @param {?} xmlRules
* @return {?}
*/
function (pos, rootNode, xmlRules) {
/** @type {?} */
var deleteNode;
// console.log(pos.getDebugDescription());
if (pos === undefined) {
return false;
}
switch (pos.PosAtNode) {
case XMLCursorPositions.CursorOnCompleteNode:
deleteNode = pos.ActualNode;
XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);
deleteNode.parentElement.removeChild(deleteNode);
break;
case XMLCursorPositions.CursorBehindNode:
if (pos.ActualNode.nodeType === Node.TEXT_NODE) {
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, pos.ActualNode.textContent.length);
return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);
}
else {
pos.ActualNode.parentElement.removeChild(pos.ActualNode);
}
break;
case XMLCursorPositions.CursorInEmptyNode:
deleteNode = pos.ActualNode;
XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);
deleteNode.parentElement.removeChild(deleteNode);
break;
case XMLCursorPositions.CursorInFrontOfNode:
deleteNode = DomDummyNodeManager.getPreviousSibling(pos.ActualNode);
if (!deleteNode) {
deleteNode = pos.ActualNode.parentElement;
}
if (deleteNode) {
if (deleteNode.nodeType === Node.TEXT_NODE) {
pos.SetCursor(deleteNode, XMLCursorPositions.CursorInsideTextNode, deleteNode.textContent.length);
return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);
}
else {
deleteNode.parentElement.removeChild(deleteNode);
}
}
break;
case XMLCursorPositions.CursorInsideTextNode:
if (pos.PosInTextnode === 0) {
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode, 0);
return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);
}
else {
/** @type {?} */
var text = pos.ActualNode.textContent;
text = text.substring(0, pos.PosInTextnode - 1) + text.substr(pos.PosInTextnode, pos.ActualNode.textContent.length);
pos.ActualNode.textContent = text;
XmlCursorPosMover.moveLeft(pos, rootNode, xmlRules);
// pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, pos.PosInTextnode - 1);
}
break;
default:
throw new Error("String.Format(\"XmlEdit.deleteBefore: unknown CursorPos " + pos.PosAtNode);
}
return true;
};
return XmlEditDelete;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlEditRuleCheckTextInsert = /** @class */ (function () {
function XmlEditRuleCheckTextInsert(xsdNodes) {
this.xsdNodes = xsdNodes;
this.namespacePraefix = 'xs:';
}
/**
* @param {?} cursorPosToCheck
* @return {?}
*/
XmlEditRuleCheckTextInsert.prototype.isTextAllowedAtThisCursorPos = /**
* @param {?} cursorPosToCheck
* @return {?}
*/
function (cursorPosToCheck) {
if (!cursorPosToCheck) {
return false;
}
/** @type {?} */
var parentNode = this.getRelevantParentNodeForCursorPos(cursorPosToCheck);
/** @type {?} */
var parentName = Xml2html.getTagNameFromNode(parentNode);
/** @type {?} */
var xsdNode = this.xsdNodes.get(parentName);
if (xsdNode) {
/** @type {?} */
var result = this.isTextAllowedInThisElement(xsdNode);
return result;
}
else {
return false; // element not found
}
};
/**
* @param {?} cursorPosToCheck
* @return {?}
*/
XmlEditRuleCheckTextInsert.prototype.getRelevantParentNodeForCursorPos = /**
* @param {?} cursorPosToCheck
* @return {?}
*/
function (cursorPosToCheck) {
if (cursorPosToCheck) {
/** @type {?} */
var parentNode = cursorPosToCheck.ActualNode;
switch (parentNode.nodeType) {
case Node.COMMENT_NODE:
case Node.TEXT_NODE:
parentNode = parentNode.parentElement;
break;
case Node.ELEMENT_NODE:
switch (cursorPosToCheck.PosAtNode) {
case XMLCursorPositions.CursorInEmptyNode:
case XMLCursorPositions.CursorInsideTextNode:
break;
case XMLCursorPositions.CursorBehindNode:
case XMLCursorPositions.CursorInFrontOfNode:
case XMLCursorPositions.CursorOnCompleteNode:
parentNode = parentNode.parentElement;
break;
default:
throw new Error("unhandled cursorPosToCheck.PosAmNode \"" + cursorPosToCheck.PosAtNode + "\"/" + XmlCursorPos.getXmlCursorPositionDebugName(cursorPosToCheck.PosAtNode) + "\" ");
}
break;
default:
throw new Error("unhandled parentNode.nodeType \"" + parentNode.nodeType + "\"");
}
return parentNode;
}
};
/**
* @param {?} xsdNode
* @param {?=} alreadyAddedElementNames
* @return {?}
*/
XmlEditRuleCheckTextInsert.prototype.isTextAllowedInThisElement = /**
* @param {?} xsdNode
* @param {?=} alreadyAddedElementNames
* @return {?}
*/
function (xsdNode, alreadyAddedElementNames) {
var _this = this;
if (alreadyAddedElementNames === void 0) {
alreadyAddedElementNames = new Set();
}
/** @type {?} */
var elementName;
if (xsdNode.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
var asElem = /** @type {?} */ (xsdNode);
if (asElem) {
/** @type {?} */
var mixedAttrib = asElem.getAttribute('mixed');
if (mixedAttrib) {
return true;
}
/** @type {?} */
var typeAttrib = asElem.getAttribute('type');
if (typeAttrib && typeAttrib === this.namespacePraefix + "string") {
return true;
}
if (asElem.localName === 'element') {
elementName = asElem.getAttribute('name');
if (elementName) {
if (alreadyAddedElementNames.has(elementName)) {
return false; // element recursion detected
}
}
alreadyAddedElementNames.add(elementName);
}
}
}
/** @type {?} */
var childNodes = /** @type {?} */ (Array.prototype.slice.call(xsdNode.childNodes));
/** @type {?} */
var allowed = false;
childNodes.forEach(function (child) {
if (child.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
var childElem = /** @type {?} */ (child);
if (childElem) {
switch (childElem.localName) {
case 'complexType':
case 'sequence':
case 'choice':
case 'simpleContent':
case 'extension':
if (_this.isTextAllowedInThisElement(child, alreadyAddedElementNames) === true) {
allowed = true;
break;
}
break;
case 'element':
/** @type {?} */
var refname = childElem.attributes.getNamedItem('ref');
if (refname) {
/** @type {?} */
var referedNode = _this.xsdNodes.get(refname.value);
if (referedNode) {
if (_this.isTextAllowedInThisElement(referedNode, alreadyAddedElementNames) === true) {
allowed = true;
break;
}
}
else {
throw new Error(" refered element \"" + refname + "\" for element \"" + childElem.outerHTML + "\" not found");
}
}
break;
case 'attribute':
break;
default:
alert('unknown childElem.localname "' + childElem.localName + '"/' + childElem.outerHTML);
}
}
}
});
return allowed;
};
return XmlEditRuleCheckTextInsert;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlEditInsert = /** @class */ (function () {
function XmlEditInsert() {
}
/**
* @param {?} pos
* @param {?} value
* @param {?} rootNode
* @param {?} xmlRules
* @param {?} xmlSchema
* @return {?}
*/
XmlEditInsert.replaceWithText = /**
* @param {?} pos
* @param {?} value
* @param {?} rootNode
* @param {?} xmlRules
* @param {?} xmlSchema
* @return {?}
*/
function (pos, value, rootNode, xmlRules, xmlSchema) {
if (pos === undefined) {
return false;
}
if (value === '' || value === undefined || value == null) {
return false;
}
if (pos.isEmptySelection() === false) {
if (XmlEditDelete.deleteSelection(pos, rootNode, xmlRules) === false) {
return false;
}
}
return XmlEditInsert.insertText(pos.EndPos, value, rootNode, xmlRules, xmlSchema);
};
/**
* @param {?} pos
* @param {?} value
* @param {?} rootNode
* @param {?} xmlRules
* @param {?} xmlSchema
* @return {?}
*/
XmlEditInsert.insertText = /**
* @param {?} pos
* @param {?} value
* @param {?} rootNode
* @param {?} xmlRules
* @param {?} xmlSchema
* @return {?}
*/
function (pos, value, rootNode, xmlRules, xmlSchema) {
if (pos === undefined) {
return false;
}
if (value === '' || value === undefined || value == null) {
return false;
}
switch (pos.PosAtNode) {
case XMLCursorPositions.CursorOnCompleteNode:
/** @type {?} */
var textAllowed = XmlEditInsert.isTextAllowedInParentNode(pos, xmlSchema);
if (textAllowed === true) {
/** @type {?} */
var newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);
pos.ActualNode.parentElement.insertBefore(newTextNode, pos.ActualNode);
pos.ActualNode.parentElement.removeChild(pos.ActualNode);
/** @type {?} */
var nextSibling = DomDummyNodeManager.getNextSibling(newTextNode);
if (nextSibling) {
pos.SetCursor(nextSibling, XMLCursorPositions.CursorInFrontOfNode);
}
else {
pos.SetCursor(newTextNode, XMLCursorPositions.CursorBehindNode);
}
return true;
}
else {
return false;
}
case XMLCursorPositions.CursorBehindNode:
if (pos.ActualNode.nodeType === Node.TEXT_NODE) {
pos.ActualNode.textContent = pos.ActualNode.textContent + value;
return true;
}
else {
textAllowed = XmlEditInsert.isTextAllowedInParentNode(pos, xmlSchema);
if (textAllowed === true) {
/** @type {?} */
var newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);
pos.ActualNode.parentElement.insertBefore(newTextNode, pos.ActualNode.nextSibling); // inserts the new node after the actual node
return true;
}
else {
return false;
}
}
case XMLCursorPositions.CursorInFrontOfNode:
if (pos.ActualNode.nodeType === Node.TEXT_NODE) {
pos.ActualNode.textContent = value + pos.ActualNode.textContent;
return true;
}
else {
textAllowed = XmlEditInsert.isTextAllowedInParentNode(pos, xmlSchema);
if (textAllowed === true) {
/** @type {?} */
var newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);
pos.ActualNode.parentElement.insertBefore(newTextNode, pos.ActualNode);
return true;
}
else {
return false;
}
}
case XMLCursorPositions.CursorInEmptyNode:
textAllowed = new XmlEditRuleCheckTextInsert(xmlSchema.xsdNodes).isTextAllowedAtThisCursorPos(pos);
if (textAllowed === true) {
/** @type {?} */
var newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);
pos.ActualNode.appendChild(newTextNode);
return true;
}
else {
return false;
}
case XMLCursorPositions.CursorInsideTextNode:
/** @type {?} */
var text = pos.ActualNode.textContent;
pos.ActualNode.textContent = text.substr(0, pos.PosInTextnode) + value + text.substr(pos.PosInTextnode, text.length);
pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, pos.PosInTextnode + 1);
break;
default:
throw new Error("String.Format(\"XmlEditInsert.insert: unknown CursorPos " + pos.getDebugDescription());
}
return true;
};
/**
* @param {?} pos
* @param {?} xmlSchema
* @return {?}
*/
XmlEditInsert.isTextAllowedInParentNode = /**
* @param {?} pos
* @param {?} xmlSchema
* @return {?}
*/
function (pos, xmlSchema) {
/** @type {?} */
var parentNode = pos.ActualNode.parentElement;
/** @type {?} */
var parentCursorPos = pos.clone();
parentCursorPos.SetCursor(parentNode, XMLCursorPositions.CursorInEmptyNode);
return new XmlEditRuleCheckTextInsert(xmlSchema.xsdNodes).isTextAllowedAtThisCursorPos(parentCursorPos);
};
return XmlEditInsert;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlEditorContext = /** @class */ (function () {
function XmlEditorContext(_document) {
this._document = _document;
this.actualCursor = new XmlCursor();
this.dummyNodeManager = new DomDummyNodeManager();
this.actualCursorChanged = new rxjs.Subject();
this.debugService = new XmlEditorDebugger();
}
/**
* @return {?}
*/
XmlEditorContext.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this.actualCursorChanged.unsubscribe();
};
/**
* @param {?} cursorPos
* @return {?}
*/
XmlEditorContext.prototype.setCursorPos = /**
* @param {?} cursorPos
* @return {?}
*/
function (cursorPos) {
this.actualCursor = cursorPos;
this.actualCursorChanged.next(cursorPos);
this.debugService.setActualCursorPos(cursorPos);
};
// /**
// * Executed command from editor header buttons
// * @param command string from triggerCommand
// */
// executeCommand(command: string) {
// if (command !== '') {
// this.commander.executeCommand(command);
// this.exec();
// }
// this.onEditorFocus();
// const cleanUpFirst = false;
// this.domDummyNodeManager.UpdateDummyNodes(this.xmlDocumentRootNode, cleanUpFirst);
// return;
// }
/**
* @param {?} mouseEvent
* @return {?}
*/
XmlEditorContext.prototype.mouseUp = /**
* @param {?} mouseEvent
* @return {?}
*/
function (mouseEvent) {
if (window.getSelection) {
/** @type {?} */
var userSelection = void 0;
userSelection = window.getSelection();
XmlCursorPosSetter.setFromSelection(this.actualCursor.StartPos, userSelection.anchorNode, userSelection.anchorOffset, this.debugService);
XmlCursorPosSetter.setFromSelection(this.actualCursor.EndPos, userSelection.focusNode, userSelection.focusOffset, this.debugService);
this.setCursorPos(this.actualCursor);
this.actualCursor.sortStartAndEnd();
this.actualCursor.show();
}
else {
throw new Error("can't get window.getSelection, target=" + JSON.stringify(mouseEvent.target));
}
};
/**
* @param {?} event
* @return {?}
*/
XmlEditorContext.prototype.keyDown = /**
* @param {?} event
* @return {?}
*/
function (event) {
console.log('keydown! key:' + event.key + ' / code:' + event.code);
switch (event.key) {
case 'Control':
this.keyCtrlIsDown = true;
break;
case 'Shift':
this.keyShiftIsDown = true;
break;
case 'c':
if (this.keyCtrlIsDown) {
// Copy
return false;
}
else {
if (this.insertText('c')) {
return false;
}
}
break;
case 'ArrowUp':
case 'ArrowDown':
return true;
case 'ArrowRight':
if (this.keyShiftIsDown) {
XmlCursorPosMover.moveRight(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);
}
else {
XmlCursorPosMover.moveRight(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);
this.actualCursor.StartPos.SetCursor(this.actualCursor.EndPos.ActualNode, this.actualCursor.EndPos.PosAtNode, this.actualCursor.EndPos.PosInTextnode);
}
this.actualCursor.sortStartAndEnd();
this.actualCursor.show();
this.setCursorPos(this.actualCursor);
return false;
case 'ArrowLeft':
if (this.keyShiftIsDown) {
XmlCursorPosMover.moveLeft(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);
}
else {
XmlCursorPosMover.moveLeft(this.actualCursor.StartPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);
this.actualCursor.EndPos.SetCursor(this.actualCursor.StartPos.ActualNode, this.actualCursor.StartPos.PosAtNode, this.actualCursor.StartPos.PosInTextnode);
}
this.actualCursor.sortStartAndEnd();
this.actualCursor.show();
this.setCursorPos(this.actualCursor);
return false;
case 'Backspace':
if (this.actualCursor.isEmptySelection()) {
XmlEditDelete.deleteBefore(this.actualCursor.StartPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);
}
else {
XmlEditDelete.deleteSelection(this.actualCursor, this.actualCursor.xmlDocumentRootNode, this.config.rules);
}
this.actualCursor.EndPos.SetCursor(this.actualCursor.StartPos.ActualNode, this.actualCursor.StartPos.PosAtNode, this.actualCursor.StartPos.PosInTextnode);
this.cleanUpAndUpdateDummyElements();
this.actualCursor.show();
return false;
case 'Delete':
if (this.actualCursor.isEmptySelection()) {
XmlEditDelete.deleteAfter(this.actualCursor.StartPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);
}
else {
XmlEditDelete.deleteSelection(this.actualCursor, this.actualCursor.xmlDocumentRootNode, this.config.rules);
}
this.cleanUpAndUpdateDummyElements();
this.actualCursor.show();
return false;
case 'Enter':
return false;
default:
/** @type {?} */
var textInsert = event.key;
if (this.insertText(textInsert)) {
return false;
}
break;
}
return true;
};
/**
* @param {?} event
* @return {?}
*/
XmlEditorContext.prototype.keyUp = /**
* @param {?} event
* @return {?}
*/
function (event) {
switch (event.key) {
case 'Control':
this.keyCtrlIsDown = false;
break;
case 'Shift':
this.actualCursor.sortStartAndEnd();
this.keyShiftIsDown = false;
break;
case 'ArrowLeft':
case 'ArrowRight':
this.actualCursor.show();
break;
case 'ArrowUp':
case 'ArrowDown':
case 'Backspace':
case 'Delete':
case 'Enter':
case 'Control':
case 'Shift':
break;
}
return true;
};
/**
* @param {?} text
* @return {?}
*/
XmlEditorContext.prototype.pasted = /**
* @param {?} text
* @return {?}
*/
function (text) {
alert('pasted: ' + text);
return false;
};
/**
* @return {?}
*/
XmlEditorContext.prototype.copied = /**
* @return {?}
*/
function () {
alert('copied');
return false;
};
/**
* @param {?} value
* @return {?}
*/
XmlEditorContext.prototype.insertText = /**
* @param {?} value
* @return {?}
*/
function (value) {
if (value === '' || value === null || value === undefined) {
return true;
}
/** @type {?} */
var inserted = false;
if (this.actualCursor.isEmptySelection()) {
inserted = XmlEditInsert.insertText(this.actualCursor.EndPos, value, this.actualCursor.xmlDocumentRootNode, this.config.rules, this.config.xmlSchema);
}
else {
inserted = XmlEditInsert.replaceWithText(this.actualCursor, value, this.actualCursor.xmlDocumentRootNode, this.config.rules, this.config.xmlSchema);
}
if (inserted) {
// character inserted -> move cursor right
// for (let index = 0; index < value.length; index++) {
// XmlCursorPosMover.moveRight(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);
// }
this.actualCursor.StartPos.SetCursor(this.actualCursor.EndPos.ActualNode, this.actualCursor.EndPos.PosAtNode, this.actualCursor.EndPos.PosInTextnode);
this.cleanUpAndUpdateDummyElements();
this.actualCursor.show();
console.warn('text inserted!');
return true;
}
else {
console.warn('text NOT inserted!');
return false;
}
};
/** inserts a new element at the actual cursor pos */
/**
* inserts a new element at the actual cursor pos
* @param {?} element
* @return {?}
*/
XmlEditorContext.prototype.insertElement = /**
* inserts a new element at the actual cursor pos
* @param {?} element
* @return {?}
*/
function (element) {
/** @type {?} */
var html = new Xml2html(this.config.rules).createNewElementHtml(element);
this.domInsertHtml(html);
this.cleanUpAndUpdateDummyElements();
// this.actualCursor.show();
console.warn('element inserted!');
};
/**
* Create raw HTML
* @param {?} html HTML string
* @return {?}
*/
XmlEditorContext.prototype.domInsertHtml = /**
* Create raw HTML
* @param {?} html HTML string
* @return {?}
*/
function (html) {
if (document.getSelection) {
/** @type {?} */
var range = document.getSelection().getRangeAt(0);
range.insertNode(range.createContextualFragment(html));
}
else {
throw new Error('document.getSelection not defined!');
}
this.cleanUpAndUpdateDummyElements();
this.actualCursor.show();
};
/**
* save selection when the editor is focussed out
*/
/**
* save selection when the editor is focussed out
* @return {?}
*/
XmlEditorContext.prototype.saveSelection = /**
* save selection when the editor is focussed out
* @return {?}
*/
function () {
if (window.getSelection) {
/** @type {?} */
var sel = window.getSelection();
if (sel.getRangeAt && sel.rangeCount) {
this.savedSelection = sel.getRangeAt(0);
this.selectedText = sel.toString();
}
}
else if (this._document.getSelection && this._document.createRange) {
this.savedSelection = document.createRange();
}
else {
this.savedSelection = null;
}
};
/**
* restore selection when the editor is focussed in
*/
/**
* restore selection when the editor is focussed in
* @return {?}
*/
XmlEditorContext.prototype.restoreSelection = /**
* restore selection when the editor is focussed in
* @return {?}
*/
function () {
if (this.savedSelection) {
if (window.getSelection) {
/** @type {?} */
var sel = window.getSelection();
sel.removeAllRanges();
sel.addRange(this.savedSelection);
return true;
}
else if (this._document.getSelection /*&& this.savedSelection.select*/) {
// this.savedSelection.select();
return true;
}
}
else {
return false;
}
};
/**
* @return {?}
*/
XmlEditorContext.prototype.cleanUpAndUpdateDummyElements = /**
* @return {?}
*/
function () {
this.dummyNodeManager.RemoveAllDummyNodes(this.actualCursor.xmlDocumentRootNode);
XmlDomCleaner.cleanUp(this.actualCursor.xmlDocumentRootNode, this.actualCursor);
this.dummyNodeManager.UpdateDummyNodes(this.actualCursor.xmlDocumentRootNode);
this.actualCursor.sortStartAndEnd();
};
return XmlEditorContext;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* \@dynamic
*/
var AngularXmlEditorService = /** @class */ (function () {
function AngularXmlEditorService(_document) {
this._document = _document;
this.contexts = new Map();
}
/**
* @return {?}
*/
AngularXmlEditorService.prototype.getNewEditorContextId = /**
* @return {?}
*/
function () {
/** @type {?} */
var no = 0;
while (this.contexts.has(no.toString())) {
no++;
}
return no.toString();
};
/**
* @param {?} contextId
* @return {?}
*/
AngularXmlEditorService.prototype.getEditorContext = /**
* @param {?} contextId
* @return {?}
*/
function (contextId) {
/** @type {?} */
var context = this.contexts.get(contextId);
if (context === undefined) {
context = new XmlEditorContext(this._document);
this.contexts.set(contextId, context);
}
return context;
};
/**
* @param {?} contextId
* @return {?}
*/
AngularXmlEditorService.prototype.disposeEditorContext = /**
* @param {?} contextId
* @return {?}
*/
function (contextId) {
this.contexts.delete(contextId);
};
AngularXmlEditorService.decorators = [
{ type: i0.Injectable, args: [{
providedIn: 'root'
},] }
];
/** @nocollapse */
AngularXmlEditorService.ctorParameters = function () {
return [
{ type: Document, decorators: [{ type: i0.Inject, args: [i1.DOCUMENT,] }] }
];
};
/** @nocollapse */ AngularXmlEditorService.ngInjectableDef = i0.defineInjectable({ factory: function AngularXmlEditorService_Factory() { return new AngularXmlEditorService(i0.inject(i1.DOCUMENT)); }, token: AngularXmlEditorService, providedIn: "root" });
return AngularXmlEditorService;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var Html2xml = /** @class */ (function () {
function Html2xml(rules) {
this.rules = rules;
this.attributeWorker = new Xml2htmlAttributeWorker(rules);
}
/**
* @param {?} html
* @return {?}
*/
Html2xml.prototype.ToXml = /**
* @param {?} html
* @return {?}
*/
function (html) {
if (html === '') {
return '';
}
/** @type {?} */
var cleanHtml = this.CleanUpHtmlBeforeConvert2Xml(html);
/** @type {?} */
var domparser = new DOMParser();
/** @type {?} */
var domdoc = domparser.parseFromString(cleanHtml, 'text/xml');
/** @type {?} */
var targetDocument = new Document();
if (domdoc.documentElement === null) {
return '';
}
/** @type {?} */
var body = this.GetXmlElementFromHtmlElement(domdoc.documentElement, targetDocument);
if (body && body.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
var xml = ( /** @type {?} */(body)).outerHTML;
return xml;
}
else {
throw new Error("root node " + XmlToolbox.GetNodeDebugContext(body) + " is no element");
}
};
/**
* @param {?} html
* @return {?}
*/
Html2xml.prototype.CleanUpHtmlBeforeConvert2Xml = /**
* @param {?} html
* @return {?}
*/
function (html) {
/** @type {?} */
var domparser = new DOMParser();
/** @type {?} */
var domdoc = domparser.parseFromString(html, 'text/html');
new DomDummyNodeManager().RemoveAllDummyNodes(domdoc.documentElement);
/** @type {?} */
var cleanHtml = domdoc.body.innerHTML;
return cleanHtml;
};
/**
* @param {?} node
* @param {?} targetDocument
* @return {?}
*/
Html2xml.prototype.GetXmlElementFromHtmlElement = /**
* @param {?} node
* @param {?} targetDocument
* @return {?}
*/
function (node, targetDocument) {
switch (node.nodeType) {
case Node.ELEMENT_NODE: // element node
/** @type {?} */
var asElement = /** @type {?} */ (node);
/** @type {?} */
var tagName = Xml2html.getTagNameFromNode(node);
if (!tagName || tagName === '') {
throw new Error("no tagname in " + XmlToolbox.GetNodeDebugContext(node));
}
/** @type {?} */
var newElement = targetDocument.createElement(tagName);
/** @type {?} */
var children = asElement.childNodes;
if (children.length === 0 && !asElement.classList.contains(Xml2html.NoClosingTagClassName)) {
newElement.appendChild(targetDocument.createTextNode('')); // to prevent non closing tags
}
else {
for (var i = 0; i < children.length; ++i) {
/** @type {?} */
var childAsHtml = this.GetXmlElementFromHtmlElement(children[i], targetDocument);
if (childAsHtml !== undefined) {
newElement.appendChild(childAsHtml);
}
}
}
// // insert attributes
this.attributeWorker.writeAllHtmlAttributesToXml(asElement, newElement);
return newElement;
case Node.TEXT_NODE: // text node
/** @type {?} */
var content = ( /** @type {?} */(node)).textContent;
if (content.length > 0) {
return targetDocument.createTextNode(content);
}
else {
return undefined;
}
default:
// tslint:disable-next-line:max-line-length
throw new Error("unknown html element nodeType " + node.nodeType + " in value: " + XmlToolbox.GetNodeDebugContext(node));
}
};
return Html2xml;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var AngularXmlEditorComponent = /** @class */ (function () {
function AngularXmlEditorComponent(_renderer, editorService) {
this._renderer = _renderer;
this.editorService = editorService;
this.isDebugMode = false;
this.valueChange = new i0.EventEmitter();
// actualXmlCursor: XmlCursor = new XmlCursor();
this.domDummyNodeManager = new DomDummyNodeManager();
}
Object.defineProperty(AngularXmlEditorComponent.prototype, "config", {
get: /**
* @return {?}
*/ function () {
if (this.editorContext !== undefined && this.editorContext.config !== undefined) {
return this.editorContext && this.editorContext.config;
}
return undefined;
},
enumerable: true,
configurable: true
});
Object.defineProperty(AngularXmlEditorComponent.prototype, "editorContextId", {
set: /**
* @param {?} value
* @return {?}
*/ function (value) {
if (!value) {
return;
}
this.editorContext = this.editorService.getEditorContext(value);
},
enumerable: true,
configurable: true
});
Object.defineProperty(AngularXmlEditorComponent.prototype, "debugMode", {
set: /**
* @param {?} value
* @return {?}
*/ function (value) {
this.isDebugMode = value;
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
AngularXmlEditorComponent.prototype.ngOnChanges = /**
* @return {?}
*/
function () { };
/**
* @return {?}
*/
AngularXmlEditorComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () { };
/**
* @return {?}
*/
AngularXmlEditorComponent.prototype.onLostFocus = /**
* @return {?}
*/
function () {
this.editorContext.saveSelection(); // save selection on lost focus
if (typeof this.onTouchedFunction === 'function') {
this.onTouchedFunction();
}
return;
};
/**
* @return {?}
*/
AngularXmlEditorComponent.prototype.onGotFocus = /**
* @return {?}
*/
function () {
this.editorContext.restoreSelection();
this.textArea.nativeElement.focus(); // set focus to the text area
};
/**
* @return {?}
*/
AngularXmlEditorComponent.prototype.clicked = /**
* @return {?}
*/
function () { };
/**
* @return {?}
*/
AngularXmlEditorComponent.prototype.mousedown = /**
* @return {?}
*/
function () { };
/**
* @param {?} mouseEvent
* @return {?}
*/
AngularXmlEditorComponent.prototype.mouseup = /**
* @param {?} mouseEvent
* @return {?}
*/
function (mouseEvent) {
return this.editorContext.mouseUp(mouseEvent);
};
/**
* @param {?} text
* @return {?}
*/
AngularXmlEditorComponent.prototype.pasted = /**
* @param {?} text
* @return {?}
*/
function (text) {
return this.editorContext.pasted(text);
};
/**
* @return {?}
*/
AngularXmlEditorComponent.prototype.copied = /**
* @return {?}
*/
function () {
return this.editorContext.copied();
};
/**
* @param {?} event
* @return {?}
*/
AngularXmlEditorComponent.prototype.keyDown = /**
* @param {?} event
* @return {?}
*/
function (event) {
return this.editorContext.keyDown(event);
};
/**
* @param {?} event
* @return {?}
*/
AngularXmlEditorComponent.prototype.keyUp = /**
* @param {?} event
* @return {?}
*/
function (event) {
return this.editorContext.keyUp(event);
};
// exec(): boolean {
// let userSelection: Selection;
// if (window.getSelection) {
// userSelection = window.getSelection();
// this.editorBreadCrumb.showSelection(userSelection);
// this.actualXmlCursor.StartPos.SetCursor(userSelection.anchorNode, XMLCursorPositionen.CursorInsideTextNode, userSelection.anchorOffset);
// this.commander.setCursorPos(this.actualXmlCursor.StartPos);
// }
// this.domDummyNodeManager.UpdateDummyNodes(this.actualXmlCursor.xmlDocumentRootNode, false);
// return false;
// }
/**
* @param {?} xml
* @return {?}
*/
AngularXmlEditorComponent.prototype.showXml = /**
* @param {?} xml
* @return {?}
*/
function (xml) {
if (this.textArea && this.editorContext && this.editorContext.config && this.editorContext.config.rules) {
if (xml === undefined) {
return;
}
/** @type {?} */
var xml2html = new Xml2html(this.editorContext.config.rules);
/** @type {?} */
var html = xml2html.ToHtml(xml);
/** @type {?} */
var normalizedValue = xml === null ? '' : html;
this._renderer.setProperty(this.textArea.nativeElement, 'innerHTML', normalizedValue);
}
};
/* START OF ControlValueAccessor (see https://angular.io/api/forms/ControlValueAccessor ) */
/**
* Sets the function called when the control gets a change event
*/
/**
* Sets the function called when the control gets a change event
* @param {?} func
* @return {?}
*/
AngularXmlEditorComponent.prototype.registerOnChange = /**
* Sets the function called when the control gets a change event
* @param {?} func
* @return {?}
*/
function (func) {
this.onChangeFunction = func;
};
/**
* Sets the function called when the control gets a touch event
*/
/**
* Sets the function called when the control gets a touch event
* @param {?} func
* @return {?}
*/
AngularXmlEditorComponent.prototype.registerOnTouched = /**
* Sets the function called when the control gets a touch event
* @param {?} func
* @return {?}
*/
function (func) {
this.onTouchedFunction = func;
};
/**
* Write the new value to the element
*/
/**
* Write the new value to the element
* @param {?} value
* @return {?}
*/
AngularXmlEditorComponent.prototype.writeValue = /**
* Write the new value to the element
* @param {?} value
* @return {?}
*/
function (value) {
if (this.editorContext && this.editorContext.config) {
if (value === null || value === undefined || value === '') {
value = undefined;
}
this.showXml(value);
if (value === undefined) {
this.editorContext.actualCursor.xmlDocumentRootNode = undefined;
}
else {
/** @type {?} */
var el = /** @type {?} */ (this.textArea.nativeElement);
/** @type {?} */
var node = /** @type {?} */ (el.firstChild);
this.editorContext.actualCursor.xmlDocumentRootNode = node;
this.editorContext.actualCursor.StartPos.SetCursor(this.editorContext.actualCursor.xmlDocumentRootNode, XMLCursorPositions.CursorOnCompleteNode);
this.domDummyNodeManager.UpdateDummyNodes(this.editorContext.actualCursor.xmlDocumentRootNode);
}
}
};
/**
* Executed from the contenteditable section while the input property changes
* @param html html string from contenteditable
*/
/**
* Executed from the contenteditable section while the input property changes
* @param {?} html html string from contenteditable
* @return {?}
*/
AngularXmlEditorComponent.prototype.onContentChange = /**
* Executed from the contenteditable section while the input property changes
* @param {?} html html string from contenteditable
* @return {?}
*/
function (html) {
if (typeof this.onChangeFunction === 'function') {
/** @type {?} */
var html2xml = new Html2xml(this.editorContext.config.rules);
/** @type {?} */
var xml = html2xml.ToXml(html);
/** @type {?} */
var normalizedValue = xml === null ? '' : xml;
this.onChangeFunction(normalizedValue);
}
return;
};
/**
* sets the disabled state for this element
*/
/**
* sets the disabled state for this element
* @param {?} isDisabled
* @return {?}
*/
AngularXmlEditorComponent.prototype.setDisabledState = /**
* sets the disabled state for this element
* @param {?} isDisabled
* @return {?}
*/
function (isDisabled) {
/** @type {?} */
var div = this.textArea.nativeElement;
/** @type {?} */
var action = isDisabled ? 'addClass' : 'removeClass';
this._renderer[action](div, 'disabled');
};
AngularXmlEditorComponent.decorators = [
{ type: i0.Component, args: [{
selector: 'axed-editor',
template: "<div\r\n *ngIf=\"config\"\r\n #editor\r\n class=\"axed axed-textarea showtags debugOff\"\r\n (focus)=\"onGotFocus()\"\r\n [attr.contenteditable]=\"true\"\r\n [style.height]=\"config.height\"\r\n [style.width]=\"config.width\"\r\n (input)=\"onContentChange($event.target.innerHTML)\"\r\n (blur)=\"onLostFocus()\"\r\n (click)=\"clicked()\"\r\n (mousedown)=\"mousedown()\"\r\n (mouseup)=\"mouseup($event)\"\r\n (keyup)=\"keyUp($event)\"\r\n (keydown)=\"keyDown($event)\"\r\n (copy)=\"copied()\"\r\n (paste)=\"pasted($event.clipboardData.getData('text/plain'))\"\r\n></div>\r\n",
encapsulation: i0.ViewEncapsulation.None,
// to prevent the scss to rename the class names and not match the new generated xml dom
providers: [
{
provide: forms.NG_VALUE_ACCESSOR,
useExisting: i0.forwardRef(function () { return AngularXmlEditorComponent; }),
multi: true
}
],
styles: ["a{cursor:pointer}.axed-textarea{min-height:150px;overflow:auto;margin-top:5px;resize:vertical;outline:0;--font-size:15px;--topBottomTagPadding:2px;--tagIndent:20px;font-size:var(--font-size);font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Oxygen,Ubuntu,Cantarell,'Open Sans','Helvetica Neue',sans-serif}.axed-textarea.showtags{line-height:calc(var(--font-size) + (var(--topBottomTagPadding) * 2) + 10px)}.axed-textarea.showtags div::after,.axed-textarea.showtags div::before{background:orange;white-space:pre-wrap;border:1px solid #778899}.axed-textarea.showtags div::after,.axed-textarea.showtags div:not(.xmlTagNoClosing)::before{content:\" \" attr(data-tagname) \" \";padding:var(--topBottomTagPadding) 0 var(--topBottomTagPadding);margin:0 2px 2px}.axed-textarea.showtags div:not(.xmlTagNoClosing)::after{content:\" \" attr(data-tagname);padding-right:7px;border-radius:10px 0 0 10px}.axed-textarea.showtags div:not(.xmlTagNoClosing)::before{border-radius:0 10px 10px 0}.axed-textarea.showtags div[data-attributes].xmlTagNoClosing:not([data-attributes=''])::after,.axed-textarea.showtags div[data-attributes]:not([data-attributes='']):not(.xmlTagNoClosing)::before{content:\" \" attr(data-tagname) \" \" attr(data-attributes) \" \"}.axed-textarea.showtags div.comment::after,.axed-textarea.showtags div.comment::before{content:' ' 'comment' ' ';background-color:#d3d3d3}.axed-textarea div div:not(.floating){margin-left:var(--tagIndent)}.tagElement>.dummyNode.parent{color:red}div.floating{display:inline}span.dummyNode.beforefirstTag{float:left;width:0}.axed-textarea.debug span.dummyNode{background-color:red;width:inherit}.axed-textarea.debug span.dummyNode.beforefirstTag{background-color:violet;width:inherit}.axed-textarea.showtags div.selected,.axed-textarea.showtags div.selected::after,.axed-textarea.showtags div.selected::before{background:#add8e6!important;color:#fff}[data-tagname=parsererror],[data-tagname=parsererror] div,[data-tagname=parsererror] div ::after,[data-tagname=parsererror] div::before,[data-tagname=parsererror]::after,[data-tagname=parsererror]::before{background:red!important;color:#fff!important;font-weight:700!important;font-size:20px!important;line-height:32px!important}.angular-editor{position:relative}.angular-editor ::ng-deep [contenteditable=true]:empty:before{content:attr(placeholder);display:block;color:#868e96;opacity:1}.angular-editor .axed-wrapper{position:relative}.angular-editor .axed-wrapper .axed-textarea{min-height:5rem;padding:.5rem .8rem 1rem;border:1px solid #ddd;background-color:transparent;overflow-x:hidden;overflow-y:auto;z-index:2;position:relative}.angular-editor .axed-wrapper .axed-textarea.focus,.angular-editor .axed-wrapper .axed-textarea:focus{outline:0}.angular-editor .axed-wrapper .axed-textarea ::ng-deep blockquote{margin-left:1rem;border-left:.2em solid #dfe2e5;padding-left:.5rem}.angular-editor .axed-wrapper ::ng-deep p{margin-bottom:0}.angular-editor .axed-wrapper .axed-placeholder{display:none;position:absolute;top:0;padding:.5rem .8rem 1rem .9rem;z-index:1;color:#6c757d;opacity:.75}.angular-editor .axed-wrapper.show-placeholder .angular-editor-placeholder{display:block}.angular-editor .axed-wrapper.disabled{cursor:not-allowed;opacity:.5;pointer-events:none}.axed-attribute-editor-toolbar{min-height:100px;font:100 .8rem/15px Roboto,Arial,sans-serif;background-color:#f5f5f5;padding:15px;border:1px solid #ddd;margin:0}.axed-attribute-editor-toolbar input,.axed-attribute-editor-toolbar select{width:100%}"]
}] }
];
/** @nocollapse */
AngularXmlEditorComponent.ctorParameters = function () {
return [
{ type: i0.Renderer2 },
{ type: AngularXmlEditorService }
];
};
AngularXmlEditorComponent.propDecorators = {
config: [{ type: i0.Input, args: ['config',] }],
editorContextId: [{ type: i0.Input, args: ['editorContextId',] }],
debugMode: [{ type: i0.Input, args: ['debugMode',] }],
textArea: [{ type: i0.ViewChild, args: ['editor',] }],
editorWrapper: [{ type: i0.ViewChild, args: ['editorWrapper',] }],
valueChange: [{ type: i0.Output }]
};
return AngularXmlEditorComponent;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlRuleElement = /** @class */ (function () {
function XmlRuleElement(init) {
Object.assign(this, init);
}
/**
* @param {?} elements
* @return {?}
*/
XmlRuleElement.Sorted = /**
* @param {?} elements
* @return {?}
*/
function (elements) {
/** @type {?} */
var result = elements.sort(function (e1, e2) {
if (e1.tagName > e2.tagName) {
return 1;
}
if (e1.tagName < e2.tagName) {
return -1;
}
return 0;
});
return result;
};
return XmlRuleElement;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlEditRuleCheckElements = /** @class */ (function () {
function XmlEditRuleCheckElements(xsdNodes) {
this.xsdNodes = xsdNodes;
}
/**
* @param {?} cursorPosToCheck
* @return {?}
*/
XmlEditRuleCheckElements.prototype.ElementsAllowedAtThisCursorPos = /**
* @param {?} cursorPosToCheck
* @return {?}
*/
function (cursorPosToCheck) {
if (!cursorPosToCheck) {
return [];
}
/** @type {?} */
var parentNode = this.getRelevantParentNodeForCursorPos(cursorPosToCheck);
/** @type {?} */
var parentName = Xml2html.getTagNameFromNode(parentNode);
/** @type {?} */
var xsdNode = this.xsdNodes.get(parentName);
if (xsdNode) {
/** @type {?} */
var result = this.getSubElementNames(xsdNode, []);
return result;
}
else {
// console.warn('element "' + parentName + '" not found');
return [];
}
};
/**
* @param {?} cursorPosToCheck
* @return {?}
*/
XmlEditRuleCheckElements.prototype.getRelevantParentNodeForCursorPos = /**
* @param {?} cursorPosToCheck
* @return {?}
*/
function (cursorPosToCheck) {
if (cursorPosToCheck) {
/** @type {?} */
var parentNode = cursorPosToCheck.ActualNode;
switch (parentNode.nodeType) {
case Node.COMMENT_NODE:
case Node.TEXT_NODE:
parentNode = parentNode.parentElement;
break;
case Node.ELEMENT_NODE:
switch (cursorPosToCheck.PosAtNode) {
case XMLCursorPositions.CursorInEmptyNode:
case XMLCursorPositions.CursorInsideTextNode:
break;
case XMLCursorPositions.CursorBehindNode:
case XMLCursorPositions.CursorInFrontOfNode:
case XMLCursorPositions.CursorOnCompleteNode:
parentNode = parentNode.parentElement;
break;
default:
throw new Error("unhandled cursorPosToCheck.PosAmNode \"" + cursorPosToCheck.PosAtNode + "\"/" + XmlCursorPos.getXmlCursorPositionDebugName(cursorPosToCheck.PosAtNode) + "\" ");
}
break;
default:
throw new Error("unhandled parentNode.nodeType \"" + parentNode.nodeType + "\"");
}
return parentNode;
}
};
/**
* @param {?} xsdNode
* @param {?} alreadyAddedElementNames
* @param {?=} depth
* @return {?}
*/
XmlEditRuleCheckElements.prototype.getSubElementNames = /**
* @param {?} xsdNode
* @param {?} alreadyAddedElementNames
* @param {?=} depth
* @return {?}
*/
function (xsdNode, alreadyAddedElementNames, depth) {
var _this = this;
if (depth === void 0) {
depth = 0;
}
/** @type {?} */
var elementNames = [];
/** @type {?} */
var elementName;
if (xsdNode.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
var asElem = /** @type {?} */ (xsdNode);
if (asElem) {
if (asElem.localName === 'element') {
elementName = asElem.getAttribute('name');
}
}
}
if (elementName) {
// console.warn('found: ' + JSON.stringify(elementName) + ' depth: ' + depth);
if (alreadyAddedElementNames.length !== 0) {
if (alreadyAddedElementNames.indexOf(elementName) !== -1) {
return elementNames; // element recursion detected
}
if (depth === 0) ;
else {
elementNames = elementNames.concat(elementName);
return elementNames;
}
}
alreadyAddedElementNames.push(elementName);
}
/** @type {?} */
var childNodes = /** @type {?} */ (Array.prototype.slice.call(xsdNode.childNodes));
depth++;
childNodes.forEach(function (child) {
if (child.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
var childElem = /** @type {?} */ (child);
if (childElem) {
switch (childElem.localName) {
case 'complexType':
case 'sequence':
case 'choice':
case 'simpleContent':
case 'extension':
elementNames = elementNames.concat(_this.getSubElementNames(child, alreadyAddedElementNames, depth));
break;
case 'element':
/** @type {?} */
var refname = childElem.attributes.getNamedItem('ref');
if (refname) {
/** @type {?} */
var referedNode = _this.xsdNodes.get(refname.value);
if (referedNode) {
elementNames = elementNames.concat(_this.getSubElementNames(referedNode, alreadyAddedElementNames, depth));
}
else {
throw new Error(" refered element \"" + refname + "\" for element \"" + childElem.outerHTML + "\" not found");
}
}
else {
elementNames = elementNames.concat(_this.getSubElementNames(child, alreadyAddedElementNames, depth));
}
break;
case 'attribute':
break;
default:
throw new Error("unknown childElem.localname \"" + childElem.localName + "\"/" + childElem.outerHTML);
}
}
}
});
return elementNames;
};
return XmlEditRuleCheckElements;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlEditorToolbarComponent = /** @class */ (function () {
function XmlEditorToolbarComponent(editorService) {
this.editorService = editorService;
this.elementGroups = [];
}
Object.defineProperty(XmlEditorToolbarComponent.prototype, "config", {
get: /**
* @return {?}
*/ function () {
if (this.editorContext !== undefined && this.editorContext.config !== undefined) {
return this.editorContext && this.editorContext.config;
}
return undefined;
},
enumerable: true,
configurable: true
});
Object.defineProperty(XmlEditorToolbarComponent.prototype, "editorContextId", {
set: /**
* @param {?} value
* @return {?}
*/ function (value) {
var _this = this;
if (!value) {
return;
}
this.editorContext = this.editorService.getEditorContext(value);
this.actualCursorPosChangedSubscription = this.editorContext.actualCursorChanged.subscribe(function (pos) {
_this.elementGroups = _this.GetElementGroupsForCursorPos(pos.StartPos);
});
},
enumerable: true,
configurable: true
});
/** inserts an element at the actual cursor pos */
/**
* inserts an element at the actual cursor pos
* @param {?} element
* @return {?}
*/
XmlEditorToolbarComponent.prototype.insertElement = /**
* inserts an element at the actual cursor pos
* @param {?} element
* @return {?}
*/
function (element) {
/** @type {?} */
var html = new Xml2html(this.editorContext.config.rules).createNewElementHtml(element);
this.editorContext.domInsertHtml(html);
};
/**
* @return {?}
*/
XmlEditorToolbarComponent.prototype.ngAfterViewInit = /**
* @return {?}
*/
function () { };
/**
* @return {?}
*/
XmlEditorToolbarComponent.prototype.ngOnChanges = /**
* @return {?}
*/
function () { };
/**
* @return {?}
*/
XmlEditorToolbarComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this.actualCursorPosChangedSubscription.unsubscribe();
};
/**
* @param {?} pos
* @return {?}
*/
XmlEditorToolbarComponent.prototype.GetElementGroupsForCursorPos = /**
* @param {?} pos
* @return {?}
*/
function (pos) {
/** @type {?} */
var allowedElements = new XmlEditRuleCheckElements(this.editorContext.config.xmlSchema.xsdNodes).ElementsAllowedAtThisCursorPos(pos);
return this.GetAllElementGroups()
.map(function (g) {
return /** @type {?} */ ({
title: g.title,
elements: g.elements.filter(function (e) { return allowedElements.includes(e.tagName); })
});
})
.filter(function (g) { return g.elements.length > 0; });
};
/**
* @return {?}
*/
XmlEditorToolbarComponent.prototype.GetAllElementGroups = /**
* @return {?}
*/
function () {
var _this = this;
/** @type {?} */
var unusedElements = XmlRuleElement.Sorted(Array.from(this.editorContext.config.rules.ruleElements.values()).filter(function (elem) {
return _this.editorContext.config.elementGroups.some(function (group) { return !group.elementNames.includes(elem.tagName); });
}));
/** @type {?} */
var otherElementsGroup = /** @type {?} */ ({
title: 'other',
elements: unusedElements
});
return this.editorContext.config.elementGroups
.map(function (g) {
return /** @type {?} */ ({
title: g.title,
elements: XmlRuleElement.Sorted(g.elementNames.map(function (elementName) { return _this.editorContext.config.rules.ruleElements.get(elementName); }).filter(function (e) { return e !== undefined; }))
});
})
.concat(otherElementsGroup)
.filter(function (g) { return g.elements.length !== 0; });
};
XmlEditorToolbarComponent.decorators = [
{ type: i0.Component, args: [{
selector: 'axed-toolbar',
template: "<div class=\"sws-xml-editor-toolbar\">\r\n <h3>Insert element</h3>\r\n\r\n <!--\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button type=\"button\" title=\"Undo\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('undo')\"><i class='fa fa-undo'></i></button>\r\n <button type=\"button\" title=\"Redo\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('redo')\"><i class='fa fa-repeat'></i></button>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button [id]=\"'bold-'+id\" type=\"button\" title=\"Bold\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('bold')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-bold'></i></button>\r\n <button [id]=\"'italic-'+id\" type=\"button\" title=\"Italic\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('italic')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-italic'></i></button>\r\n <button [id]=\"'underline-'+id\" type=\"button\" title=\"Underline\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('underline')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-underline'></i></button>\r\n <button [id]=\"'strikeThrough-'+id\" type=\"button\" title=\"Strikethrough\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('strikeThrough')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-strikethrough'></i></button>\r\n <button [id]=\"'subscript-'+id\" type=\"button\" title=\"Subscript\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('subscript')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-subscript'></i></button>\r\n <button [id]=\"'superscript-'+id\" type=\"button\" title=\"Superscript\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('superscript')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-superscript'></i></button>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button [id]=\"'justifyLeft-'+id\" type=\"button\" title=\"Justify Left\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('justifyLeft')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-align-left'></i></button>\r\n <button [id]=\"'justifyCenter-'+id\" type=\"button\" title=\"Justify Center\" class=\"angular-editor-button\" (click)=\"triggerCommand('justifyCenter')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-align-center'></i></button>\r\n <button [id]=\"'justifyRight-'+id\" type=\"button\" title=\"Justify Right\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('justifyRight')\"\r\n [disabled]=\"htmlMode\">\r\n <i class='fa fa-align-right'></i></button>\r\n <button [id]=\"'justifyFull-'+id\" type=\"button\" title=\"Justify Full\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('justifyFull')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-align-justify'></i></button>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button [id]=\"'indent-'+id\" type=\"button\" title=\"Indent\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('indent')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-indent'></i></button>\r\n <button [id]=\"'outdent-'+id\" type=\"button\" title=\"Outdent\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('outdent')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-outdent'></i></button>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button [id]=\"'insertUnorderedList-'+id\" type=\"button\" title=\"Unordered List\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('insertUnorderedList')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-list-ul'></i></button>\r\n <button [id]=\"'insertOrderedList-'+id\" type=\"button\" title=\"Ordered List\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('insertOrderedList')\"\r\n [disabled]=\"htmlMode\"><i class='fa fa-list-ol'></i></button>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <label [for]=\"'heading-'+id\" class=\"block-label\"></label>\r\n <select title=\"Formatting\" [id]=\"'heading-'+id\" class=\"select-heading\" [(ngModel)]=\"block\" (change)=\"triggerCommand(block)\"\r\n [disabled]=\"htmlMode\">\r\n <optgroup label=\"Formatting\"></optgroup>\r\n <option class=\"h1\" value=\"h1\">Heading 1</option>\r\n <option class=\"h2\" value=\"h2\">Heading 2</option>\r\n <option class=\"h3\" value=\"h3\">Heading 3</option>\r\n <option class=\"h4\" value=\"h4\">Heading 4</option>\r\n <option class=\"h5\" value=\"h5\">Heading 5</option>\r\n <option class=\"h6\" value=\"h6\">Heading 6</option>\r\n <option class=\"p\" value=\"p\">Paragraph</option>\r\n <option class=\"pre\" value=\"pre\">Predefined</option>\r\n <option class=\"div\" value=\"div\">Standard</option>\r\n <option class=\"default\" value=\"default\">Default</option>\r\n </select>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <label [for]=\"'fontSelector-'+id\" class=\"block-label\"></label>\r\n <select title=\"Font Name\" [id]=\"'fontSelector-'+id\" class=\"select-font\" [(ngModel)]=\"fontName\" (change)=\"setFontName(fontName)\"\r\n [disabled]=\"htmlMode\">\r\n <optgroup label=\"Font Name\"></optgroup>\r\n <option class=\"arial\" value=\"Arial\">Arial</option>\r\n <option class=\"calibri\" value=\"Calibri\">Calibri</option>\r\n <option class=\"comic-sans-ms\" value=\"Comic Sans MS\">Comic Sans MS</option>\r\n <option class=\"times-new-roman\" value=\"Times New Roman\">Times New Roman</option>\r\n </select>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <label [for]=\"'fontSizeSelector-'+id\" class=\"block-label\"></label>\r\n <select title=\"Font Size\" [id]=\"'fontSizeSelector-'+id\" class=\"select-font-size\" [(ngModel)]=\"fontSize\" (change)=\"setFontSize(fontSize)\"\r\n [disabled]=\"htmlMode\">\r\n <optgroup label=\"Font Sizing\"></optgroup>\r\n <option class=\"size1\" value=\"1\">1</option>\r\n <option class=\"size2\" value=\"2\">2</option>\r\n <option class=\"size3\" value=\"3\">3</option>\r\n <option class=\"size4\" value=\"4\">4</option>\r\n <option class=\"size5\" value=\"5\">5</option>\r\n <option class=\"size6\" value=\"6\">6</option>\r\n <option class=\"size7\" value=\"7\">7</option>\r\n </select>\r\n </div>\r\n <div class=\"angular-editor-toolbar-set\">\r\n <input style=\"display: none\" type=\"color\" (change)=\"insertColor(fgInput.value, 'textColor')\" #fgInput>\r\n <button [id]=\"'foregroundColorPicker-'+id\" type=\"button\" class=\"sws-xml-editor-button\" (click)=\"fgInput.click()\"\r\n title=\"Text Color\" [disabled]=\"htmlMode\"><span class=\"color-label foreground\"><i class=\"fa fa-font\"></i></span></button>\r\n <input style=\"display: none\" type=\"color\" (change)=\"insertColor(bgInput.value, 'backgroundColor')\" #bgInput>\r\n <button [id]=\"'backgroundColorPicker-'+id\" type=\"button\" class=\"sws-xml-editor-button\" (click)=\"bgInput.click()\"\r\n title=\"Background Color\" [disabled]=\"htmlMode\"><span class=\"color-label background\"><i class=\"fa fa-font\"></i></span></button>\r\n </div>\r\n <div *ngIf=\"customClasses\" class=\"sws-xml-editor-toolbar-set\">\r\n <label [for]=\"'customClassSelector-'+id\" class=\"block-label\"></label>\r\n <select title=\"Custom Style\" [id]=\"'customClassSelector-'+id\" class=\"select-custom-style\" [(ngModel)]=\"customClassId\"\r\n (change)=\"setCustomClass(customClassId)\" [disabled]=\"htmlMode\">\r\n <optgroup label=\"Custom Class\"></optgroup>\r\n <option class=\"\" value=-1>Clear Class</option>\r\n <option *ngFor=\"let item of customClasses; let i = index\" [class]=\"item.class\" [value]=\"i\">{{item.name}}</option>\r\n </select>\r\n </div>\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button [id]=\"'link-'+id\" type=\"button\" class=\"sws-xml-editor-button\" (click)=\"insertUrl()\" title=\"Insert Link\"\r\n [disabled]=\"htmlMode\">\r\n <i class=\"fa fa-link\"></i>\r\n </button>\r\n <button type=\"button\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('unlink')\" title=\"Unlink\" [disabled]=\"htmlMode\">\r\n <i class=\"fa fa-chain-broken\"></i>\r\n </button>\r\n <input style=\"display: none\" type=\"file\" (change)=\"onFileChanged($event)\" #fileInput>\r\n <button type=\"button\" class=\"sws-xml-editor-button\" (click)=\"fileInput.click()\" title=\"Insert Image\" [disabled]=\"htmlMode\"><i\r\n class=\"fa fa-image\"></i></button>\r\n\r\n <button type=\"button\" title=\"Horizontal Line\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('insertElement_STAR')\"\r\n [disabled]=\"htmlMode\"><i class=\"fa fa-minus\"></i> STAR</button>\r\n </div>\r\n -->\r\n\r\n\r\n\r\n <div class=\"sws-xml-editor-toolbar-set\" *ngFor=\"let group of elementGroups\">\r\n <label class=\"sws-editor-toolbar-grouplabel\" *ngIf=\"group.title\">{{ group.title }}:</label>\r\n <button *ngFor=\"let elem of group.elements\" type=\"button\" title=\"{{elem.title}}\" class=\"sws-xml-editor-button\"\r\n (click)=\"insertElement(elem)\">\r\n <span *ngIf=\"elem.iconClass\"><i class=\"{{elem.iconClass}}\"></i> </span>{{ elem.tagName }}\r\n </button>\r\n </div>\r\n\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button type=\"button\" title=\"remove tag\" class=\"sws-xml-editor-button\"><i class=\"fa fa-remove\"></i> remove</button>\r\n </div>\r\n\r\n <!--\r\n <div class=\"sws-xml-editor-toolbar-set\">\r\n <button [id]=\"'toggleEditorMode-'+id\" type=\"button\" title=\"HTML Code\" class=\"sws-xml-editor-button\" (click)=\"triggerCommand('toggleEditorMode')\"><i\r\n class='fa fa-code'></i></button>\r\n </div>\r\n -->\r\n</div>\r\n",
styles: [".sws-xml-editor-toolbar{display:inline-block}.sws-xml-editor-toolbar .sws-xml-editor-toolbar-set{border-radius:5px;background-color:#fff;margin-right:5px;margin-bottom:5px;border:1px solid #ddd;clear:both;float:left;display:block;position:relative}.sws-xml-editor-toolbar .sws-xml-editor-toolbar-set .sws-editor-toolbar-grouplabel{display:block;font-weight:700;background-color:transparent;float:left;padding:.5em .5em 0}.sws-xml-editor-toolbar .sws-xml-editor-toolbar-set .sws-xml-editor-button{border-radius:5px;background-color:transparent;margin:2px;padding:.6em;min-width:3em;float:left;border:.5px solid #eee}.sws-xml-editor-toolbar .sws-xml-editor-toolbar-set .sws-xml-editor-button:hover{cursor:pointer;background-color:#ff8c00;transition:.2s}"]
}] }
];
/** @nocollapse */
XmlEditorToolbarComponent.ctorParameters = function () {
return [
{ type: AngularXmlEditorService }
];
};
XmlEditorToolbarComponent.propDecorators = {
config: [{ type: i0.Input, args: ['config',] }],
editorContextId: [{ type: i0.Input, args: ['editorContextId',] }]
};
return XmlEditorToolbarComponent;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlRuleAttribut = /** @class */ (function () {
function XmlRuleAttribut(init) {
Object.assign(this, init);
this.typ = this.getTyp();
}
/**
* @return {?}
*/
XmlRuleAttribut.prototype.getTyp = /**
* @return {?}
*/
function () {
if (this.fixedValues && this.fixedValues.length > 0) {
return RuleAttributeTypes.Enum;
}
return RuleAttributeTypes.String;
};
return XmlRuleAttribut;
}());
/** @enum {number} */
var RuleAttributeTypes = {
String: 0,
Enum: 1,
Number: 2,
};
RuleAttributeTypes[RuleAttributeTypes.String] = 'String';
RuleAttributeTypes[RuleAttributeTypes.Enum] = 'Enum';
RuleAttributeTypes[RuleAttributeTypes.Number] = 'Number';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlEditRuleCheckAttributes = /** @class */ (function () {
function XmlEditRuleCheckAttributes(xmlSchema) {
this.xmlSchema = xmlSchema;
}
/**
* @param {?} cursorPosToCheck
* @return {?}
*/
XmlEditRuleCheckAttributes.prototype.AttributesAllowedAtThisCursorPos = /**
* @param {?} cursorPosToCheck
* @return {?}
*/
function (cursorPosToCheck) {
if (!cursorPosToCheck) {
return [];
}
/** @type {?} */
var parentNode = this.getRelevantParentNodeForCursorPos(cursorPosToCheck);
/** @type {?} */
var parentName = Xml2html.getTagNameFromNode(parentNode);
return this.getAttributesForElementName(parentName);
};
/**
* @param {?} cursorPosToCheck
* @return {?}
*/
XmlEditRuleCheckAttributes.prototype.getRelevantParentNodeForCursorPos = /**
* @param {?} cursorPosToCheck
* @return {?}
*/
function (cursorPosToCheck) {
if (cursorPosToCheck) {
/** @type {?} */
var parentNode = cursorPosToCheck.ActualNode;
switch (parentNode.nodeType) {
case Node.COMMENT_NODE:
case Node.TEXT_NODE:
parentNode = parentNode.parentElement;
break;
case Node.ELEMENT_NODE:
switch (cursorPosToCheck.PosAtNode) {
case XMLCursorPositions.CursorInEmptyNode:
case XMLCursorPositions.CursorInsideTextNode:
case XMLCursorPositions.CursorOnCompleteNode:
break;
case XMLCursorPositions.CursorBehindNode:
case XMLCursorPositions.CursorInFrontOfNode:
parentNode = parentNode.parentElement;
break;
default:
throw new Error("unhandled cursorPosToCheck.PosAmNode \"" + cursorPosToCheck.PosAtNode + "\"/" + XmlCursorPos.getXmlCursorPositionDebugName(cursorPosToCheck.PosAtNode) + "\" ");
}
break;
default:
throw new Error("unhandled parentNode.nodeType \"" + parentNode.nodeType + "\"");
}
return parentNode;
}
};
/**
* @param {?} elementName
* @return {?}
*/
XmlEditRuleCheckAttributes.prototype.getAttributesForElementName = /**
* @param {?} elementName
* @return {?}
*/
function (elementName) {
/** @type {?} */
var xsdNode = this.xmlSchema.findXsdNodeForTagName(elementName);
return this.getAttributesForElement(xsdNode, new Set([xsdNode]));
};
/**
* @param {?} xsdNode
* @param {?} alreadyAddedElements
* @return {?}
*/
XmlEditRuleCheckAttributes.prototype.getAttributesForElement = /**
* @param {?} xsdNode
* @param {?} alreadyAddedElements
* @return {?}
*/
function (xsdNode, alreadyAddedElements) {
var _this = this;
/** @type {?} */
var attributes = [];
if (xsdNode) {
alreadyAddedElements.add(xsdNode);
/** @type {?} */
var childNodes = Array.prototype.slice.call(xsdNode.childNodes);
childNodes.forEach(function (child) {
if (xsdNode.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
var childElem = /** @type {?} */ (child);
if (childElem) {
if (child.localName === 'attribute') {
// is attribute
attributes = attributes.concat([
new XmlRuleAttribut({
attribName: childElem.attributes.getNamedItem('name').value,
required: _this.isRequiredAttribute(childElem),
xsdRawNode: childElem,
fixedValues: _this.getFixedValues(childElem),
defaultValue: _this.getDefaultValue(childElem)
})
]);
}
else {
// no attribute
if (!alreadyAddedElements.has(child)) {
/** @type {?} */
var subNodeAttributes = _this.getAttributesForElement(child, alreadyAddedElements);
attributes = attributes.concat(subNodeAttributes);
}
}
}
}
});
}
return attributes;
};
/**
* the default value for this attribute
* @param {?} childElem
* @return {?}
*/
XmlEditRuleCheckAttributes.prototype.getDefaultValue = /**
* the default value for this attribute
* @param {?} childElem
* @return {?}
*/
function (childElem) {
/** @type {?} */
var attrib = childElem.attributes.getNamedItem('default');
if (attrib !== null) {
return attrib.value;
}
return undefined;
};
/**
* is this attribute required?
* @param {?} childElem
* @return {?}
*/
XmlEditRuleCheckAttributes.prototype.isRequiredAttribute = /**
* is this attribute required?
* @param {?} childElem
* @return {?}
*/
function (childElem) {
/** @type {?} */
var attrib = childElem.attributes.getNamedItem('use');
/** @type {?} */
var value = attrib !== null && attrib.value === 'required';
return value;
};
/**
* get the allowes values for this attribute
* @param {?} xsdNode
* @param {?=} alreadyChecked
* @return {?}
*/
XmlEditRuleCheckAttributes.prototype.getFixedValues = /**
* get the allowes values for this attribute
* @param {?} xsdNode
* @param {?=} alreadyChecked
* @return {?}
*/
function (xsdNode, alreadyChecked) {
var _this = this;
if (alreadyChecked === void 0) {
alreadyChecked = [];
}
/** @type {?} */
var values = [];
/** @type {?} */
var childNodes = Array.prototype.slice.call(xsdNode.childNodes);
childNodes.forEach(function (child) {
if (xsdNode.nodeType === Node.ELEMENT_NODE) {
/** @type {?} */
var childElem = /** @type {?} */ (child);
if (childElem) {
if (child.localName === 'enumeration') {
values = values.concat([childElem.attributes.getNamedItem('value').value]);
}
else {
// no attribute
if (alreadyChecked.indexOf(child) === -1) {
/** @type {?} */
var subNodeAttributes = _this.getFixedValues(child, alreadyChecked);
values = values.concat(subNodeAttributes);
}
}
}
}
});
return values;
};
return XmlEditRuleCheckAttributes;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlEditorAttributeEditorComponent = /** @class */ (function () {
function XmlEditorAttributeEditorComponent(editorService) {
this.editorService = editorService;
this.attribTypes = RuleAttributeTypes;
this.attributes = [];
}
Object.defineProperty(XmlEditorAttributeEditorComponent.prototype, "editorContextId", {
set: /**
* @param {?} value
* @return {?}
*/ function (value) {
var _this = this;
if (!value) {
return;
}
this.editorContext = this.editorService.getEditorContext(value);
this.actualCursorPosChangedSubscription = this.editorContext.actualCursorChanged.subscribe(function (pos) {
_this.attributes = _this.GetAttributesForCursorPos(pos.StartPos);
_this.elementName = _this.GetElementNameForCursorPos(pos.StartPos);
});
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
XmlEditorAttributeEditorComponent.prototype.ngOnInit = /**
* @return {?}
*/
function () { };
/**
* @return {?}
*/
XmlEditorAttributeEditorComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this.actualCursorPosChangedSubscription.unsubscribe();
};
/**
* @param {?} key
* @param {?} value
* @return {?}
*/
XmlEditorAttributeEditorComponent.prototype.attributeValueChanged = /**
* @param {?} key
* @param {?} value
* @return {?}
*/
function (key, value) {
if (this.actualElement) {
/** @type {?} */
var attribWorker = new Xml2htmlAttributeWorker(this.editorContext.config.rules);
attribWorker.writeAttributeToHtml(this.actualElement, key, value);
}
};
/**
* @param {?} pos
* @return {?}
*/
XmlEditorAttributeEditorComponent.prototype.GetElementNameForCursorPos = /**
* @param {?} pos
* @return {?}
*/
function (pos) {
/** @type {?} */
var rulesCheck = new XmlEditRuleCheckAttributes(this.editorContext.config.xmlSchema);
/** @type {?} */
var parentNode = /** @type {?} */ (rulesCheck.getRelevantParentNodeForCursorPos(pos));
if (parentNode) {
return Xml2html.getTagNameFromNode(parentNode);
}
return undefined;
};
/**
* @param {?} pos
* @return {?}
*/
XmlEditorAttributeEditorComponent.prototype.GetAttributesForCursorPos = /**
* @param {?} pos
* @return {?}
*/
function (pos) {
/** @type {?} */
var attribWorker = new Xml2htmlAttributeWorker(this.editorContext.config.rules);
/** @type {?} */
var rulesCheck = new XmlEditRuleCheckAttributes(this.editorContext.config.xmlSchema);
/** @type {?} */
var parentNode = /** @type {?} */ (rulesCheck.getRelevantParentNodeForCursorPos(pos));
this.actualElement = parentNode;
if (parentNode) {
/** @type {?} */
var allowedAttributes = rulesCheck.AttributesAllowedAtThisCursorPos(pos);
return allowedAttributes.map(function (a) {
return /** @type {?} */ ({
rules: a,
value: attribWorker.getAttributeValueFromHtml(parentNode, a.attribName)
});
});
}
return [];
};
XmlEditorAttributeEditorComponent.decorators = [
{ type: i0.Component, args: [{
selector: 'axed-attribute-editor',
template: "<div class=\"sws-attribute-editor-toolbar\" *ngIf=\"elementName\">\r\n\r\n <h3>Attributes</h3>\r\n\r\n <div *ngIf=\"attributes.length > 0; else noAttributes\">\r\n <p>Attributes for <b>{{elementName}}</b> element</p>\r\n <div *ngFor=\"let attrib of attributes\">\r\n <span>{{attrib.rules.attribName}}</span>:<br />\r\n\r\n <input type=\"text\" *ngIf=\"attrib.rules.typ === attribTypes.String\" value=\"{{attrib.value}}\"\r\n (input)=\"attributeValueChanged(attrib.rules.attribName, $event.target.value);\">\r\n\r\n <select *ngIf=\"attrib.rules.typ === attribTypes.Enum\" value=\"{{attrib.value}}\"\r\n (input)=\"attributeValueChanged(attrib.rules.attribName, $event.target.value);\">\r\n <option *ngIf=\"attrib.rules.required === false\"></option>\r\n <option *ngFor=\"let value of attrib.rules.fixedValues\">{{value}}</option>\r\n </select>\r\n\r\n </div>\r\n </div>\r\n\r\n <ng-template #noAttributes>\r\n No attributes to edit for element <b>{{elementName}}</b>\r\n </ng-template>\r\n\r\n</div>\r\n",
styles: [".sws-attribute-editor-toolbar input,.sws-attribute-editor-toolbar select{width:100%;border-radius:5px;background-color:transparent;padding:.6em 0 .4em;margin-bottom:.3em;border:.5px solid #eee}"]
}] }
];
/** @nocollapse */
XmlEditorAttributeEditorComponent.ctorParameters = function () {
return [
{ type: AngularXmlEditorService }
];
};
XmlEditorAttributeEditorComponent.propDecorators = {
editorContextId: [{ type: i0.Input, args: ['editorContextId',] }]
};
return XmlEditorAttributeEditorComponent;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlEditorDebugComponent = /** @class */ (function () {
function XmlEditorDebugComponent(editorService) {
this.editorService = editorService;
}
Object.defineProperty(XmlEditorDebugComponent.prototype, "editorContextId", {
set: /**
* @param {?} value
* @return {?}
*/ function (value) {
var _this = this;
if (!value) {
return;
}
this.editorContext = this.editorService.getEditorContext(value);
this.actualCursorPosChangedSubscription = this.editorContext.debugService.actualCursorPosChanged$.subscribe(function (pos) {
_this.cursorPosInfo = pos.StartPos.getDebugDescription();
});
this.inputSelectionSubscription = this.editorContext.debugService.inputSelectionChanged$.subscribe(function (info) {
_this.inputSelection = info;
});
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
XmlEditorDebugComponent.prototype.ngOnInit = /**
* @return {?}
*/
function () { };
/**
* @return {?}
*/
XmlEditorDebugComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
this.actualCursorPosChangedSubscription.unsubscribe();
this.inputSelectionSubscription.unsubscribe();
};
XmlEditorDebugComponent.decorators = [
{ type: i0.Component, args: [{
selector: 'axed-debug',
template: "<div class=\"sws-xml-editor-toolbar\">\r\n\r\n <h3>Debugging</h3>\r\n\r\n <div class=\"block\">\r\n <label>Cursor: </label>\r\n {{cursorPosInfo}}\r\n </div>\r\n\r\n <div class=\"block\">\r\n <label>Selection set: </label>\r\n {{inputSelection}}\r\n </div>\r\n\r\n</div>",
styles: [".sws-xml-editor-toolbar{min-height:50px;font:100 .8rem/15px Roboto,Arial,sans-serif;background-color:#f5f5f5;padding:15px;border:1px solid #ddd}.sws-xml-editor-toolbar .block{background-color:transparent;min-width:2rem;border:solid #ddd;padding-bottom:1em}.sws-xml-editor-toolbar label{font-weight:700}"]
}] }
];
/** @nocollapse */
XmlEditorDebugComponent.ctorParameters = function () {
return [
{ type: AngularXmlEditorService }
];
};
XmlEditorDebugComponent.propDecorators = {
editorContextId: [{ type: i0.Input, args: ['editorContextId',] }]
};
return XmlEditorDebugComponent;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var DomBreakcrumbComponent = /** @class */ (function () {
function DomBreakcrumbComponent() {
this.nodes = [];
}
/**
* @return {?}
*/
DomBreakcrumbComponent.prototype.ngOnInit = /**
* @return {?}
*/
function () { };
/**
* @param {?} selection
* @return {?}
*/
DomBreakcrumbComponent.prototype.showSelection = /**
* @param {?} selection
* @return {?}
*/
function (selection) {
if (selection === undefined) {
this.nodes = ['none'];
}
else {
/** @type {?} */
var collectNodes = [];
/** @type {?} */
var node = selection.focusNode;
/** @type {?} */
var reachedTop = node === undefined || node === null;
while (!reachedTop) {
switch (node.nodeType) {
case Node.ELEMENT_NODE: // element node
/** @type {?} */
var asElement = /** @type {?} */ (node);
if (asElement !== undefined) {
/** @type {?} */
var name_1 = asElement.getAttribute('data-tagname');
if (asElement.className === 'sws-xml-editor-textarea') {
reachedTop = true;
}
else {
collectNodes.unshift(name_1);
}
}
}
node = node.parentElement;
if (node === undefined || node == null) {
reachedTop = true;
}
}
this.nodes = collectNodes;
}
};
DomBreakcrumbComponent.decorators = [
{ type: i0.Component, args: [{
selector: 'axed-dom-breakcrumb',
template: "<ul>\r\n <li *ngFor=\"let element of nodes\">\r\n {{ element }}\r\n </li>\r\n</ul>\r\n",
styles: ["ul{list-style-type:none;margin:0;padding:0}ul li{display:inline-block;zoom:1;padding-right:10px}ul li::before{content:'>';color:#d3d3d3}"]
}] }
];
/** @nocollapse */
DomBreakcrumbComponent.ctorParameters = function () { return []; };
return DomBreakcrumbComponent;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var AngularXmlEditorModule = /** @class */ (function () {
function AngularXmlEditorModule() {
}
AngularXmlEditorModule.decorators = [
{ type: i0.NgModule, args: [{
imports: [i1.CommonModule, forms.FormsModule, forms.ReactiveFormsModule],
declarations: [AngularXmlEditorComponent, XmlEditorToolbarComponent, XmlEditorAttributeEditorComponent, XmlEditorDebugComponent, DomBreakcrumbComponent],
exports: [AngularXmlEditorComponent, XmlEditorToolbarComponent, XmlEditorAttributeEditorComponent, XmlEditorDebugComponent, DomBreakcrumbComponent]
},] }
];
return AngularXmlEditorModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlSchema = /** @class */ (function () {
function XmlSchema(xsdNodes) {
this.xsdNodes = xsdNodes;
}
/**
* @param {?} tagName
* @return {?}
*/
XmlSchema.prototype.findXsdNodeForTagName = /**
* @param {?} tagName
* @return {?}
*/
function (tagName) {
return this.xsdNodes.get(tagName);
};
return XmlSchema;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlSchemaLoader = /** @class */ (function () {
function XmlSchemaLoader(schemaContent) {
var _this = this;
if (!schemaContent || schemaContent === '') {
return;
}
/** @type {?} */
var domparser = new DOMParser();
/** @type {?} */
var schemaDom = domparser.parseFromString(schemaContent, 'text/xml');
/** @type {?} */
var result = [];
/** @type {?} */
var rawElementsAtRoot = /** @type {?} */ (Array.from(schemaDom.documentElement.childNodes));
rawElementsAtRoot.forEach(function (e) {
/** @type {?} */
var subChilds = _this.getRawElements(e);
result = result.concat(subChilds);
});
this.xmlSchema = new XmlSchema(this.getXsdNodes(/** @type {?} */ (result)));
}
/**
* @param {?} node
* @return {?}
*/
XmlSchemaLoader.prototype.getRawElements = /**
* @param {?} node
* @return {?}
*/
function (node) {
var _this = this;
/** @type {?} */
var result = [];
if (this.isValidXsdNode(node)) {
result = result.concat(node);
}
/** @type {?} */
var children = /** @type {?} */ (Array.from(node.childNodes));
children.forEach(function (child) {
result = result.concat(_this.getRawElements(child));
});
return result;
};
/**
* @param {?} node
* @return {?}
*/
XmlSchemaLoader.prototype.isValidXsdNode = /**
* @param {?} node
* @return {?}
*/
function (node) {
/** @type {?} */
var allowedXsdTypes = ['element', 'group', 'complexType'];
/** @type {?} */
var asElem = /** @type {?} */ (node);
if (asElem) {
if (allowedXsdTypes.includes(asElem.localName)) {
if (asElem.attributes.getNamedItem('name')) {
// console.warn(asElem.attributes.getNamedItem('name').value);
return true;
}
else {
return false;
}
}
else {
return false;
}
}
else {
return false;
}
};
/**
* @param {?} rawElements
* @return {?}
*/
XmlSchemaLoader.prototype.getXsdNodes = /**
* @param {?} rawElements
* @return {?}
*/
function (rawElements) {
// console.warn(rawElements.length);
return new Map(rawElements.map(function (n) { return [n.attributes.getNamedItem('name').value, /** @type {?} */ (n)]; }));
};
return XmlSchemaLoader;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlRules = /** @class */ (function () {
function XmlRules(ruleElements) {
this.ruleElements = ruleElements;
}
return XmlRules;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var XmlRulesCreator = /** @class */ (function () {
function XmlRulesCreator(schema, _floatingElementNames) {
this.schema = schema;
this._floatingElementNames = _floatingElementNames;
this.rules = new XmlRules(this.getAllElementRuleNodes(Array.from(this.schema.xsdNodes.values())));
}
/**
* @param {?} node
* @return {?}
*/
XmlRulesCreator.prototype.findXsdNodeForHtmlNode = /**
* @param {?} node
* @return {?}
*/
function (node) {
/** @type {?} */
var tagName = Xml2html.getTagNameFromNode(node);
return this.schema.xsdNodes.get(tagName);
};
/**
* @param {?} xsdNodes
* @return {?}
*/
XmlRulesCreator.prototype.getAllElementRuleNodes = /**
* @param {?} xsdNodes
* @return {?}
*/
function (xsdNodes) {
var _this = this;
return new Map(xsdNodes.map(function (xsdNode) { return [xsdNode.attributes.getNamedItem('name').value, _this.getRuleElementForXsdNode(xsdNode)]; }));
};
/**
* @param {?} xsdNode
* @return {?}
*/
XmlRulesCreator.prototype.getRuleElementForXsdNode = /**
* @param {?} xsdNode
* @return {?}
*/
function (xsdNode) {
if (xsdNode) {
/** @type {?} */
var tagName = xsdNode.attributes.getNamedItem('name').value;
return new XmlRuleElement({
tagName: tagName,
floating: this.isFloating(tagName),
empty: this.isEmpty(xsdNode)
});
}
else {
return undefined;
}
};
/**
* @param {?} xsdNode
* @return {?}
*/
XmlRulesCreator.prototype.isEmpty = /**
* @param {?} xsdNode
* @return {?}
*/
function (xsdNode) {
if (new XmlEditRuleCheckTextInsert(this.schema.xsdNodes).isTextAllowedInThisElement(xsdNode) === true) {
return false;
}
return true;
};
/**
* @param {?} tagName
* @return {?}
*/
XmlRulesCreator.prototype.isFloating = /**
* @param {?} tagName
* @return {?}
*/
function (tagName) {
return this._floatingElementNames.includes(tagName);
};
return XmlRulesCreator;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
exports.AngularXmlEditorService = AngularXmlEditorService;
exports.AngularXmlEditorComponent = AngularXmlEditorComponent;
exports.AngularXmlEditorModule = AngularXmlEditorModule;
exports.XmlSchemaLoader = XmlSchemaLoader;
exports.XmlRulesCreator = XmlRulesCreator;
exports.XmlEditorContext = XmlEditorContext;
exports.ɵe = XmlSchema;
exports.ɵd = DomBreakcrumbComponent;
exports.ɵb = XmlEditorAttributeEditorComponent;
exports.ɵc = XmlEditorDebugComponent;
exports.ɵa = XmlEditorToolbarComponent;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"angular-xml-editor.umd.js.map","sources":["ng://angular-xml-editor/lib/code/xmlEditorDebugger.ts","ng://angular-xml-editor/lib/code/xmlToolbox.class.ts","ng://angular-xml-editor/lib/code/xml-html-converter/xml2htmlAttributeWorker.class.ts","ng://angular-xml-editor/lib/code/xml-html-converter/xml2html.class.ts","ng://angular-xml-editor/lib/code/dummyNodes/domDummyNodeManager.class.ts","ng://angular-xml-editor/lib/code/cursor/xmlCursorPos.class.ts","ng://angular-xml-editor/lib/code/cursor/xmlCursorPosMover.class.ts","ng://angular-xml-editor/lib/code/cursor/xmlCursor.class.ts","ng://angular-xml-editor/lib/code/cursor/xmlCursorPosSetter.class.ts","ng://angular-xml-editor/lib/code/xml-editing/xmlDomCleaner.class.ts","ng://angular-xml-editor/lib/code/xml-editing/xmlEditDeleteclass.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlEditRuleCheckTextInsert.class.ts","ng://angular-xml-editor/lib/code/xml-editing/xmlEditInsert.class.ts","ng://angular-xml-editor/lib/code/xmlEditorContext.class.ts","ng://angular-xml-editor/lib/angular-xml-editor.service.ts","ng://angular-xml-editor/lib/code/xml-html-converter/html2xml.class.ts","ng://angular-xml-editor/lib/angular-xml-editor.component.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlRuleElement.class.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlEditRuleCheckElements.class.ts","ng://angular-xml-editor/lib/components/xml-editor-toolbar/xml-editor-toolbar.component.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlRuleAttribut.class.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlEditRuleCheckAttributes.class.ts","ng://angular-xml-editor/lib/components/xml-editor-attribute-editor/xml-editor-attribute-editor.component.ts","ng://angular-xml-editor/lib/components/xml-editor-debug/xml-editor-debug.component.ts","ng://angular-xml-editor/lib/components/dom-breakcrumb/dom-breakcrumb.component.ts","ng://angular-xml-editor/lib/angular-xml-editor.module.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlSchema.class.ts","ng://angular-xml-editor/lib/code/xml-rules-check/XmlSchemaLoader.class.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlRules.class.ts","ng://angular-xml-editor/lib/code/xml-rules-check/xmlRulesCreator.class.ts"],"sourcesContent":["import { OnDestroy } from '@angular/core';\r\nimport { Subject } from 'rxjs';\r\nimport { XmlCursor } from './cursor/xmlCursor.class';\r\n\r\n// @Injectable({\r\n//   providedIn: 'root'\r\n// })\r\nexport class XmlEditorDebugger implements OnDestroy {\r\n  public actualCursorPosChanged$ = new Subject<XmlCursor>();\r\n  public inputSelectionChanged$ = new Subject<string>();\r\n\r\n  constructor() {}\r\n\r\n  setActualCursorPos(pos: XmlCursor) {\r\n    this.actualCursorPosChanged$.next(pos);\r\n  }\r\n\r\n  setInputSelection(info: string) {\r\n    this.inputSelectionChanged$.next(info);\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.actualCursorPosChanged$.complete();\r\n    this.inputSelectionChanged$.complete();\r\n  }\r\n}\r\n","export class XmlToolbox {\r\n  /// <summary>\r\n  /// Ist dieser Node ein als Text bearbeitbarer Node\r\n  /// </summary>\r\n  /// <param name=\"node\"></param>\r\n  /// <returns></returns>\r\n  public static IsTextOrCommentNode(node: Node): boolean {\r\n    switch (node.nodeType) {\r\n      case Node.TEXT_NODE: // text node\r\n      case Node.COMMENT_NODE:\r\n        return true;\r\n      default:\r\n        return false;\r\n    }\r\n    // return ((node.nodeType === System.Xml.XmlText) || (node.nodeType === System.Xml.XmlComment));\r\n  }\r\n\r\n  // Gets the info to identify a node for exception or debug purposes\r\n  public static GetNodeDebugContext(node: Node): string {\r\n    if (node === null || node === undefined) {\r\n      return 'NULL';\r\n    }\r\n\r\n    if (node.nodeType === Node.TEXT_NODE) {\r\n      if (node.textContent === ' ' || node.textContent === String.fromCharCode(160)) {\r\n        return `TextContent!Parent=${XmlToolbox.GetNodeDebugContext(node.parentNode)}`;\r\n      } else {\r\n        return `TextContent='${node.textContent}'`;\r\n      }\r\n    }\r\n\r\n    const asElem = node as Element;\r\n    if (asElem === undefined) {\r\n      return `localName: ${node.nodeName}, nodeType:${node.nodeType}`;\r\n    } else {\r\n      return asElem.outerHTML;\r\n    }\r\n  }\r\n}\r\n","import { XmlRules } from '../xml-rules-check/xmlRules.class';\r\n\r\nexport class Xml2htmlAttributeWorker {\r\n  public static DataAttribPraefix = 'data-attribute-';\r\n\r\n  constructor(public rules: XmlRules) {}\r\n\r\n  /** writes the given attributes to the html node in data-attribute-syntax **/\r\n  writeAllXmlAttributesToHtml(xmlElement: Element, htmlElement: Element) {\r\n    const attributes = xmlElement.attributes;\r\n    for (let i = 0; i < attributes.length; ++i) {\r\n      const attr = attributes[i];\r\n      this.writeAttributeToHtml(htmlElement, attr.name, attr.value);\r\n    }\r\n  }\r\n\r\n  /** writes the given attribute value to the html node in data-attribute-syntax **/\r\n  writeAttributeToHtml(htmlElement: Element, key: string, value: string) {\r\n    const name = `${Xml2htmlAttributeWorker.DataAttribPraefix}${key}`;\r\n    if (value && value.length > 0) {\r\n      htmlElement.setAttribute(name, value);\r\n    } else {\r\n      htmlElement.removeAttribute(name);\r\n    }\r\n    this.updateAttributesDescriptionInHtmlElement(htmlElement);\r\n  }\r\n\r\n  /** writes the given attribute value from the html node data-attribute-syntax **/\r\n  getAttributeValueFromHtml(htmlElement: Element, key: string): string {\r\n    const attributes = htmlElement.attributes;\r\n    for (let i = 0; i < attributes.length; ++i) {\r\n      if (attributes[i].name === `${Xml2htmlAttributeWorker.DataAttribPraefix}${key}`) {\r\n        return attributes[i].value;\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  /** writes the given attribute value to the xml node (and gets it from the html node from data-attribute-syntax) **/\r\n  writeAllHtmlAttributesToXml(htmlElement: Element, xmlElement: Element) {\r\n    const attributes = htmlElement.attributes;\r\n    for (let i = 0; i < attributes.length; ++i) {\r\n      const attr = attributes[i];\r\n      if (attr.name.startsWith(Xml2htmlAttributeWorker.DataAttribPraefix)) {\r\n        xmlElement.setAttribute(attr.name.substr(Xml2htmlAttributeWorker.DataAttribPraefix.length), attr.value);\r\n      }\r\n    }\r\n  }\r\n\r\n  /** updates the 'for human eyes' only description of the attributes inside a html node **/\r\n  private updateAttributesDescriptionInHtmlElement(htmlElement: Element) {\r\n    const attributes = htmlElement.attributes;\r\n    let allAttributes = '';\r\n    for (let i = 0; i < attributes.length; ++i) {\r\n      const attr = attributes[i];\r\n      if (attr.name.startsWith(Xml2htmlAttributeWorker.DataAttribPraefix)) {\r\n        allAttributes = `${allAttributes} ${attr.name.substr(Xml2htmlAttributeWorker.DataAttribPraefix.length)}=\"${attr.value}\"`;\r\n      }\r\n    }\r\n    if (allAttributes.length > 0) {\r\n      htmlElement.setAttribute('data-attributes', allAttributes);\r\n    } else {\r\n      htmlElement.removeAttribute('data-attributes');\r\n    }\r\n  }\r\n}\r\n","import { XmlRules } from '../xml-rules-check/xmlRules.class';\r\nimport { XmlToolbox } from '../xmlToolbox.class';\r\nimport { Xml2htmlAttributeWorker } from './xml2htmlAttributeWorker.class';\r\nimport { XmlRuleElement } from '../xml-rules-check/xmlRuleElement.class';\r\n\r\nexport class Xml2html {\r\n  private static DataTagName = 'data-tagname';\r\n  public static NoClosingTagClassName = 'xmlTagNoClosing';\r\n  public static FloatingTagClassName = 'floating';\r\n  public static CommentTagClassName = 'comment';\r\n\r\n  private attributeWorker: Xml2htmlAttributeWorker;\r\n\r\n  constructor(public rules: XmlRules) {\r\n    this.attributeWorker = new Xml2htmlAttributeWorker(rules);\r\n  }\r\n\r\n  static getTagNameFromNode(node: Node): string {\r\n    const elem = node as Element;\r\n    let name = '';\r\n    if (elem) {\r\n      name = elem.getAttribute(Xml2html.DataTagName);\r\n    }\r\n    if (name === undefined || name === null || name === '') {\r\n      throw new Error(`node has no DataTagName attribute ${XmlToolbox.GetNodeDebugContext(node)}`);\r\n    }\r\n    return name;\r\n  }\r\n\r\n  static isFloatingElement(node: Node): boolean {\r\n    const elem = node as Element;\r\n    if (elem && elem.classList) {\r\n      return elem.classList.contains(Xml2html.FloatingTagClassName);\r\n    }\r\n    return false;\r\n  }\r\n\r\n  static isNoClosingElement(node: Node): boolean {\r\n    const elem = node as Element;\r\n    if (elem && elem.classList) {\r\n      return elem.classList.contains(Xml2html.NoClosingTagClassName);\r\n    }\r\n    return false;\r\n  }\r\n\r\n  public ToHtml(xml: string): string {\r\n    if (xml === '' || xml === undefined || xml === null) {\r\n      return '';\r\n    }\r\n\r\n    // alert(xml);\r\n\r\n    // remove newline / carriage return\r\n    xml = xml.replace(/\\n/g, '');\r\n    xml = xml.replace(/\\r/g, '');\r\n    // remove whitespace (tabs) before tags\r\n    xml = xml.replace(/[\\t]+\\</g, '<');\r\n    // remove whitespace between tags\r\n    xml = xml.replace(/\\>[\\t]+\\</g, '><');\r\n    // remove whitespace after tags\r\n    xml = xml.replace(/\\>[\\t]+$/g, '>');\r\n\r\n    const domparser = new DOMParser();\r\n    const domdoc = domparser.parseFromString(xml, 'text/xml');\r\n\r\n    const targetDocument = new Document();\r\n\r\n    if (domdoc.documentElement === null) {\r\n      return '';\r\n    }\r\n\r\n    const body = this.GetHtmlElementFromXmlElement(domdoc.documentElement, targetDocument);\r\n    if (body && body.nodeType === Node.ELEMENT_NODE) {\r\n      const html = (body as Element).outerHTML;\r\n      return html;\r\n    } else {\r\n      throw new Error(`root node ${XmlToolbox.GetNodeDebugContext(body)} is no element`);\r\n    }\r\n  }\r\n\r\n  createNewElementHtml(ruleElem: XmlRuleElement): string {\r\n    const elem = this.createNewElementByName(ruleElem.tagName);\r\n    return elem.outerHTML;\r\n  }\r\n\r\n  public createNewElementByName(tagName: string): Element {\r\n    const tempDoc = new Document();\r\n    const newElement = tempDoc.createElement('div');\r\n    // floating element or not?\r\n    const rule = this.rules.ruleElements.get(tagName);\r\n    if (rule && rule.floating === true) {\r\n      newElement.classList.add(Xml2html.FloatingTagClassName);\r\n    }\r\n    // visualize closing tag or not?\r\n    if (rule && rule.empty === true) {\r\n      newElement.classList.add(Xml2html.NoClosingTagClassName);\r\n    }\r\n    newElement.setAttribute(Xml2html.DataTagName, tagName);\r\n    return newElement;\r\n  }\r\n\r\n  private GetHtmlElementFromXmlElement(node: Node, targetDocument: Document): Node {\r\n    switch (node.nodeType) {\r\n      case Node.ELEMENT_NODE: // element node\r\n        const asElement = node as Element;\r\n        const nodeName = asElement.nodeName;\r\n\r\n        // create element node\r\n        let newElement = targetDocument.createElement('div');\r\n\r\n        // floating element or not?\r\n        const rule = this.rules.ruleElements.get(nodeName);\r\n        if (rule && rule.floating) {\r\n          newElement.classList.add(Xml2html.FloatingTagClassName);\r\n        }\r\n        // visualize closing tag or not?\r\n        if (rule && rule.empty) {\r\n          newElement.classList.add(Xml2html.NoClosingTagClassName);\r\n        }\r\n        newElement.setAttribute(Xml2html.DataTagName, nodeName);\r\n\r\n        // append child elements recursive\r\n        const children = asElement.childNodes;\r\n        if (children.length === 0) {\r\n          newElement.appendChild(targetDocument.createTextNode('')); // to prevent non closing tags\r\n        } else {\r\n          for (let i = 0; i < children.length; ++i) {\r\n            const childAsHtml = this.GetHtmlElementFromXmlElement(children[i], targetDocument);\r\n            if (childAsHtml !== undefined) {\r\n              newElement.appendChild(childAsHtml);\r\n            }\r\n          }\r\n        }\r\n\r\n        // insert attributes\r\n        this.attributeWorker.writeAllXmlAttributesToHtml(asElement, newElement);\r\n\r\n        return newElement;\r\n\r\n      case Node.TEXT_NODE: // text node\r\n        const content = (node as Element).textContent;\r\n        if (content.length > 0) {\r\n          return targetDocument.createTextNode(content);\r\n        } else {\r\n          return undefined;\r\n        }\r\n\r\n      case Node.COMMENT_NODE:\r\n        // create element node\r\n        newElement = targetDocument.createElement('div');\r\n        newElement.classList.add(Xml2html.CommentTagClassName);\r\n        newElement.setAttribute(Xml2html.DataTagName, 'comment');\r\n        newElement.textContent = (node as Element).textContent;\r\n        return newElement;\r\n\r\n      /* yet not implemented types */\r\n      case Node.PROCESSING_INSTRUCTION_NODE:\r\n        console.warn(`nodeType \"PROCESSING_INSTRUCTION_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} not implemented yet`);\r\n        return undefined;\r\n\r\n      case Node.DOCUMENT_NODE:\r\n        throw new Error(`nodeType \"Node.DOCUMENT_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} not implemented yet`);\r\n      case Node.DOCUMENT_TYPE_NODE:\r\n        throw new Error(`nodeType \"Node.DOCUMENT_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} not implemented yet`);\r\n      case Node.DOCUMENT_FRAGMENT_NODE:\r\n        throw new Error(`nodeType \"Node.DOCUMENT_FRAGMENT_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} not implemented yet`);\r\n\r\n      /* Depreached node types */\r\n      case Node.ATTRIBUTE_NODE:\r\n        throw new Error(`nodeType \"Node.ATTRIBUTE_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} is depreached`);\r\n      case Node.CDATA_SECTION_NODE:\r\n        throw new Error(`nodeType \"Node.CDATA_SECTION_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} is depreached`);\r\n      case Node.ENTITY_REFERENCE_NODE:\r\n        throw new Error(`nodeType \"Node.ENTITY_REFERENCE_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} is depreached`);\r\n      case Node.ENTITY_NODE:\r\n        throw new Error(`nodeType \"Node.ENTITY_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} is depreached`);\r\n      case Node.NOTATION_NODE:\r\n        throw new Error(`nodeType \"Node.NOTATION_NODE\" ${XmlToolbox.GetNodeDebugContext(node)} is depreached`);\r\n\r\n      default:\r\n        // tslint:disable-next-line:max-line-length\r\n        throw new Error(`unknown xmlElement nodeType ${node.nodeType} in value: ${XmlToolbox.GetNodeDebugContext(node)}`);\r\n    }\r\n  }\r\n}\r\n","import { Xml2html } from '../xml-html-converter/xml2html.class';\r\n\r\nexport class DomDummyNodeManager {\r\n  public static DummyNodeClassName = 'dummyNode';\r\n  public static DummyNodeBeforeFirstTagClassName = 'beforefirstTag';\r\n  public static DummyNodeContent = String.fromCharCode(160);\r\n\r\n  constructor() {}\r\n\r\n  public static IsDummyNode(node: Node) {\r\n    const asElem = node as Element;\r\n    if (asElem && node.nodeType === Node.ELEMENT_NODE) {\r\n      return asElem.classList.contains(DomDummyNodeManager.DummyNodeClassName);\r\n    }\r\n    return false;\r\n  }\r\n\r\n  public static IsBeforeFirstTagDummyNode(node: Node) {\r\n    if (DomDummyNodeManager.IsDummyNode(node)) {\r\n      const asElem = node as Element;\r\n      if (asElem && node.nodeType === Node.ELEMENT_NODE) {\r\n        return asElem.classList.contains(DomDummyNodeManager.DummyNodeBeforeFirstTagClassName);\r\n      }\r\n      return false;\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  // get previos sibling - except dummy nodes\r\n  public static getPreviousSibling(node: Node): Node {\r\n    if (!node) {\r\n      return undefined;\r\n    }\r\n    while (node) {\r\n      node = node.previousSibling;\r\n      if (node) {\r\n        if (DomDummyNodeManager.IsDummyNode(node)) {\r\n        } else {\r\n          return node;\r\n        }\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  // get next sibling - except dummy nodes\r\n  public static getNextSibling(node: Node): Node {\r\n    if (!node) {\r\n      return undefined;\r\n    }\r\n    while (node) {\r\n      node = node.nextSibling;\r\n      if (node) {\r\n        if (DomDummyNodeManager.IsDummyNode(node)) {\r\n        } else {\r\n          return node;\r\n        }\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  // get children count - except dummy nodes\r\n  public static getChildNodeCount(node: Node): number {\r\n    if (!node) {\r\n      return 0;\r\n    }\r\n    let count = 0;\r\n    for (let i = 0; i < node.childNodes.length; i++) {\r\n      if (!DomDummyNodeManager.IsDummyNode(node.childNodes[i])) {\r\n        count++;\r\n      }\r\n    }\r\n    return count;\r\n  }\r\n\r\n  // get first child - except dummy nodes\r\n  public static getFirstChild(node: Node): Node {\r\n    if (!node) {\r\n      return undefined;\r\n    }\r\n    let first = node.firstChild as Node;\r\n    while (DomDummyNodeManager.IsDummyNode(first)) {\r\n      first = first.nextSibling;\r\n    }\r\n    return first;\r\n  }\r\n\r\n  // get last child - except dummy nodes\r\n  public static getLastChild(node: Node): Node {\r\n    if (!node) {\r\n      return undefined;\r\n    }\r\n    let last = node.lastChild as Node;\r\n    while (DomDummyNodeManager.IsDummyNode(last)) {\r\n      last = last.previousSibling;\r\n    }\r\n    return last;\r\n  }\r\n\r\n  RemoveAllDummyNodes(node: Node, nodeDepth = 0): void {\r\n    let children: Node[] = [];\r\n    for (let i = 0; i < node.childNodes.length; ++i) {\r\n      children.push(node.childNodes[i]);\r\n    }\r\n\r\n    // delete all dummy node children\r\n    children.forEach(child => {\r\n      if (DomDummyNodeManager.IsDummyNode(child)) {\r\n        node.removeChild(child);\r\n      }\r\n    });\r\n\r\n    children = [];\r\n    for (let i = 0; i < node.childNodes.length; ++i) {\r\n      children.push(node.childNodes[i]);\r\n    }\r\n\r\n    // update child nodes\r\n    children.forEach(child => {\r\n      this.RemoveAllDummyNodes(child, nodeDepth + 1);\r\n    });\r\n  }\r\n\r\n  UpdateDummyNodes(node: Node, nodeDepth = 0) {\r\n    const document = node.ownerDocument;\r\n    const asElement = node as Element;\r\n\r\n    const children: Node[] = [];\r\n    for (let i = 0; i < node.childNodes.length; ++i) {\r\n      children.push(node.childNodes[i]);\r\n    }\r\n\r\n    if (asElement && !DomDummyNodeManager.IsDummyNode(asElement) && !DomDummyNodeManager.IsDummyNode(asElement.parentElement)) {\r\n      if (asElement.nodeType === Node.TEXT_NODE) {\r\n        const before = asElement.previousSibling;\r\n        if (before.nodeType === Node.TEXT_NODE) {\r\n          // textnode after text node: dont insert dummy node!\r\n        } else {\r\n          if (!DomDummyNodeManager.IsDummyNode(before)) {\r\n            asElement.parentNode.insertBefore(this.createDummyNode(document), asElement);\r\n          }\r\n        }\r\n      }\r\n\r\n      if (asElement.nodeType === Node.ELEMENT_NODE) {\r\n        let firstChild = node.firstChild;\r\n        if (!firstChild) {\r\n          // create dummy node in empty tag\r\n          node.appendChild(this.createDummyNode(document));\r\n          firstChild = node.firstChild;\r\n        }\r\n\r\n        if (Xml2html.isNoClosingElement(node)) {\r\n        } else {\r\n          firstChild = node.firstChild;\r\n\r\n          if (!firstChild) {\r\n            // create dummy node in empty tag\r\n            node.appendChild(this.createDummyNode(document));\r\n            firstChild = node.firstChild;\r\n          }\r\n\r\n          // Insert a dummy node before the first child\r\n          if (!DomDummyNodeManager.IsDummyNode(firstChild)) {\r\n            if (firstChild) {\r\n              node.insertBefore(this.createDummyNode(document), firstChild);\r\n              firstChild = node.firstChild;\r\n            } else {\r\n              node.appendChild(this.createDummyNode(document));\r\n            }\r\n          }\r\n\r\n          // Insert a dummy node after the last child\r\n          let lastChild = node.lastChild;\r\n          if (!DomDummyNodeManager.IsDummyNode(lastChild)) {\r\n            node.appendChild(this.createDummyNode(document));\r\n            lastChild = node.lastChild;\r\n          }\r\n\r\n          // Insert a dummy node before the first (dummy child) but optical in front of the node (to show the cursor in front of the node)\r\n          if (nodeDepth > 0) {\r\n            if (DomDummyNodeManager.IsDummyNode(firstChild) && !DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {\r\n              const dummyNode = this.createDummyNode(document);\r\n              dummyNode.classList.add(DomDummyNodeManager.DummyNodeBeforeFirstTagClassName);\r\n              asElement.insertBefore(dummyNode, firstChild);\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    // update child nodes\r\n    children.forEach(child => {\r\n      this.UpdateDummyNodes(child, nodeDepth + 1);\r\n    });\r\n  }\r\n\r\n  public createDummyNode(targetDocument: Document, content?: string): Element {\r\n    const dummyNode = targetDocument.createElement('span');\r\n    let dummy2TextNode;\r\n    if (content === undefined) {\r\n      dummy2TextNode = targetDocument.createTextNode(DomDummyNodeManager.DummyNodeContent);\r\n    } else {\r\n      dummy2TextNode = targetDocument.createTextNode(content);\r\n    }\r\n    dummyNode.classList.add(DomDummyNodeManager.DummyNodeClassName);\r\n    dummyNode.appendChild(dummy2TextNode);\r\n    return dummyNode;\r\n  }\r\n}\r\n","import { XmlToolbox } from '../xmlToolbox.class';\r\nimport { SelectionPos } from './xmlCursor.class';\r\nimport { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\nimport { Xml2html } from '../xml-html-converter/xml2html.class';\r\n\r\nexport class XmlCursorPos {\r\n  public ActualNode: Node; // this XMLNode actual has the editor focus\r\n  public PosAtNode: XMLCursorPositions; // At this position the cursor is - inside oder outside the actual focussed node\r\n  public PosInTextnode: number; // The cursor positio inside floating text when pos  is CursorInnerhalbDesTextNodes\r\n\r\n  static getXmlCursorPositionDebugName(position: XMLCursorPositions): string {\r\n    switch (position) {\r\n      case XMLCursorPositions.CursorOnCompleteNode:\r\n        return 'CursorOnCompleteNode';\r\n      case XMLCursorPositions.CursorBehindNode:\r\n        return 'CursorBehindNode';\r\n      case XMLCursorPositions.CursorInEmptyNode:\r\n        return 'CursorInEmptyNode';\r\n      case XMLCursorPositions.CursorInsideTextNode:\r\n        return 'CursorInsideTextNode';\r\n      case XMLCursorPositions.CursorInFrontOfNode:\r\n        return 'CursorInFrontOfNode';\r\n      default:\r\n        return `unknown cursorPos ${position}`;\r\n    }\r\n  }\r\n\r\n  static getSelectionForPos(pos: XmlCursorPos): SelectionPos {\r\n    if (DomDummyNodeManager.IsDummyNode(pos.ActualNode)) {\r\n      throw new Error(`XmlCursorPos.getSelectionForPos: pos.AktNode ${pos.getDebugDescription()} is a dummy node!`);\r\n    }\r\n\r\n    if (DomDummyNodeManager.IsDummyNode(pos.ActualNode.parentElement)) {\r\n      throw new Error(`XmlCursorPos.getSelectionForPos: pos.AktNode.parentElement ${pos.getDebugDescription()} is a dummy node!`);\r\n    }\r\n\r\n    switch (pos.PosAtNode) {\r\n      case XMLCursorPositions.CursorOnCompleteNode: // (0)\r\n        let firstChild = pos.ActualNode.firstChild;\r\n        if (DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {\r\n          return {\r\n            node: firstChild.firstChild, // text inside BeforeFirstTagDummyNod\r\n            offset: 0\r\n          };\r\n        } else {\r\n          return {\r\n            node: pos.ActualNode,\r\n            offset: 0\r\n          };\r\n        }\r\n\r\n      case XMLCursorPositions.CursorInFrontOfNode: // (1)\r\n        if (pos.ActualNode.nodeType === Node.TEXT_NODE) {\r\n          // text node\r\n          const dummyBefore = pos.ActualNode.previousSibling;\r\n          if (DomDummyNodeManager.IsDummyNode(dummyBefore)) {\r\n            return {\r\n              node: dummyBefore.firstChild, // before text node\r\n              offset: 1\r\n            };\r\n          } else {\r\n            throw new Error('XMLCursorPositions.CursorInFrontOfNode (1):text node: is no dummy node:  ' + pos.getDebugDescription());\r\n          }\r\n        } else {\r\n          // no text node\r\n          firstChild = pos.ActualNode.firstChild;\r\n          if (DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {\r\n            return {\r\n              node: firstChild.firstChild, // text inside BeforeFirstTagDummyNod\r\n              offset: 1\r\n            };\r\n          }\r\n          if (Xml2html.isNoClosingElement(pos.ActualNode) && DomDummyNodeManager.IsDummyNode(firstChild)) {\r\n            return { node: firstChild.firstChild, offset: 1 };\r\n          }\r\n          throw new Error('XMLCursorPositions.CursorInFrontOfNode (1):no text node: dont know what to do! ');\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorBehindNode: // (7, 11)\r\n        const dummyAfter = pos.ActualNode.nextSibling;\r\n        if (DomDummyNodeManager.IsDummyNode(dummyAfter)) {\r\n          return {\r\n            node: dummyAfter.firstChild, // before text node\r\n            offset: 0\r\n          };\r\n        } else {\r\n          throw new Error(`XMLCursorPositionen.CursorBehindNode should only be set, when the element has no next sibling.`);\r\n        }\r\n\r\n      case XMLCursorPositions.CursorInEmptyNode:\r\n        const lastChild = pos.ActualNode.lastChild;\r\n        if (!DomDummyNodeManager.IsDummyNode(firstChild) && !DomDummyNodeManager.IsBeforeFirstTagDummyNode(firstChild)) {\r\n          return {\r\n            node: lastChild.firstChild, // text inside DummyNode\r\n            offset: 0\r\n          };\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInsideTextNode:\r\n        return {\r\n          node: pos.ActualNode,\r\n          offset: pos.PosInTextnode\r\n        };\r\n    }\r\n    throw new Error(`showCursor.getSelectionForPos unknown CursorPos ${pos.getDebugDescription()}`);\r\n  }\r\n\r\n  constructor() {\r\n    this.ActualNode = null; // no node selected\r\n    this.PosAtNode = XMLCursorPositions.CursorOnCompleteNode;\r\n    this.PosInTextnode = 0;\r\n  }\r\n\r\n  clone(): XmlCursorPos {\r\n    const klon = new XmlCursorPos();\r\n    klon.SetCursor(this.ActualNode, this.PosAtNode, this.PosInTextnode);\r\n    return klon;\r\n  }\r\n\r\n  equals(otherPos: XmlCursorPos): boolean {\r\n    if (!otherPos) {\r\n      return false;\r\n    }\r\n    if (otherPos.ActualNode !== this.ActualNode) {\r\n      return false;\r\n    }\r\n    if (otherPos.PosAtNode !== this.PosAtNode) {\r\n      return false;\r\n    }\r\n    if (this.PosAtNode === XMLCursorPositions.CursorInsideTextNode && this.PosInTextnode !== otherPos.PosInTextnode) {\r\n      return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  getDebugDescription(): string {\r\n    return `node:${XmlToolbox.GetNodeDebugContext(this.ActualNode)}, pos:${XmlCursorPos.getXmlCursorPositionDebugName(this.PosAtNode)}, posInText:${this.PosInTextnode}`;\r\n  }\r\n\r\n  SetCursor(actualNode: Node, posAtNode: XMLCursorPositions, posInTextnode: number = 0) {\r\n    if (!actualNode) {\r\n      throw new Error('actualNode is null');\r\n    }\r\n\r\n    let changed: boolean;\r\n    if (actualNode !== this.ActualNode) {\r\n      changed = true;\r\n    } else {\r\n      if (posAtNode !== this.PosAtNode) {\r\n        changed = true;\r\n      } else {\r\n        if (posInTextnode !== this.PosInTextnode) {\r\n          changed = true;\r\n        } else {\r\n          changed = false;\r\n        }\r\n      }\r\n    }\r\n\r\n    this.ActualNode = actualNode;\r\n    this.PosAtNode = posAtNode;\r\n    this.PosInTextnode = posInTextnode;\r\n\r\n    // console.log(`SetCursor: ${this.getDebugDescription()}`);\r\n\r\n    if (changed) {\r\n      // PosChanged(EventArgs.Empty); // inform you that the cursor has now been changed\r\n    }\r\n  }\r\n\r\n  setCursorBehindNodeForDefaultOrRightMovement(node: Node) {\r\n    const nextSibling = DomDummyNodeManager.getNextSibling(node);\r\n    if (nextSibling) {\r\n      this.SetCursor(nextSibling, XMLCursorPositions.CursorInFrontOfNode);\r\n    } else {\r\n      this.SetCursor(node, XMLCursorPositions.CursorBehindNode);\r\n    }\r\n  }\r\n\r\n  setCursorpBehindNodeForLeftMovement(node: Node) {\r\n    if (XmlToolbox.IsTextOrCommentNode(node)) {\r\n      //  For a text node, the cursor is placed after the last character.\r\n      this.SetCursor(node, XMLCursorPositions.CursorInsideTextNode, Math.max(0, node.textContent.length - 1));\r\n    } else {\r\n      const childNodeCount = DomDummyNodeManager.getChildNodeCount(node);\r\n      if (childNodeCount === 0) {\r\n        // There are no children in the node.\r\n        if (!Xml2html.isNoClosingElement(node)) {\r\n          // If the cursor shows a close tag, then put it in the empty node\r\n          this.SetCursor(node, XMLCursorPositions.CursorInEmptyNode);\r\n        } else {\r\n          // If the cursor does not display a close tag, then place it before the empty node.\r\n          this.SetCursor(node, XMLCursorPositions.CursorInFrontOfNode);\r\n        }\r\n      } else {\r\n        // There are children in node\r\n        this.SetCursor(DomDummyNodeManager.getLastChild(node), XMLCursorPositions.CursorBehindNode);\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\nexport enum XMLCursorPositions {\r\n  CursorInFrontOfNode = 0,\r\n  CursorOnCompleteNode = 1,\r\n  CursorInEmptyNode = 2,\r\n  CursorInsideTextNode = 3,\r\n  CursorBehindNode = 4\r\n}\r\n","import { XmlCursorPos, XMLCursorPositions } from './xmlCursorPos.class';\r\nimport { XmlRules } from '../xml-rules-check/xmlRules.class';\r\nimport { XmlToolbox } from '../xmlToolbox.class';\r\nimport { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\nimport { Xml2html } from '../xml-html-converter/xml2html.class';\r\n\r\nexport class XmlCursorPosMover {\r\n  public static moveLeft(pos: XmlCursorPos, rootNode: Element, xmlRules: XmlRules): boolean {\r\n    if (pos === undefined) {\r\n      return false;\r\n    }\r\n\r\n    switch (pos.PosAtNode) {\r\n      case XMLCursorPositions.CursorOnCompleteNode:\r\n        // Put in front of the node\r\n        pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode);\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInFrontOfNode:\r\n        if (pos.ActualNode === rootNode) {\r\n          return false;\r\n        } else {\r\n          const previousSibling = DomDummyNodeManager.getPreviousSibling(pos.ActualNode);\r\n          if (previousSibling) {\r\n            // Previous sibling node exists\r\n            pos.setCursorpBehindNodeForLeftMovement(previousSibling);\r\n          } else {\r\n            // no previous sibling node available -> set before parent node\r\n            pos.SetCursor(pos.ActualNode.parentNode, XMLCursorPositions.CursorInFrontOfNode);\r\n          }\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorBehindNode:\r\n        pos.setCursorpBehindNodeForLeftMovement(pos.ActualNode);\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInEmptyNode:\r\n        // Put in front of the node\r\n        pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode);\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInsideTextNode:\r\n        if (XmlToolbox.IsTextOrCommentNode(pos.ActualNode)) {\r\n          // Node is Textnode\r\n          if (pos.PosInTextnode > 1) {\r\n            // Cursor one character to the left\r\n            pos.SetCursor(pos.ActualNode, pos.PosAtNode, pos.PosInTextnode - 1);\r\n          } else {\r\n            // Put in front of the node\r\n            pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode);\r\n          }\r\n        } else {\r\n          // no Textnode\r\n          const elemt = pos.ActualNode as Element;\r\n          throw new Error(`XMLCursorPos.MoveLeft: CursorPos is XMLCursorPositionen.CursorInnerhalbDesTextNodes,\r\n                           but no text node has been chosen, but the node ${elemt ? elemt.outerHTML : ''}`);\r\n        }\r\n        break;\r\n\r\n      default:\r\n        throw new Error(`XMLCursorPos.MoveLeft: unknown CursorPos ${pos.PosAtNode}`);\r\n    }\r\n    return true;\r\n  }\r\n\r\n  public static moveRight(pos: XmlCursorPos, rootNode: Element, xmlRules: XmlRules): boolean {\r\n    if (pos === undefined) {\r\n      return false;\r\n    }\r\n\r\n    switch (pos.PosAtNode) {\r\n      case XMLCursorPositions.CursorOnCompleteNode:\r\n        // Hinter den Node setzen\r\n        const tagName = Xml2html.getTagNameFromNode(pos.ActualNode);\r\n        const rule = xmlRules.ruleElements.get(tagName);\r\n        if (rule && rule.empty === true) {\r\n          pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);\r\n        } else {\r\n          const firstChild = DomDummyNodeManager.getFirstChild(pos.ActualNode);\r\n          if (firstChild) {\r\n            pos.SetCursor(firstChild, XMLCursorPositions.CursorInFrontOfNode);\r\n          } else {\r\n            pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInEmptyNode);\r\n          }\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorBehindNode:\r\n        const nextSibling = DomDummyNodeManager.getNextSibling(pos.ActualNode);\r\n        if (nextSibling) {\r\n          // cursor behind node should only be set, when no other siblings are following\r\n          const elemt = pos.ActualNode as Element;\r\n          throw new Error(`XMLCursorPos.MoveRight: cursor behind node should only be set, when no other siblings are following ${elemt ? elemt.outerHTML : ''}`);\r\n        } else {\r\n          // No following siblings present, then set after parent node\r\n          const parentNextSibling = DomDummyNodeManager.getNextSibling(pos.ActualNode.parentElement);\r\n          if (parentNextSibling) {\r\n            pos.SetCursor(parentNextSibling, XMLCursorPositions.CursorInFrontOfNode);\r\n          } else {\r\n            pos.SetCursor(pos.ActualNode.parentElement, XMLCursorPositions.CursorBehindNode);\r\n          }\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInEmptyNode:\r\n        // Place behind the node\r\n        pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInFrontOfNode:\r\n        if (XmlToolbox.IsTextOrCommentNode(pos.ActualNode)) {\r\n          // Node is Textnode\r\n          if ((pos.ActualNode as Element).textContent.length > 1) {\r\n            // Textnode is not empty\r\n            pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, 1); // one character forward, behind the first character\r\n          } else {\r\n            // Textnode is empty\r\n            // put behind the node\r\n            pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorBehindNode);\r\n            // Because \"CursorBehindNode\" is not attractive, one more step\r\n            this.moveRight(pos, rootNode, xmlRules);\r\n          }\r\n        } else {\r\n          // Node is not Textnode\r\n          const childNodeCount = DomDummyNodeManager.getChildNodeCount(pos.ActualNode);\r\n          if (childNodeCount === 0) {\r\n            // no Children existing\r\n            if (Xml2html.isNoClosingElement(pos.ActualNode)) {\r\n              // If no closed tag is displayed for this node, then directly behind the node\r\n              // Place behind the node\r\n              pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);\r\n            } else {\r\n              // Node has closing tag, so put in between\r\n              // Place in empty node\r\n              pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInEmptyNode);\r\n            }\r\n          } else {\r\n            // Children existing\r\n            const firstChild = DomDummyNodeManager.getFirstChild(pos.ActualNode);\r\n            pos.SetCursor(firstChild, XMLCursorPositions.CursorInFrontOfNode);\r\n          }\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInsideTextNode:\r\n        if (XmlToolbox.IsTextOrCommentNode(pos.ActualNode)) {\r\n          // Node is Textnode\r\n          if ((pos.ActualNode as Element).textContent.length > pos.PosInTextnode + 1) {\r\n            // there is still text in the right of the textnode\r\n            // step one character forwards: behind the first char\r\n            pos.SetCursor(pos.ActualNode, pos.PosAtNode, pos.PosInTextnode + 1);\r\n          } else {\r\n            // no text after the textnode\r\n            // place cursor behind the node\r\n            pos.setCursorBehindNodeForDefaultOrRightMovement(pos.ActualNode);\r\n          }\r\n        } else {\r\n          // Node is no Textnode\r\n          const elemt = pos.ActualNode as Element;\r\n          throw new Error(`XMLCursorPos.MoveRight: CursorPos is XMLCursorPositionen.CursorInnerhalbDesTextNodes, \r\n                        but no text node has been chosen, but the node ${elemt ? elemt.outerHTML : ''}`);\r\n        }\r\n        break;\r\n      default:\r\n        throw new Error(`String.Format(\"XMLCursorPos.MoveRight: unknown CursorPos ${pos.PosAtNode}`);\r\n    }\r\n\r\n    return true;\r\n  }\r\n}\r\n","import { XmlCursorPos, XMLCursorPositions } from './xmlCursorPos.class';\r\nimport { XmlToolbox } from '../xmlToolbox.class';\r\nimport { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\n\r\nexport class XmlCursor {\r\n  xmlDocumentRootNode: Element = undefined;\r\n  domDummyNodeManager = new DomDummyNodeManager();\r\n\r\n  public StartPos = new XmlCursorPos();\r\n  public EndPos = new XmlCursorPos();\r\n\r\n  /**\r\n   * is there nothing between start and end pos?\r\n   */\r\n  isEmptySelection(): boolean {\r\n    if (this.StartPos.equals(this.EndPos)) {\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  sortStartAndEnd() {\r\n    if (this.StartPos.ActualNode && this.EndPos.ActualNode) {\r\n      if (this.StartPos.ActualNode.isSameNode(this.EndPos.ActualNode)) {\r\n        if (\r\n          this.StartPos.PosAtNode === XMLCursorPositions.CursorInsideTextNode &&\r\n          this.EndPos.PosAtNode === XMLCursorPositions.CursorInsideTextNode &&\r\n          this.StartPos.PosInTextnode > this.EndPos.PosInTextnode\r\n        ) {\r\n          this.swapStartAndEnd();\r\n        }\r\n      } else {\r\n        const compared = this.StartPos.ActualNode.compareDocumentPosition(this.EndPos.ActualNode);\r\n        // tslint:disable-next-line:no-bitwise\r\n        if (!(compared & Node.DOCUMENT_POSITION_FOLLOWING)) {\r\n          this.swapStartAndEnd();\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  swapStartAndEnd() {\r\n    const node = this.StartPos.ActualNode;\r\n    const pos = this.StartPos.PosAtNode;\r\n    const text = this.StartPos.PosInTextnode;\r\n    this.StartPos.SetCursor(this.EndPos.ActualNode, this.EndPos.PosAtNode, this.EndPos.PosInTextnode);\r\n    this.EndPos.SetCursor(node, pos, text);\r\n  }\r\n\r\n  show() {\r\n    if (window.getSelection) {\r\n      const selection: Selection = window.getSelection();\r\n      this.show2(selection);\r\n    } else {\r\n      throw new Error('showCursor: unable to get \"window.getSelection\"');\r\n    }\r\n  }\r\n\r\n  private show2(selection: Selection) {\r\n    if (!selection) {\r\n      return;\r\n    }\r\n\r\n    // Remove all selected classes\r\n    const elems = document.querySelectorAll('.selected');\r\n    [].forEach.call(elems, function(el) {\r\n      el.classList.remove('selected');\r\n    });\r\n\r\n    const startSelection = XmlCursorPos.getSelectionForPos(this.StartPos);\r\n    if (this.EndPos && this.EndPos.ActualNode && !this.EndPos.equals(this.StartPos)) {\r\n      // start + end pos\r\n      const endSelection = XmlCursorPos.getSelectionForPos(this.EndPos);\r\n      selection.setBaseAndExtent(startSelection.node, startSelection.offset, endSelection.node, endSelection.offset);\r\n    } else {\r\n      // only start pos\r\n      selection.setPosition(startSelection.node, startSelection.offset);\r\n\r\n      // select tag by adding \"select\" class\r\n      if (this.StartPos.PosAtNode === XMLCursorPositions.CursorOnCompleteNode) {\r\n        const asElem = this.StartPos.ActualNode as Element;\r\n        if (asElem && asElem.classList) {\r\n          asElem.classList.add('selected');\r\n          console.log('selected!');\r\n        } else {\r\n          console.error(`no asElem.classList for select! ${XmlToolbox.GetNodeDebugContext(asElem)}`);\r\n        }\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\nexport interface SelectionPos {\r\n  node: Node;\r\n  offset: number;\r\n}\r\n","import { XmlCursorPos, XMLCursorPositions } from './xmlCursorPos.class';\r\nimport { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\nimport { XmlToolbox } from '../xmlToolbox.class';\r\nimport { XmlEditorDebugger } from '../xmlEditorDebugger';\r\n\r\nexport class XmlCursorPosSetter {\r\n  public static setFromSelection(pos: XmlCursorPos, selectionAnchorNode: Node, selectionAnchorOffset: number, debugLog: XmlEditorDebugger = null) {\r\n    if (selectionAnchorNode !== undefined && selectionAnchorNode !== null) {\r\n      let node = selectionAnchorNode as Element;\r\n      if (DomDummyNodeManager.IsDummyNode(selectionAnchorNode.parentElement)) {\r\n        // clicked inside a dummy node\r\n        node = selectionAnchorNode.parentElement as Element;\r\n\r\n        if (DomDummyNodeManager.IsBeforeFirstTagDummyNode(node)) {\r\n          switch (selectionAnchorOffset) {\r\n            case 0:\r\n              if (debugLog) {\r\n                debugLog.setInputSelection(`(1) cursor here: #<tag> pos 0`);\r\n              }\r\n              pos.SetCursor(node.parentElement, XMLCursorPositions.CursorOnCompleteNode, 0);\r\n              return;\r\n\r\n            case 1:\r\n              if (debugLog) {\r\n                debugLog.setInputSelection(`(2) cursor here: #<tag> pos 1`);\r\n              }\r\n              pos.SetCursor(node.parentElement, XMLCursorPositions.CursorInFrontOfNode, 0);\r\n              return;\r\n\r\n            default:\r\n              throw new Error(`selectionAnchorOffset=${selectionAnchorOffset}?!?`);\r\n          }\r\n        }\r\n\r\n        if (node.parentElement.childNodes.length === 2) {\r\n          if (debugLog) {\r\n            debugLog.setInputSelection(`(13, 14) cursor here: <tag>#</tag>`);\r\n          }\r\n          pos.SetCursor(node.parentElement, XMLCursorPositions.CursorInEmptyNode, 0);\r\n          return;\r\n        }\r\n\r\n        if (node === node.parentElement.lastChild && selectionAnchorOffset === 1) {\r\n          if (debugLog) {\r\n            debugLog.setInputSelection(`(8, 12) cursor here: #</tag>, selecting complete node`);\r\n          }\r\n          pos.SetCursor(node.parentElement, XMLCursorPositions.CursorOnCompleteNode, 0);\r\n          return;\r\n        }\r\n\r\n        const nextSibling = node.nextSibling;\r\n        if (nextSibling) {\r\n          if (debugLog) {\r\n            debugLog.setInputSelection(`(3, 4, 9, 10) cursor here: #Text or here #<tag>`);\r\n          }\r\n          pos.SetCursor(nextSibling, XMLCursorPositions.CursorInFrontOfNode, 0);\r\n          return;\r\n        }\r\n\r\n        const previousSibling = node.previousSibling;\r\n        if (previousSibling) {\r\n          if (debugLog) {\r\n            debugLog.setInputSelection(`(7, 11) cursor here: Text# or here <tag>#`);\r\n          }\r\n          pos.SetCursor(previousSibling, XMLCursorPositions.CursorBehindNode, 0);\r\n          return;\r\n        }\r\n      } else {\r\n        // is no dummy node\r\n        if (selectionAnchorNode.nodeType === Node.TEXT_NODE) {\r\n          if (selectionAnchorOffset === 0) {\r\n            if (debugLog) {\r\n              debugLog.setInputSelection(`(6) cursor here: #Text`);\r\n            }\r\n            pos.SetCursor(selectionAnchorNode, XMLCursorPositions.CursorInsideTextNode, 0);\r\n            return;\r\n          }\r\n\r\n          if (selectionAnchorOffset === selectionAnchorNode.textContent.length) {\r\n            if (debugLog) {\r\n              debugLog.setInputSelection(`(7 Alternative) cursor here: Text#`);\r\n            }\r\n            pos.SetCursor(selectionAnchorNode, XMLCursorPositions.CursorInsideTextNode, selectionAnchorNode.textContent.length);\r\n            return;\r\n          }\r\n\r\n          if (debugLog) {\r\n            debugLog.setInputSelection(`(5) cursor here: Text#Text`);\r\n          }\r\n          if (selectionAnchorOffset > selectionAnchorNode.textContent.length) {\r\n            throw new Error(\r\n              `selectionAnchorOffset ${selectionAnchorOffset} is > than text-lenght ${selectionAnchorNode.textContent.length} of text '${selectionAnchorNode.textContent}' `\r\n            );\r\n          }\r\n          pos.SetCursor(selectionAnchorNode, XMLCursorPositions.CursorInsideTextNode, selectionAnchorOffset);\r\n          return;\r\n        }\r\n      }\r\n\r\n      // if (DomDummyNodeManager.IsDummyNode(parentElem)) {\r\n      //     const dummyElement = parentElem;\r\n\r\n      //     const nextSibling = parentElem.nextSibling;\r\n      //     if (XmlToolbox.IstTextOderKommentarNode(nextSibling)) {\r\n      //         // cursor here: #text (# = red dummyNode)\r\n      //         pos.CursorSetzen(nextSibling, XMLCursorPositionen.CursorInnerhalbDesTextNodes, 0);\r\n      //         return;\r\n      //     }\r\n\r\n      //     const previousSibling = dummyElement.previousSibling;\r\n      //     if (!previousSibling) {\r\n      //     //    pos.CursorSetzen(dummyElement.parentElement, XMLCursorPositionen.c, 0);\r\n      //     }\r\n      // }\r\n\r\n      // switch (node.nodeType) {\r\n\r\n      //     case Node.TEXT_NODE:\r\n\r\n      // if (loopCount === 0) {\r\n      //     const nextSibling = parentElem.nextSibling;\r\n      //     if (nextSibling && nextSibling.nodeType === Node.TEXT_NODE && selectionAnchorOffset === 1) {\r\n      //         // set cursor at start of following textnode\r\n      //         pos.CursorSetzen(nextSibling, XMLCursorPositionen.CursorInnerhalbDesTextNodes, 0);\r\n      //     } else {\r\n      //         const previousSibling = parentElem.previousSibling;\r\n      //         if (previousSibling && previousSibling.nodeType === Node.TEXT_NODE && selectionAnchorOffset === 0) {\r\n      //             // set cursor at end of previous textnode\r\n      //             pos.CursorSetzen(previousSibling, XMLCursorPositionen.CursorInnerhalbDesTextNodes, previousSibling.nodeValue.length);\r\n      //         }\r\n      //     }\r\n      // } else {\r\n      //     node = parentElem; // up to dummy node\r\n      // }\r\n\r\n      //         } else {\r\n      //             pos.CursorSetzen(node, XMLCursorPositionen.CursorInnerhalbDesTextNodes, selectionAnchorOffset);\r\n      //         }\r\n      //         break;\r\n\r\n      //     case Node.ELEMENT_NODE:\r\n      //         if (DomDummyNodeManager.IsDummyNode(node)) {\r\n      //             // node = parentElem; // up to parent node\r\n      //         } else {\r\n      //             pos.CursorSetzen(node, XMLCursorPositionen.CursorAufNodeSelbstVorderesTag);\r\n      //         }\r\n      //         break;\r\n\r\n      //     default:\r\n      //         throw new Error(`unhandled nodeType '${node.nodeType}' of node ${XmlToolbox.GetNodeDebugContext(node)}`);\r\n      // }\r\n    }\r\n    console.error(\r\n      `found no suiting cursor interpretation! For selectionAnchorNode=${XmlToolbox.GetNodeDebugContext(selectionAnchorNode)}, selectionAnchorOffset=${selectionAnchorOffset}`\r\n    );\r\n  }\r\n}\r\n","import { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\nimport { XmlCursor } from '../cursor/xmlCursor.class';\r\nimport { XMLCursorPositions } from '../cursor/xmlCursorPos.class';\r\n\r\nexport class XmlDomCleaner {\r\n  public static cleanUp(node: Node, actualCursor: XmlCursor) {\r\n    this.concatTextNodes(node, actualCursor);\r\n  }\r\n\r\n  /***\r\n   * if two textnodes are direct siblings: concat to one textnode\r\n   */\r\n  public static concatTextNodes(node: Node, actualCursor: XmlCursor, nodeDepth = 0): void {\r\n    let restart = true;\r\n\r\n    while (restart === true) {\r\n      restart = false;\r\n\r\n      for (let i = 0; i < node.childNodes.length; ++i) {\r\n        const firstToCheck = node.childNodes[i];\r\n        if (DomDummyNodeManager.IsDummyNode(firstToCheck)) {\r\n          throw new Error('Dummynodes have to be removed before using XmlDomCleaner!');\r\n        }\r\n        if (firstToCheck.nodeType === Node.TEXT_NODE) {\r\n          const secondToCheck = firstToCheck.nextSibling;\r\n          if (secondToCheck !== null && secondToCheck.nodeType === Node.TEXT_NODE) {\r\n            // two text nodes after each other => concat\r\n            if (actualCursor.StartPos.ActualNode === secondToCheck) {\r\n              actualCursor.StartPos.SetCursor(firstToCheck, XMLCursorPositions.CursorInsideTextNode, firstToCheck.textContent.length + actualCursor.StartPos.PosInTextnode);\r\n            }\r\n            if (actualCursor.EndPos.ActualNode === secondToCheck) {\r\n              actualCursor.EndPos.SetCursor(firstToCheck, XMLCursorPositions.CursorInsideTextNode, firstToCheck.textContent.length + actualCursor.EndPos.PosInTextnode);\r\n            }\r\n            firstToCheck.textContent = firstToCheck.textContent + secondToCheck.textContent;\r\n            node.removeChild(secondToCheck);\r\n            restart = true;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    // update child nodes\r\n    for (let i = 0; i < node.childNodes.length; ++i) {\r\n      this.concatTextNodes(node.childNodes[i], actualCursor, nodeDepth + 1);\r\n    }\r\n  }\r\n}\r\n","import { XmlRules } from '../xml-rules-check/xmlRules.class';\r\nimport { XmlCursorPos, XMLCursorPositions } from '../cursor/xmlCursorPos.class';\r\nimport { XmlCursorPosMover } from '../cursor/xmlCursorPosMover.class';\r\nimport { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\nimport { XmlCursor } from '../cursor/xmlCursor.class';\r\n\r\nexport class XmlEditDelete {\r\n  public static deleteSelection(cursor: XmlCursor, rootNode: Element, xmlRules: XmlRules): boolean {\r\n    return true;\r\n  }\r\n\r\n  public static deleteAfter(pos: XmlCursorPos, rootNode: Element, xmlRules: XmlRules): boolean {\r\n    if (pos === undefined) {\r\n      return false;\r\n    }\r\n\r\n    switch (pos.PosAtNode) {\r\n      case XMLCursorPositions.CursorOnCompleteNode:\r\n        return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);\r\n\r\n      case XMLCursorPositions.CursorBehindNode:\r\n      case XMLCursorPositions.CursorInFrontOfNode:\r\n        XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);\r\n        return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);\r\n\r\n      case XMLCursorPositions.CursorInEmptyNode:\r\n        return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);\r\n\r\n      case XMLCursorPositions.CursorInsideTextNode:\r\n        XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);\r\n        return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);\r\n\r\n      default:\r\n        throw new Error(`String.Format(\"XmlCursorEdit.deleteBefore: unknown CursorPos ${pos.PosAtNode}`);\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  public static deleteBefore(pos: XmlCursorPos, rootNode: Element, xmlRules: XmlRules): boolean {\r\n    let deleteNode: Node;\r\n\r\n    // console.log(pos.getDebugDescription());\r\n\r\n    if (pos === undefined) {\r\n      return false;\r\n    }\r\n    switch (pos.PosAtNode) {\r\n      case XMLCursorPositions.CursorOnCompleteNode:\r\n        deleteNode = pos.ActualNode;\r\n        XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);\r\n        deleteNode.parentElement.removeChild(deleteNode);\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorBehindNode:\r\n        if (pos.ActualNode.nodeType === Node.TEXT_NODE) {\r\n          pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, pos.ActualNode.textContent.length);\r\n          return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);\r\n        } else {\r\n          pos.ActualNode.parentElement.removeChild(pos.ActualNode);\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInEmptyNode:\r\n        deleteNode = pos.ActualNode;\r\n        XmlCursorPosMover.moveRight(pos, rootNode, xmlRules);\r\n        deleteNode.parentElement.removeChild(deleteNode);\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInFrontOfNode:\r\n        deleteNode = DomDummyNodeManager.getPreviousSibling(pos.ActualNode);\r\n        if (!deleteNode) {\r\n          deleteNode = pos.ActualNode.parentElement;\r\n        }\r\n        if (deleteNode) {\r\n          if (deleteNode.nodeType === Node.TEXT_NODE) {\r\n            pos.SetCursor(deleteNode, XMLCursorPositions.CursorInsideTextNode, deleteNode.textContent.length);\r\n            return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);\r\n          } else {\r\n            deleteNode.parentElement.removeChild(deleteNode);\r\n          }\r\n        }\r\n        break;\r\n\r\n      case XMLCursorPositions.CursorInsideTextNode:\r\n        if (pos.PosInTextnode === 0) {\r\n          pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInFrontOfNode, 0);\r\n          return XmlEditDelete.deleteBefore(pos, rootNode, xmlRules);\r\n        } else {\r\n          let text = pos.ActualNode.textContent;\r\n          text = text.substring(0, pos.PosInTextnode - 1) + text.substr(pos.PosInTextnode, pos.ActualNode.textContent.length);\r\n          pos.ActualNode.textContent = text;\r\n          XmlCursorPosMover.moveLeft(pos, rootNode, xmlRules);\r\n          // pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, pos.PosInTextnode - 1);\r\n        }\r\n        break;\r\n\r\n      default:\r\n        throw new Error(`String.Format(\"XmlEdit.deleteBefore: unknown CursorPos ${pos.PosAtNode}`);\r\n    }\r\n\r\n    return true;\r\n  }\r\n}\r\n","import { XmlCursorPos, XMLCursorPositions } from '../cursor/xmlCursorPos.class';\r\nimport { Xml2html } from '../xml-html-converter/xml2html.class';\r\n\r\nexport class XmlEditRuleCheckTextInsert {\r\n  namespacePraefix = 'xs:';\r\n\r\n  constructor(private xsdNodes: Map<string, Element>) {}\r\n\r\n  isTextAllowedAtThisCursorPos(cursorPosToCheck: XmlCursorPos): boolean {\r\n    if (!cursorPosToCheck) {\r\n      return false;\r\n    }\r\n    const parentNode = this.getRelevantParentNodeForCursorPos(cursorPosToCheck);\r\n    const parentName = Xml2html.getTagNameFromNode(parentNode);\r\n    const xsdNode = this.xsdNodes.get(parentName);\r\n    if (xsdNode) {\r\n      const result = this.isTextAllowedInThisElement(xsdNode);\r\n      return result;\r\n    } else {\r\n      return false; // element not found\r\n    }\r\n  }\r\n\r\n  getRelevantParentNodeForCursorPos(cursorPosToCheck: XmlCursorPos): Node {\r\n    if (cursorPosToCheck) {\r\n      let parentNode = cursorPosToCheck.ActualNode;\r\n\r\n      switch (parentNode.nodeType) {\r\n        case Node.COMMENT_NODE:\r\n        case Node.TEXT_NODE:\r\n          parentNode = parentNode.parentElement;\r\n          break;\r\n\r\n        case Node.ELEMENT_NODE:\r\n          switch (cursorPosToCheck.PosAtNode) {\r\n            case XMLCursorPositions.CursorInEmptyNode:\r\n            case XMLCursorPositions.CursorInsideTextNode:\r\n              break;\r\n\r\n            case XMLCursorPositions.CursorBehindNode:\r\n            case XMLCursorPositions.CursorInFrontOfNode:\r\n            case XMLCursorPositions.CursorOnCompleteNode:\r\n              parentNode = parentNode.parentElement;\r\n              break;\r\n\r\n            default:\r\n              throw new Error(`unhandled  cursorPosToCheck.PosAmNode \"${cursorPosToCheck.PosAtNode}\"/${XmlCursorPos.getXmlCursorPositionDebugName(cursorPosToCheck.PosAtNode)}\" `);\r\n          }\r\n          break;\r\n\r\n        default:\r\n          throw new Error(`unhandled  parentNode.nodeType \"${parentNode.nodeType}\"`);\r\n      }\r\n      return parentNode;\r\n    }\r\n  }\r\n\r\n  isTextAllowedInThisElement(xsdNode: Node, alreadyAddedElementNames: Set<string> = new Set<string>()): boolean {\r\n    let elementName: string;\r\n\r\n    if (xsdNode.nodeType === Node.ELEMENT_NODE) {\r\n      const asElem = xsdNode as Element;\r\n      if (asElem) {\r\n        const mixedAttrib = asElem.getAttribute('mixed');\r\n        if (mixedAttrib) {\r\n          return true;\r\n        }\r\n        const typeAttrib = asElem.getAttribute('type');\r\n        if (typeAttrib && typeAttrib === `${this.namespacePraefix}string`) {\r\n          return true;\r\n        }\r\n\r\n        if (asElem.localName === 'element') {\r\n          elementName = asElem.getAttribute('name');\r\n          if (elementName) {\r\n            if (alreadyAddedElementNames.has(elementName)) {\r\n              return false; // element recursion detected\r\n            }\r\n          }\r\n          alreadyAddedElementNames.add(elementName);\r\n        }\r\n      }\r\n    }\r\n\r\n    const childNodes = Array.prototype.slice.call(xsdNode.childNodes) as Node[];\r\n\r\n    let allowed = false;\r\n\r\n    childNodes.forEach(child => {\r\n      if (child.nodeType === Node.ELEMENT_NODE) {\r\n        const childElem = child as Element;\r\n        if (childElem) {\r\n          switch (childElem.localName) {\r\n            case 'complexType':\r\n            case 'sequence':\r\n            case 'choice':\r\n            case 'simpleContent':\r\n            case 'extension':\r\n              if (this.isTextAllowedInThisElement(child, alreadyAddedElementNames) === true) {\r\n                allowed = true;\r\n                break;\r\n              }\r\n              break;\r\n\r\n            case 'element':\r\n              const refname = childElem.attributes.getNamedItem('ref');\r\n              if (refname) {\r\n                const referedNode = this.xsdNodes.get(refname.value);\r\n                if (referedNode) {\r\n                  if (this.isTextAllowedInThisElement(referedNode, alreadyAddedElementNames) === true) {\r\n                    allowed = true;\r\n                    break;\r\n                  }\r\n                } else {\r\n                  throw new Error(` refered element \"${refname}\" for element \"${childElem.outerHTML}\" not found`);\r\n                }\r\n              }\r\n              break;\r\n\r\n            case 'attribute':\r\n              break;\r\n\r\n            default:\r\n              alert('unknown childElem.localname \"' + childElem.localName + '\"/' + childElem.outerHTML);\r\n          }\r\n        }\r\n      }\r\n    });\r\n\r\n    return allowed;\r\n  }\r\n}\r\n","import { XmlCursorPos, XMLCursorPositions } from '../cursor/xmlCursorPos.class';\r\nimport { XmlRules } from '../xml-rules-check/xmlRules.class';\r\nimport { XmlEditRuleCheckTextInsert } from '../xml-rules-check/xmlEditRuleCheckTextInsert.class';\r\nimport { XmlSchema } from '../xml-rules-check/xmlSchema.class';\r\nimport { XmlEditDelete } from './xmlEditDeleteclass';\r\nimport { XmlCursor } from '../cursor/xmlCursor.class';\r\nimport { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\n\r\nexport class XmlEditInsert {\r\n  public static replaceWithText(pos: XmlCursor, value: string, rootNode: Element, xmlRules: XmlRules, xmlSchema: XmlSchema): boolean {\r\n    if (pos === undefined) {\r\n      return false;\r\n    }\r\n    if (value === '' || value === undefined || value == null) {\r\n      return false;\r\n    }\r\n\r\n    if (pos.isEmptySelection() === false) {\r\n      if (XmlEditDelete.deleteSelection(pos, rootNode, xmlRules) === false) {\r\n        return false;\r\n      }\r\n    }\r\n\r\n    return XmlEditInsert.insertText(pos.EndPos, value, rootNode, xmlRules, xmlSchema);\r\n  }\r\n\r\n  public static insertText(pos: XmlCursorPos, value: string, rootNode: Element, xmlRules: XmlRules, xmlSchema: XmlSchema): boolean {\r\n    if (pos === undefined) {\r\n      return false;\r\n    }\r\n\r\n    if (value === '' || value === undefined || value == null) {\r\n      return false;\r\n    }\r\n\r\n    switch (pos.PosAtNode) {\r\n      case XMLCursorPositions.CursorOnCompleteNode:\r\n        let textAllowed = XmlEditInsert.isTextAllowedInParentNode(pos, xmlSchema);\r\n        if (textAllowed === true) {\r\n          const newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);\r\n          pos.ActualNode.parentElement.insertBefore(newTextNode, pos.ActualNode);\r\n          pos.ActualNode.parentElement.removeChild(pos.ActualNode);\r\n          const nextSibling = DomDummyNodeManager.getNextSibling(newTextNode);\r\n          if (nextSibling) {\r\n            pos.SetCursor(nextSibling, XMLCursorPositions.CursorInFrontOfNode);\r\n          } else {\r\n            pos.SetCursor(newTextNode, XMLCursorPositions.CursorBehindNode);\r\n          }\r\n          return true;\r\n        } else {\r\n          return false;\r\n        }\r\n\r\n      case XMLCursorPositions.CursorBehindNode:\r\n        if (pos.ActualNode.nodeType === Node.TEXT_NODE) {\r\n          pos.ActualNode.textContent = pos.ActualNode.textContent + value;\r\n          return true;\r\n        } else {\r\n          textAllowed = XmlEditInsert.isTextAllowedInParentNode(pos, xmlSchema);\r\n          if (textAllowed === true) {\r\n            const newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);\r\n            pos.ActualNode.parentElement.insertBefore(newTextNode, pos.ActualNode.nextSibling); // inserts the new node after the actual node\r\n            return true;\r\n          } else {\r\n            return false;\r\n          }\r\n        }\r\n\r\n      case XMLCursorPositions.CursorInFrontOfNode:\r\n        if (pos.ActualNode.nodeType === Node.TEXT_NODE) {\r\n          pos.ActualNode.textContent = value + pos.ActualNode.textContent;\r\n          return true;\r\n        } else {\r\n          textAllowed = XmlEditInsert.isTextAllowedInParentNode(pos, xmlSchema);\r\n          if (textAllowed === true) {\r\n            const newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);\r\n            pos.ActualNode.parentElement.insertBefore(newTextNode, pos.ActualNode);\r\n            return true;\r\n          } else {\r\n            return false;\r\n          }\r\n        }\r\n\r\n      case XMLCursorPositions.CursorInEmptyNode:\r\n        textAllowed = new XmlEditRuleCheckTextInsert(xmlSchema.xsdNodes).isTextAllowedAtThisCursorPos(pos);\r\n        if (textAllowed === true) {\r\n          const newTextNode = pos.ActualNode.ownerDocument.createTextNode(value);\r\n          pos.ActualNode.appendChild(newTextNode);\r\n          return true;\r\n        } else {\r\n          return false;\r\n        }\r\n\r\n      case XMLCursorPositions.CursorInsideTextNode:\r\n        const text = pos.ActualNode.textContent;\r\n        pos.ActualNode.textContent = text.substr(0, pos.PosInTextnode) + value + text.substr(pos.PosInTextnode, text.length);\r\n        pos.SetCursor(pos.ActualNode, XMLCursorPositions.CursorInsideTextNode, pos.PosInTextnode + 1);\r\n        break;\r\n\r\n      default:\r\n        throw new Error(`String.Format(\"XmlEditInsert.insert: unknown CursorPos  ${pos.getDebugDescription()}`);\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  private static isTextAllowedInParentNode(pos: XmlCursorPos, xmlSchema: XmlSchema): boolean {\r\n    const parentNode = pos.ActualNode.parentElement;\r\n    const parentCursorPos = pos.clone();\r\n    parentCursorPos.SetCursor(parentNode, XMLCursorPositions.CursorInEmptyNode);\r\n    return new XmlEditRuleCheckTextInsert(xmlSchema.xsdNodes).isTextAllowedAtThisCursorPos(parentCursorPos);\r\n  }\r\n}\r\n","import { Subject } from 'rxjs';\r\nimport { XmlRuleElement } from './xml-rules-check/xmlRuleElement.class';\r\nimport { XmlEditorConfig } from './xmlEditorConfig';\r\nimport { XmlEditorDebugger } from './xmlEditorDebugger';\r\nimport { XmlCursorPosMover } from './cursor/xmlCursorPosMover.class';\r\nimport { XmlCursor } from './cursor/xmlCursor.class';\r\nimport { OnDestroy } from '@angular/core';\r\nimport { XmlCursorPosSetter } from './cursor/xmlCursorPosSetter.class';\r\nimport { DomDummyNodeManager } from './dummyNodes/domDummyNodeManager.class';\r\nimport { XmlDomCleaner } from './xml-editing/xmlDomCleaner.class';\r\nimport { XmlEditDelete } from './xml-editing/xmlEditDeleteclass';\r\nimport { Xml2html } from './xml-html-converter/xml2html.class';\r\nimport { TouchSequence } from 'selenium-webdriver';\r\nimport { XmlEditInsert } from './xml-editing/xmlEditInsert.class';\r\nimport { debug } from 'util';\r\n\r\nexport class XmlEditorContext implements OnDestroy {\r\n  public debugService: XmlEditorDebugger;\r\n  public config: XmlEditorConfig;\r\n\r\n  actualCursorChanged: Subject<XmlCursor>;\r\n  actualCursor = new XmlCursor();\r\n  dummyNodeManager = new DomDummyNodeManager();\r\n\r\n  savedSelection: Range | null;\r\n  selectedText: string;\r\n\r\n  keyCtrlIsDown: boolean;\r\n  keyShiftIsDown: boolean;\r\n\r\n  constructor(private _document: Document) {\r\n    this.actualCursorChanged = new Subject<XmlCursor>();\r\n    this.debugService = new XmlEditorDebugger();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.actualCursorChanged.unsubscribe();\r\n  }\r\n\r\n  setCursorPos(cursorPos: XmlCursor) {\r\n    this.actualCursor = cursorPos;\r\n    this.actualCursorChanged.next(cursorPos);\r\n    this.debugService.setActualCursorPos(cursorPos);\r\n  }\r\n\r\n  // /**\r\n  //   * Executed command from editor header buttons\r\n  //   * @param command string from triggerCommand\r\n  //   */\r\n  // executeCommand(command: string) {\r\n  //   if (command !== '') {\r\n  //     this.commander.executeCommand(command);\r\n  //     this.exec();\r\n  //   }\r\n  //   this.onEditorFocus();\r\n  //   const cleanUpFirst = false;\r\n  //   this.domDummyNodeManager.UpdateDummyNodes(this.xmlDocumentRootNode, cleanUpFirst);\r\n  //   return;\r\n  // }\r\n\r\n  mouseUp(mouseEvent: MouseEvent) {\r\n    if (window.getSelection) {\r\n      let userSelection: Selection;\r\n      userSelection = window.getSelection();\r\n      XmlCursorPosSetter.setFromSelection(this.actualCursor.StartPos, userSelection.anchorNode, userSelection.anchorOffset, this.debugService);\r\n      XmlCursorPosSetter.setFromSelection(this.actualCursor.EndPos, userSelection.focusNode, userSelection.focusOffset, this.debugService);\r\n      this.setCursorPos(this.actualCursor);\r\n      this.actualCursor.sortStartAndEnd();\r\n      this.actualCursor.show();\r\n    } else {\r\n      throw new Error(`can't get window.getSelection, target=${JSON.stringify(mouseEvent.target)}`);\r\n    }\r\n  }\r\n\r\n  keyDown(event: KeyboardEvent): boolean {\r\n    console.log('keydown! key:' + event.key + ' / code:' + event.code);\r\n\r\n    switch (event.key) {\r\n      case 'Control':\r\n        this.keyCtrlIsDown = true;\r\n        break;\r\n\r\n      case 'Shift':\r\n        this.keyShiftIsDown = true;\r\n        break;\r\n\r\n      case 'c':\r\n        if (this.keyCtrlIsDown) {\r\n          // Copy\r\n          return false;\r\n        } else {\r\n          if (this.insertText('c')) {\r\n            return false;\r\n          }\r\n        }\r\n        break;\r\n\r\n      case 'ArrowUp':\r\n      case 'ArrowDown':\r\n        return true;\r\n\r\n      case 'ArrowRight':\r\n        if (this.keyShiftIsDown) {\r\n          XmlCursorPosMover.moveRight(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n        } else {\r\n          XmlCursorPosMover.moveRight(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n          this.actualCursor.StartPos.SetCursor(this.actualCursor.EndPos.ActualNode, this.actualCursor.EndPos.PosAtNode, this.actualCursor.EndPos.PosInTextnode);\r\n        }\r\n        this.actualCursor.sortStartAndEnd();\r\n        this.actualCursor.show();\r\n        this.setCursorPos(this.actualCursor);\r\n        return false;\r\n\r\n      case 'ArrowLeft':\r\n        if (this.keyShiftIsDown) {\r\n          XmlCursorPosMover.moveLeft(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n        } else {\r\n          XmlCursorPosMover.moveLeft(this.actualCursor.StartPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n          this.actualCursor.EndPos.SetCursor(this.actualCursor.StartPos.ActualNode, this.actualCursor.StartPos.PosAtNode, this.actualCursor.StartPos.PosInTextnode);\r\n        }\r\n        this.actualCursor.sortStartAndEnd();\r\n        this.actualCursor.show();\r\n        this.setCursorPos(this.actualCursor);\r\n        return false;\r\n\r\n      case 'Backspace':\r\n        if (this.actualCursor.isEmptySelection()) {\r\n          XmlEditDelete.deleteBefore(this.actualCursor.StartPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n        } else {\r\n          XmlEditDelete.deleteSelection(this.actualCursor, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n        }\r\n        this.actualCursor.EndPos.SetCursor(this.actualCursor.StartPos.ActualNode, this.actualCursor.StartPos.PosAtNode, this.actualCursor.StartPos.PosInTextnode);\r\n        this.cleanUpAndUpdateDummyElements();\r\n        this.actualCursor.show();\r\n        return false;\r\n\r\n      case 'Delete':\r\n        if (this.actualCursor.isEmptySelection()) {\r\n          XmlEditDelete.deleteAfter(this.actualCursor.StartPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n        } else {\r\n          XmlEditDelete.deleteSelection(this.actualCursor, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n        }\r\n        this.cleanUpAndUpdateDummyElements();\r\n        this.actualCursor.show();\r\n        return false;\r\n\r\n      case 'Enter':\r\n        return false;\r\n\r\n      default:\r\n        const textInsert = event.key;\r\n        if (this.insertText(textInsert)) {\r\n          return false;\r\n        }\r\n        break;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  keyUp(event: KeyboardEvent): boolean {\r\n    switch (event.key) {\r\n      case 'Control':\r\n        this.keyCtrlIsDown = false;\r\n        break;\r\n      case 'Shift':\r\n        this.actualCursor.sortStartAndEnd();\r\n        this.keyShiftIsDown = false;\r\n        break;\r\n\r\n      case 'ArrowLeft':\r\n      case 'ArrowRight':\r\n        this.actualCursor.show();\r\n        break;\r\n\r\n      case 'ArrowUp':\r\n      case 'ArrowDown':\r\n      case 'Backspace':\r\n      case 'Delete':\r\n      case 'Enter':\r\n      case 'Control':\r\n      case 'Shift':\r\n        break;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  pasted(text: string): boolean {\r\n    alert('pasted: ' + text);\r\n    return false;\r\n  }\r\n\r\n  copied(): boolean {\r\n    alert('copied');\r\n    return false;\r\n  }\r\n\r\n  insertText(value: string): boolean {\r\n    if (value === '' || value === null || value === undefined) {\r\n      return true;\r\n    }\r\n\r\n    let inserted = false;\r\n\r\n    if (this.actualCursor.isEmptySelection()) {\r\n      inserted = XmlEditInsert.insertText(this.actualCursor.EndPos, value, this.actualCursor.xmlDocumentRootNode, this.config.rules, this.config.xmlSchema);\r\n    } else {\r\n      inserted = XmlEditInsert.replaceWithText(this.actualCursor, value, this.actualCursor.xmlDocumentRootNode, this.config.rules, this.config.xmlSchema);\r\n    }\r\n\r\n    if (inserted) {\r\n      // character inserted -> move cursor right\r\n      // for (let index = 0; index < value.length; index++) {\r\n      //   XmlCursorPosMover.moveRight(this.actualCursor.EndPos, this.actualCursor.xmlDocumentRootNode, this.config.rules);\r\n      // }\r\n      this.actualCursor.StartPos.SetCursor(this.actualCursor.EndPos.ActualNode, this.actualCursor.EndPos.PosAtNode, this.actualCursor.EndPos.PosInTextnode);\r\n      this.cleanUpAndUpdateDummyElements();\r\n      this.actualCursor.show();\r\n      console.warn('text inserted!');\r\n      return true;\r\n    } else {\r\n      console.warn('text NOT inserted!');\r\n      return false;\r\n    }\r\n  }\r\n\r\n  /** inserts a new element at the actual cursor pos */\r\n  insertElement(element: XmlRuleElement) {\r\n    const html = new Xml2html(this.config.rules).createNewElementHtml(element);\r\n    this.domInsertHtml(html);\r\n    this.cleanUpAndUpdateDummyElements();\r\n    // this.actualCursor.show();\r\n    console.warn('element inserted!');\r\n  }\r\n\r\n  /**\r\n   * Create raw HTML\r\n   * @param html HTML string\r\n   */\r\n  public domInsertHtml(html: string): void {\r\n    if (document.getSelection) {\r\n      const range = document.getSelection().getRangeAt(0);\r\n      range.insertNode(range.createContextualFragment(html));\r\n    } else {\r\n      throw new Error('document.getSelection not defined!');\r\n    }\r\n    this.cleanUpAndUpdateDummyElements();\r\n    this.actualCursor.show();\r\n  }\r\n\r\n  /**\r\n   * save selection when the editor is focussed out\r\n   */\r\n  saveSelection(): any {\r\n    if (window.getSelection) {\r\n      const sel = window.getSelection();\r\n      if (sel.getRangeAt && sel.rangeCount) {\r\n        this.savedSelection = sel.getRangeAt(0);\r\n        this.selectedText = sel.toString();\r\n      }\r\n    } else if (this._document.getSelection && this._document.createRange) {\r\n      this.savedSelection = document.createRange();\r\n    } else {\r\n      this.savedSelection = null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * restore selection when the editor is focussed in\r\n   */\r\n  restoreSelection(): boolean {\r\n    if (this.savedSelection) {\r\n      if (window.getSelection) {\r\n        const sel = window.getSelection();\r\n        sel.removeAllRanges();\r\n        sel.addRange(this.savedSelection);\r\n        return true;\r\n      } else if (this._document.getSelection /*&& this.savedSelection.select*/) {\r\n        // this.savedSelection.select();\r\n        return true;\r\n      }\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  cleanUpAndUpdateDummyElements() {\r\n    this.dummyNodeManager.RemoveAllDummyNodes(this.actualCursor.xmlDocumentRootNode);\r\n    XmlDomCleaner.cleanUp(this.actualCursor.xmlDocumentRootNode, this.actualCursor);\r\n    this.dummyNodeManager.UpdateDummyNodes(this.actualCursor.xmlDocumentRootNode);\r\n    this.actualCursor.sortStartAndEnd();\r\n  }\r\n\r\n  // /** check any slection is made or not */\r\n  // private checkSelection(): any {\r\n  //   const slectedText = this.savedSelection.toString();\r\n\r\n  //   if (slectedText.length === 0) {\r\n  //     throw new Error('No Selection Made');\r\n  //   }\r\n\r\n  //   return true;\r\n  // }\r\n\r\n  // setDefaultParagraphSeparator(separator: string) {\r\n  //   this._document.execCommand('defaultParagraphSeparator', false, separator);\r\n  // }\r\n}\r\n","import { Injectable, Inject } from '@angular/core';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport { XmlEditorContext } from './code/xmlEditorContext.class';\r\n\r\n/** @dynamic */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AngularXmlEditorService {\r\n  private contexts = new Map<string, XmlEditorContext>();\r\n\r\n  constructor(@Inject(DOCUMENT) private _document: Document) {}\r\n\r\n  getNewEditorContextId(): string {\r\n    let no = 0;\r\n    while (this.contexts.has(no.toString())) {\r\n      no++;\r\n    }\r\n    return no.toString();\r\n  }\r\n\r\n  getEditorContext(contextId: string): XmlEditorContext {\r\n    let context = this.contexts.get(contextId);\r\n    if (context === undefined) {\r\n      context = new XmlEditorContext(this._document);\r\n      this.contexts.set(contextId, context);\r\n    }\r\n    return context;\r\n  }\r\n\r\n  disposeEditorContext(contextId: string) {\r\n    this.contexts.delete(contextId);\r\n  }\r\n}\r\n","import { XmlRules } from '../xml-rules-check/xmlRules.class';\r\nimport { Xml2html } from './xml2html.class';\r\nimport { XmlToolbox } from '../xmlToolbox.class';\r\nimport { Xml2htmlAttributeWorker } from './xml2htmlAttributeWorker.class';\r\nimport { DomDummyNodeManager } from '../dummyNodes/domDummyNodeManager.class';\r\n\r\nexport class Html2xml {\r\n  private attributeWorker: Xml2htmlAttributeWorker;\r\n\r\n  constructor(public rules: XmlRules) {\r\n    this.attributeWorker = new Xml2htmlAttributeWorker(rules);\r\n  }\r\n\r\n  public ToXml(html: string): string {\r\n    if (html === '') {\r\n      return '';\r\n    }\r\n    // html = html.replace('\\t', '');\r\n    // html = html.replace('\\r', '');\r\n    // html = html.replace('\\n', '');\r\n\r\n    const cleanHtml = this.CleanUpHtmlBeforeConvert2Xml(html);\r\n    const domparser = new DOMParser();\r\n    const domdoc = domparser.parseFromString(cleanHtml, 'text/xml');\r\n    const targetDocument = new Document();\r\n    if (domdoc.documentElement === null) {\r\n      return '';\r\n    }\r\n\r\n    const body = this.GetXmlElementFromHtmlElement(domdoc.documentElement, targetDocument);\r\n    if (body && body.nodeType === Node.ELEMENT_NODE) {\r\n      const xml = (body as Element).outerHTML;\r\n      return xml;\r\n    } else {\r\n      throw new Error(`root node ${XmlToolbox.GetNodeDebugContext(body)} is no element`);\r\n    }\r\n  }\r\n\r\n  private CleanUpHtmlBeforeConvert2Xml(html: string): string {\r\n    const domparser = new DOMParser();\r\n    const domdoc = domparser.parseFromString(html, 'text/html');\r\n    new DomDummyNodeManager().RemoveAllDummyNodes(domdoc.documentElement); // remove all dummy nodes\r\n    const cleanHtml = domdoc.body.innerHTML;\r\n    return cleanHtml;\r\n  }\r\n\r\n  private GetXmlElementFromHtmlElement(node: Node, targetDocument: Document): Node {\r\n    switch (node.nodeType) {\r\n      case Node.ELEMENT_NODE: // element node\r\n        const asElement = node as Element;\r\n        const tagName = Xml2html.getTagNameFromNode(node);\r\n\r\n        if (!tagName || tagName === '') {\r\n          throw new Error(`no tagname in ${XmlToolbox.GetNodeDebugContext(node)}`);\r\n        }\r\n\r\n        // create element node\r\n        const newElement = targetDocument.createElement(tagName);\r\n\r\n        // append child elements recursive\r\n        const children = asElement.childNodes;\r\n        if (children.length === 0 && !asElement.classList.contains(Xml2html.NoClosingTagClassName)) {\r\n          newElement.appendChild(targetDocument.createTextNode('')); // to prevent non closing tags\r\n        } else {\r\n          for (let i = 0; i < children.length; ++i) {\r\n            const childAsHtml = this.GetXmlElementFromHtmlElement(children[i], targetDocument);\r\n            if (childAsHtml !== undefined) {\r\n              newElement.appendChild(childAsHtml);\r\n            }\r\n          }\r\n        }\r\n\r\n        // // insert attributes\r\n        this.attributeWorker.writeAllHtmlAttributesToXml(asElement, newElement);\r\n\r\n        return newElement;\r\n\r\n      case Node.TEXT_NODE: // text node\r\n        const content = (node as Element).textContent;\r\n        if (content.length > 0) {\r\n          return targetDocument.createTextNode(content);\r\n        } else {\r\n          return undefined;\r\n        }\r\n\r\n      default:\r\n        // tslint:disable-next-line:max-line-length\r\n        throw new Error(`unknown html element nodeType ${node.nodeType} in value: ${XmlToolbox.GetNodeDebugContext(node)}`);\r\n    }\r\n  }\r\n}\r\n","import { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\r\nimport { XmlEditorConfig } from './code/xmlEditorConfig';\r\nimport { XMLCursorPositions } from './code/cursor/xmlCursorPos.class';\r\nimport { DomDummyNodeManager } from './code/dummyNodes/domDummyNodeManager.class';\r\nimport { Component, OnChanges, Input, ViewChild, Output, EventEmitter, Renderer2, forwardRef, ViewEncapsulation, OnDestroy, ElementRef } from '@angular/core';\r\nimport { AngularXmlEditorService } from './angular-xml-editor.service';\r\nimport { XmlEditorContext } from './code/xmlEditorContext.class';\r\nimport { Xml2html } from './code/xml-html-converter/xml2html.class';\r\nimport { Html2xml } from './code/xml-html-converter/html2xml.class';\r\nimport { DebugContext } from '@angular/core/src/view';\r\n\r\n@Component({\r\n  selector: 'axed-editor',\r\n  templateUrl: './angular-xml-editor.component.html',\r\n  styleUrls: ['./angular-xml-editor.component.scss'],\r\n  encapsulation: ViewEncapsulation.None, // to prevent the scss to rename the class names and not match the new generated xml dom\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => AngularXmlEditorComponent),\r\n      multi: true\r\n    }\r\n  ]\r\n})\r\nexport class AngularXmlEditorComponent implements ControlValueAccessor, OnChanges, OnDestroy {\r\n  private editorContext: XmlEditorContext;\r\n  isDebugMode = false;\r\n\r\n  @Input('config')\r\n  get config(): XmlEditorConfig {\r\n    if (this.editorContext !== undefined && this.editorContext.config !== undefined) {\r\n      return this.editorContext && this.editorContext.config;\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  @Input('editorContextId')\r\n  set editorContextId(value: string) {\r\n    if (!value) {\r\n      return;\r\n    }\r\n    this.editorContext = this.editorService.getEditorContext(value);\r\n  }\r\n\r\n  @Input('debugMode')\r\n  set debugMode(value: boolean) {\r\n    this.isDebugMode = value;\r\n  }\r\n\r\n  @ViewChild('editor')\r\n  textArea: ElementRef;\r\n  @ViewChild('editorWrapper')\r\n  editorWrapper: ElementRef;\r\n\r\n  @Output()\r\n  public valueChange = new EventEmitter();\r\n\r\n  // actualXmlCursor: XmlCursor = new XmlCursor();\r\n  domDummyNodeManager = new DomDummyNodeManager();\r\n\r\n  private onTouchedFunction: () => void;\r\n  private onChangeFunction: (value: string) => void;\r\n\r\n  constructor(private _renderer: Renderer2, private editorService: AngularXmlEditorService) {}\r\n\r\n  ngOnChanges() {}\r\n\r\n  ngOnDestroy(): void {}\r\n\r\n  onLostFocus() {\r\n    this.editorContext.saveSelection(); // save selection on lost focus\r\n    if (typeof this.onTouchedFunction === 'function') {\r\n      this.onTouchedFunction();\r\n    }\r\n    return;\r\n  }\r\n\r\n  onGotFocus() {\r\n    this.editorContext.restoreSelection();\r\n    this.textArea.nativeElement.focus(); // set focus to the text area\r\n  }\r\n\r\n  clicked() {}\r\n\r\n  mousedown() {}\r\n\r\n  mouseup(mouseEvent: MouseEvent) {\r\n    return this.editorContext.mouseUp(mouseEvent);\r\n  }\r\n\r\n  pasted(text: string): boolean {\r\n    return this.editorContext.pasted(text);\r\n  }\r\n\r\n  copied(): boolean {\r\n    return this.editorContext.copied();\r\n  }\r\n\r\n  keyDown(event: KeyboardEvent): boolean {\r\n    return this.editorContext.keyDown(event);\r\n  }\r\n\r\n  keyUp(event: KeyboardEvent): boolean {\r\n    return this.editorContext.keyUp(event);\r\n  }\r\n\r\n  // exec(): boolean {\r\n  //   let userSelection: Selection;\r\n  //   if (window.getSelection) {\r\n  //     userSelection = window.getSelection();\r\n  //     this.editorBreadCrumb.showSelection(userSelection);\r\n  //     this.actualXmlCursor.StartPos.SetCursor(userSelection.anchorNode, XMLCursorPositionen.CursorInsideTextNode, userSelection.anchorOffset);\r\n  //     this.commander.setCursorPos(this.actualXmlCursor.StartPos);\r\n  //   }\r\n\r\n  //   this.domDummyNodeManager.UpdateDummyNodes(this.actualXmlCursor.xmlDocumentRootNode, false);\r\n\r\n  //   return false;\r\n  // }\r\n\r\n  showXml(xml: string): void {\r\n    if (this.textArea && this.editorContext && this.editorContext.config && this.editorContext.config.rules) {\r\n      if (xml === undefined) {\r\n        return;\r\n      }\r\n\r\n      const xml2html = new Xml2html(this.editorContext.config.rules);\r\n      const html = xml2html.ToHtml(xml);\r\n      const normalizedValue = xml === null ? '' : html;\r\n      this._renderer.setProperty(this.textArea.nativeElement, 'innerHTML', normalizedValue);\r\n    }\r\n  }\r\n\r\n  /* START OF ControlValueAccessor  (see https://angular.io/api/forms/ControlValueAccessor ) */\r\n\r\n  /**\r\n   * Sets the function called when the control gets a change event\r\n   */\r\n  registerOnChange(func: any): void {\r\n    this.onChangeFunction = func;\r\n  }\r\n\r\n  /**\r\n   * Sets the function called when the control gets a touch event\r\n   */\r\n  registerOnTouched(func: any): void {\r\n    this.onTouchedFunction = func;\r\n  }\r\n\r\n  /**\r\n   * Write the new value to the element\r\n   */\r\n  writeValue(value: any): void {\r\n    if (this.editorContext && this.editorContext.config) {\r\n      if (value === null || value === undefined || value === '') {\r\n        value = undefined;\r\n      }\r\n\r\n      this.showXml(value);\r\n\r\n      if (value === undefined) {\r\n        this.editorContext.actualCursor.xmlDocumentRootNode = undefined;\r\n      } else {\r\n        const el = this.textArea.nativeElement as Element;\r\n        const node = el.firstChild as Element;\r\n        this.editorContext.actualCursor.xmlDocumentRootNode = node;\r\n        this.editorContext.actualCursor.StartPos.SetCursor(this.editorContext.actualCursor.xmlDocumentRootNode, XMLCursorPositions.CursorOnCompleteNode);\r\n        this.domDummyNodeManager.UpdateDummyNodes(this.editorContext.actualCursor.xmlDocumentRootNode);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Executed from the contenteditable section while the input property changes\r\n   * @param html html string from contenteditable\r\n   */\r\n  onContentChange(html: string): void {\r\n    if (typeof this.onChangeFunction === 'function') {\r\n      const html2xml = new Html2xml(this.editorContext.config.rules);\r\n      const xml = html2xml.ToXml(html);\r\n      const normalizedValue = xml === null ? '' : xml;\r\n      this.onChangeFunction(normalizedValue);\r\n    }\r\n    return;\r\n  }\r\n\r\n  /**\r\n   * sets the disabled state for this element\r\n   */\r\n  setDisabledState(isDisabled: boolean): void {\r\n    const div = this.textArea.nativeElement;\r\n    const action = isDisabled ? 'addClass' : 'removeClass';\r\n    this._renderer[action](div, 'disabled');\r\n  }\r\n\r\n  /* END OF ControlValueAccessor */\r\n}\r\n","export class XmlRuleElement {\r\n  public tagName: string;\r\n  public empty: boolean;\r\n  public floating: boolean;\r\n\r\n  public static Sorted(elements: XmlRuleElement[]): XmlRuleElement[] {\r\n    const result = elements.sort((e1, e2) => {\r\n      if (e1.tagName > e2.tagName) {\r\n        return 1;\r\n      }\r\n      if (e1.tagName < e2.tagName) {\r\n        return -1;\r\n      }\r\n      return 0;\r\n    });\r\n    return result;\r\n  }\r\n\r\n  public constructor(init?: Partial<XmlRuleElement>) {\r\n    Object.assign(this, init);\r\n  }\r\n}\r\n","import { XmlCursorPos, XMLCursorPositions } from '../cursor/xmlCursorPos.class';\r\nimport { Xml2html } from '../xml-html-converter/xml2html.class';\r\n\r\nexport class XmlEditRuleCheckElements {\r\n  constructor(private xsdNodes: Map<string, Element>) {}\r\n\r\n  ElementsAllowedAtThisCursorPos(cursorPosToCheck: XmlCursorPos): string[] {\r\n    if (!cursorPosToCheck) {\r\n      return [];\r\n    }\r\n    const parentNode = this.getRelevantParentNodeForCursorPos(cursorPosToCheck);\r\n    const parentName = Xml2html.getTagNameFromNode(parentNode);\r\n    const xsdNode = this.xsdNodes.get(parentName);\r\n    if (xsdNode) {\r\n      const result = this.getSubElementNames(xsdNode, []);\r\n      return result;\r\n    } else {\r\n      // console.warn('element \"' + parentName + '\" not found');\r\n      return [];\r\n    }\r\n  }\r\n\r\n  getRelevantParentNodeForCursorPos(cursorPosToCheck: XmlCursorPos): Node {\r\n    if (cursorPosToCheck) {\r\n      let parentNode = cursorPosToCheck.ActualNode;\r\n\r\n      switch (parentNode.nodeType) {\r\n        case Node.COMMENT_NODE:\r\n        case Node.TEXT_NODE:\r\n          parentNode = parentNode.parentElement;\r\n          break;\r\n\r\n        case Node.ELEMENT_NODE:\r\n          switch (cursorPosToCheck.PosAtNode) {\r\n            case XMLCursorPositions.CursorInEmptyNode:\r\n            case XMLCursorPositions.CursorInsideTextNode:\r\n              break;\r\n\r\n            case XMLCursorPositions.CursorBehindNode:\r\n            case XMLCursorPositions.CursorInFrontOfNode:\r\n            case XMLCursorPositions.CursorOnCompleteNode:\r\n              parentNode = parentNode.parentElement;\r\n              break;\r\n\r\n            default:\r\n              throw new Error(`unhandled  cursorPosToCheck.PosAmNode \"${cursorPosToCheck.PosAtNode}\"/${XmlCursorPos.getXmlCursorPositionDebugName(cursorPosToCheck.PosAtNode)}\" `);\r\n          }\r\n          break;\r\n\r\n        default:\r\n          throw new Error(`unhandled  parentNode.nodeType \"${parentNode.nodeType}\"`);\r\n      }\r\n      return parentNode;\r\n    }\r\n  }\r\n\r\n  public getSubElementNames(xsdNode: Node, alreadyAddedElementNames: string[], depth: number = 0): string[] {\r\n    let elementNames: string[] = [];\r\n    let elementName: string;\r\n\r\n    if (xsdNode.nodeType === Node.ELEMENT_NODE) {\r\n      const asElem = xsdNode as Element;\r\n      if (asElem) {\r\n        if (asElem.localName === 'element') {\r\n          elementName = asElem.getAttribute('name');\r\n        }\r\n      }\r\n    }\r\n\r\n    if (elementName) {\r\n      // console.warn('found: ' + JSON.stringify(elementName) + ' depth: ' + depth);\r\n      if (alreadyAddedElementNames.length !== 0) {\r\n        if (alreadyAddedElementNames.indexOf(elementName) !== -1) {\r\n          return elementNames; // element recursion detected\r\n        }\r\n        if (depth === 0) {\r\n          // is the parent element itself - skip!\r\n        } else {\r\n          elementNames = elementNames.concat(elementName);\r\n          return elementNames;\r\n        }\r\n      }\r\n      alreadyAddedElementNames.push(elementName);\r\n    }\r\n\r\n    const childNodes = Array.prototype.slice.call(xsdNode.childNodes) as Node[];\r\n\r\n    depth++;\r\n\r\n    childNodes.forEach(child => {\r\n      if (child.nodeType === Node.ELEMENT_NODE) {\r\n        const childElem = child as Element;\r\n        if (childElem) {\r\n          switch (childElem.localName) {\r\n            case 'complexType':\r\n            case 'sequence':\r\n            case 'choice':\r\n            case 'simpleContent':\r\n            case 'extension':\r\n              elementNames = elementNames.concat(this.getSubElementNames(child, alreadyAddedElementNames, depth));\r\n              break;\r\n\r\n            case 'element':\r\n              const refname = childElem.attributes.getNamedItem('ref');\r\n              if (refname) {\r\n                const referedNode = this.xsdNodes.get(refname.value);\r\n                if (referedNode) {\r\n                  elementNames = elementNames.concat(this.getSubElementNames(referedNode, alreadyAddedElementNames, depth));\r\n                } else {\r\n                  throw new Error(` refered element \"${refname}\" for element \"${childElem.outerHTML}\" not found`);\r\n                }\r\n              } else {\r\n                elementNames = elementNames.concat(this.getSubElementNames(child, alreadyAddedElementNames, depth));\r\n              }\r\n              break;\r\n\r\n            case 'attribute':\r\n              break;\r\n\r\n            default:\r\n              throw new Error(`unknown childElem.localname \"${childElem.localName}\"/${childElem.outerHTML}`);\r\n          }\r\n        }\r\n      }\r\n    });\r\n\r\n    return elementNames;\r\n  }\r\n}\r\n","import { Component, EventEmitter, Output, Renderer2, Input, AfterViewInit, OnChanges, OnDestroy } from '@angular/core';\r\nimport { XmlRuleElement } from '../../code/xml-rules-check/xmlRuleElement.class';\r\nimport { XmlCursorPos } from '../../code/cursor/xmlCursorPos.class';\r\nimport { XmlEditRuleCheckElements } from '../../code/xml-rules-check/xmlEditRuleCheckElements.class';\r\nimport { AngularXmlEditorService } from '../../angular-xml-editor.service';\r\nimport { Subscription } from 'rxjs';\r\nimport { XmlEditorContext } from '../../code/xmlEditorContext.class';\r\nimport { XmlEditorConfig } from '../../code/xmlEditorConfig';\r\nimport { Xml2html } from '../../code/xml-html-converter/xml2html.class';\r\n\r\n@Component({\r\n  selector: 'axed-toolbar',\r\n  templateUrl: './xml-editor-toolbar.component.html',\r\n  styleUrls: ['./xml-editor-toolbar.component.scss']\r\n})\r\nexport class XmlEditorToolbarComponent implements AfterViewInit, OnChanges, OnDestroy {\r\n  private editorContext: XmlEditorContext;\r\n\r\n  @Input('config')\r\n  get config(): XmlEditorConfig {\r\n    if (this.editorContext !== undefined && this.editorContext.config !== undefined) {\r\n      return this.editorContext && this.editorContext.config;\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  @Input('editorContextId')\r\n  set editorContextId(value: string) {\r\n    if (!value) {\r\n      return;\r\n    }\r\n    this.editorContext = this.editorService.getEditorContext(value);\r\n    this.actualCursorPosChangedSubscription = this.editorContext.actualCursorChanged.subscribe(pos => {\r\n      this.elementGroups = this.GetElementGroupsForCursorPos(pos.StartPos);\r\n    });\r\n  }\r\n\r\n  elementGroups: ToolbarElementGroup[] = [];\r\n\r\n  actualCursorPosChangedSubscription: Subscription;\r\n\r\n  /** inserts an element at the actual cursor pos */\r\n  insertElement(element: XmlRuleElement) {\r\n    const html = new Xml2html(this.editorContext.config.rules).createNewElementHtml(element);\r\n    this.editorContext.domInsertHtml(html);\r\n  }\r\n\r\n  constructor(private editorService: AngularXmlEditorService) {}\r\n\r\n  ngAfterViewInit(): void {}\r\n  ngOnChanges(): void {}\r\n\r\n  ngOnDestroy(): void {\r\n    this.actualCursorPosChangedSubscription.unsubscribe();\r\n  }\r\n\r\n  GetElementGroupsForCursorPos(pos: XmlCursorPos): ToolbarElementGroup[] {\r\n    const allowedElements = new XmlEditRuleCheckElements(this.editorContext.config.xmlSchema.xsdNodes).ElementsAllowedAtThisCursorPos(pos);\r\n\r\n    return this.GetAllElementGroups()\r\n      .map(g => {\r\n        return {\r\n          title: g.title,\r\n          elements: g.elements.filter(e => allowedElements.includes(e.tagName))\r\n        } as ToolbarElementGroup;\r\n      })\r\n      .filter(g => g.elements.length > 0);\r\n  }\r\n\r\n  GetAllElementGroups(): ToolbarElementGroup[] {\r\n    const unusedElements = XmlRuleElement.Sorted(\r\n      Array.from(this.editorContext.config.rules.ruleElements.values()).filter(elem =>\r\n        this.editorContext.config.elementGroups.some(group => !group.elementNames.includes(elem.tagName))\r\n      )\r\n    );\r\n\r\n    const otherElementsGroup = {\r\n      title: 'other',\r\n      elements: unusedElements\r\n    } as ToolbarElementGroup;\r\n\r\n    return this.editorContext.config.elementGroups\r\n      .map(g => {\r\n        return {\r\n          title: g.title,\r\n          elements: XmlRuleElement.Sorted(g.elementNames.map(elementName => this.editorContext.config.rules.ruleElements.get(elementName)).filter(e => e !== undefined))\r\n        } as ToolbarElementGroup;\r\n      })\r\n      .concat(otherElementsGroup)\r\n      .filter(g => g.elements.length !== 0);\r\n  }\r\n}\r\n\r\nexport interface ToolbarElementGroup {\r\n  title: string;\r\n  elements: XmlRuleElement[];\r\n}\r\n","export class XmlRuleAttribut {\r\n  public attribName: string;\r\n\r\n  public required: boolean;\r\n\r\n  /** when the values are from a given list **/\r\n  public fixedValues: string[];\r\n\r\n  public defaultValue: string;\r\n\r\n  public xsdRawNode: Node;\r\n\r\n  public typ: RuleAttributeTypes;\r\n\r\n  public constructor(init?: Partial<XmlRuleAttribut>) {\r\n    Object.assign(this, init);\r\n    this.typ = this.getTyp();\r\n  }\r\n\r\n  getTyp(): RuleAttributeTypes {\r\n    if (this.fixedValues && this.fixedValues.length > 0) {\r\n      return RuleAttributeTypes.Enum;\r\n    }\r\n    return RuleAttributeTypes.String;\r\n  }\r\n}\r\n\r\nexport enum RuleAttributeTypes {\r\n  String = 0,\r\n  Enum = 1,\r\n  Number = 2\r\n}\r\n","import { XmlCursorPos, XMLCursorPositions } from '../cursor/xmlCursorPos.class';\r\nimport { XmlRuleAttribut } from './xmlRuleAttribut.class';\r\nimport { XmlSchema } from './xmlSchema.class';\r\nimport { Xml2html } from '../xml-html-converter/xml2html.class';\r\n\r\nexport class XmlEditRuleCheckAttributes {\r\n  constructor(private xmlSchema: XmlSchema) {}\r\n\r\n  AttributesAllowedAtThisCursorPos(cursorPosToCheck: XmlCursorPos): XmlRuleAttribut[] {\r\n    if (!cursorPosToCheck) {\r\n      return [];\r\n    }\r\n    const parentNode = this.getRelevantParentNodeForCursorPos(cursorPosToCheck);\r\n    const parentName = Xml2html.getTagNameFromNode(parentNode);\r\n    return this.getAttributesForElementName(parentName);\r\n  }\r\n\r\n  getRelevantParentNodeForCursorPos(cursorPosToCheck: XmlCursorPos): Node {\r\n    if (cursorPosToCheck) {\r\n      let parentNode = cursorPosToCheck.ActualNode;\r\n\r\n      switch (parentNode.nodeType) {\r\n        case Node.COMMENT_NODE:\r\n        case Node.TEXT_NODE:\r\n          parentNode = parentNode.parentElement;\r\n          break;\r\n\r\n        case Node.ELEMENT_NODE:\r\n          switch (cursorPosToCheck.PosAtNode) {\r\n            case XMLCursorPositions.CursorInEmptyNode:\r\n            case XMLCursorPositions.CursorInsideTextNode:\r\n            case XMLCursorPositions.CursorOnCompleteNode:\r\n              break;\r\n\r\n            case XMLCursorPositions.CursorBehindNode:\r\n            case XMLCursorPositions.CursorInFrontOfNode:\r\n              parentNode = parentNode.parentElement;\r\n              break;\r\n\r\n            default:\r\n              throw new Error(`unhandled cursorPosToCheck.PosAmNode \"${cursorPosToCheck.PosAtNode}\"/${XmlCursorPos.getXmlCursorPositionDebugName(cursorPosToCheck.PosAtNode)}\" `);\r\n          }\r\n          break;\r\n\r\n        default:\r\n          throw new Error(`unhandled parentNode.nodeType \"${parentNode.nodeType}\"`);\r\n      }\r\n      return parentNode;\r\n    }\r\n  }\r\n\r\n  getAttributesForElementName(elementName: string): XmlRuleAttribut[] {\r\n    const xsdNode = this.xmlSchema.findXsdNodeForTagName(elementName);\r\n    return this.getAttributesForElement(xsdNode, new Set([xsdNode]));\r\n  }\r\n\r\n  getAttributesForElement(xsdNode: Node, alreadyAddedElements: Set<Node>): XmlRuleAttribut[] {\r\n    let attributes: XmlRuleAttribut[] = [];\r\n\r\n    if (xsdNode) {\r\n      alreadyAddedElements.add(xsdNode);\r\n\r\n      const childNodes = Array.prototype.slice.call(xsdNode.childNodes);\r\n\r\n      childNodes.forEach(child => {\r\n        if (xsdNode.nodeType === Node.ELEMENT_NODE) {\r\n          const childElem = child as Element;\r\n          if (childElem) {\r\n            if (child.localName === 'attribute') {\r\n              // is attribute\r\n              attributes = attributes.concat([\r\n                new XmlRuleAttribut({\r\n                  attribName: childElem.attributes.getNamedItem('name').value,\r\n                  required: this.isRequiredAttribute(childElem),\r\n                  xsdRawNode: childElem,\r\n                  fixedValues: this.getFixedValues(childElem),\r\n                  defaultValue: this.getDefaultValue(childElem)\r\n                })\r\n              ]);\r\n            } else {\r\n              // no attribute\r\n              if (!alreadyAddedElements.has(child)) {\r\n                const subNodeAttributes = this.getAttributesForElement(child, alreadyAddedElements);\r\n                attributes = attributes.concat(subNodeAttributes);\r\n              } else {\r\n                // Element already added\r\n              }\r\n            }\r\n          }\r\n        }\r\n      });\r\n    }\r\n\r\n    return attributes;\r\n  }\r\n\r\n  /** the default value for this attribute */\r\n  private getDefaultValue(childElem: Element) {\r\n    const attrib = childElem.attributes.getNamedItem('default');\r\n    if (attrib !== null) {\r\n      return attrib.value;\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  /** is this attribute required? */\r\n  private isRequiredAttribute(childElem: Element) {\r\n    const attrib = childElem.attributes.getNamedItem('use');\r\n    const value = attrib !== null && attrib.value === 'required';\r\n    return value;\r\n  }\r\n\r\n  /** get the allowes values for this attribute */\r\n  private getFixedValues(xsdNode: Element, alreadyChecked: Node[] = []): string[] {\r\n    let values: string[] = [];\r\n\r\n    const childNodes = Array.prototype.slice.call(xsdNode.childNodes);\r\n    childNodes.forEach(child => {\r\n      if (xsdNode.nodeType === Node.ELEMENT_NODE) {\r\n        const childElem = child as Element;\r\n        if (childElem) {\r\n          if (child.localName === 'enumeration') {\r\n            values = values.concat([childElem.attributes.getNamedItem('value').value]);\r\n          } else {\r\n            // no attribute\r\n            if (alreadyChecked.indexOf(child) === -1) {\r\n              const subNodeAttributes = this.getFixedValues(child, alreadyChecked);\r\n              values = values.concat(subNodeAttributes);\r\n            } else {\r\n              // Element already added\r\n            }\r\n          }\r\n        }\r\n      }\r\n    });\r\n\r\n    return values;\r\n  }\r\n}\r\n","import { Component, OnInit, Input, OnDestroy } from '@angular/core';\r\nimport { XmlCursorPos } from '../../code/cursor/xmlCursorPos.class';\r\nimport { XmlEditRuleCheckAttributes } from '../../code/xml-rules-check/xmlEditRuleCheckAttributes.class';\r\nimport { XmlRuleAttribut, RuleAttributeTypes } from '../../code/xml-rules-check/xmlRuleAttribut.class';\r\nimport { AngularXmlEditorService } from '../../angular-xml-editor.service';\r\nimport { Subscription } from 'rxjs';\r\nimport { XmlEditorContext } from '../../code/xmlEditorContext.class';\r\nimport { Xml2htmlAttributeWorker } from '../../code/xml-html-converter/xml2htmlAttributeWorker.class';\r\nimport { Xml2html } from '../../code/xml-html-converter/xml2html.class';\r\n\r\n@Component({\r\n  selector: 'axed-attribute-editor',\r\n  templateUrl: './xml-editor-attribute-editor.component.html',\r\n  styleUrls: ['./xml-editor-attribute-editor.component.scss']\r\n})\r\nexport class XmlEditorAttributeEditorComponent implements OnInit, OnDestroy {\r\n  private editorContext: XmlEditorContext;\r\n\r\n  @Input('editorContextId')\r\n  set editorContextId(value: string) {\r\n    if (!value) {\r\n      return;\r\n    }\r\n    this.editorContext = this.editorService.getEditorContext(value);\r\n    this.actualCursorPosChangedSubscription = this.editorContext.actualCursorChanged.subscribe(pos => {\r\n      this.attributes = this.GetAttributesForCursorPos(pos.StartPos);\r\n      this.elementName = this.GetElementNameForCursorPos(pos.StartPos);\r\n    });\r\n  }\r\n\r\n  actualCursorPosChangedSubscription: Subscription;\r\n\r\n  attribTypes = RuleAttributeTypes;\r\n\r\n  attributes: ToolbarAttributData[] = [];\r\n  elementName: string;\r\n  actualElement: Element;\r\n\r\n  constructor(private editorService: AngularXmlEditorService) {}\r\n\r\n  ngOnInit() {}\r\n\r\n  ngOnDestroy(): void {\r\n    this.actualCursorPosChangedSubscription.unsubscribe();\r\n  }\r\n\r\n  attributeValueChanged(key: string, value: string) {\r\n    if (this.actualElement) {\r\n      const attribWorker = new Xml2htmlAttributeWorker(this.editorContext.config.rules);\r\n      attribWorker.writeAttributeToHtml(this.actualElement, key, value);\r\n    }\r\n  }\r\n\r\n  GetElementNameForCursorPos(pos: XmlCursorPos): string {\r\n    const rulesCheck = new XmlEditRuleCheckAttributes(this.editorContext.config.xmlSchema);\r\n    const parentNode = rulesCheck.getRelevantParentNodeForCursorPos(pos) as Element;\r\n    if (parentNode) {\r\n      return Xml2html.getTagNameFromNode(parentNode);\r\n    }\r\n    return undefined;\r\n  }\r\n\r\n  GetAttributesForCursorPos(pos: XmlCursorPos): ToolbarAttributData[] {\r\n    const attribWorker = new Xml2htmlAttributeWorker(this.editorContext.config.rules);\r\n    const rulesCheck = new XmlEditRuleCheckAttributes(this.editorContext.config.xmlSchema);\r\n    const parentNode = rulesCheck.getRelevantParentNodeForCursorPos(pos) as Element;\r\n    this.actualElement = parentNode;\r\n    if (parentNode) {\r\n      const allowedAttributes = rulesCheck.AttributesAllowedAtThisCursorPos(pos);\r\n      return allowedAttributes.map(a => {\r\n        return {\r\n          rules: a,\r\n          value: attribWorker.getAttributeValueFromHtml(parentNode, a.attribName)\r\n        } as ToolbarAttributData;\r\n      });\r\n    }\r\n    return [];\r\n  }\r\n}\r\n\r\nexport interface ToolbarAttributData {\r\n  rules: XmlRuleAttribut;\r\n  value: string;\r\n}\r\n","import { Component, OnInit, OnDestroy, Input } from '@angular/core';\r\nimport { Subscription } from 'rxjs';\r\nimport { XmlEditorDebugger } from '../../code/xmlEditorDebugger';\r\nimport { AngularXmlEditorService } from '../../angular-xml-editor.service';\r\nimport { XmlEditorContext } from '../../code/xmlEditorContext.class';\r\n\r\n@Component({\r\n  selector: 'axed-debug',\r\n  templateUrl: './xml-editor-debug.component.html',\r\n  styleUrls: ['./xml-editor-debug.component.scss']\r\n})\r\nexport class XmlEditorDebugComponent implements OnInit, OnDestroy {\r\n  private editorContext: XmlEditorContext;\r\n\r\n  @Input('editorContextId')\r\n  set editorContextId(value: string) {\r\n    if (!value) {\r\n      return;\r\n    }\r\n    this.editorContext = this.editorService.getEditorContext(value);\r\n    this.actualCursorPosChangedSubscription = this.editorContext.debugService.actualCursorPosChanged$.subscribe(pos => {\r\n      this.cursorPosInfo = pos.StartPos.getDebugDescription();\r\n    });\r\n    this.inputSelectionSubscription = this.editorContext.debugService.inputSelectionChanged$.subscribe(info => {\r\n      this.inputSelection = info;\r\n    });\r\n  }\r\n\r\n  cursorPosInfo: string;\r\n  inputSelection: string;\r\n\r\n  private actualCursorPosChangedSubscription: Subscription;\r\n  private inputSelectionSubscription: Subscription;\r\n\r\n  constructor(private editorService: AngularXmlEditorService) {}\r\n\r\n  ngOnInit() {}\r\n\r\n  ngOnDestroy(): void {\r\n    this.actualCursorPosChangedSubscription.unsubscribe();\r\n    this.inputSelectionSubscription.unsubscribe();\r\n  }\r\n}\r\n","import { Component, OnInit } from '@angular/core';\r\n\r\n@Component({\r\n  selector: 'axed-dom-breakcrumb',\r\n  templateUrl: './dom-breakcrumb.component.html',\r\n  styleUrls: ['./dom-breakcrumb.component.css']\r\n})\r\nexport class DomBreakcrumbComponent implements OnInit {\r\n  nodes: string[] = [];\r\n\r\n  constructor() {}\r\n\r\n  ngOnInit() {}\r\n\r\n  showSelection(selection: Selection) {\r\n    if (selection === undefined) {\r\n      this.nodes = ['none'];\r\n    } else {\r\n      const collectNodes = [];\r\n      let node = selection.focusNode;\r\n      let reachedTop = node === undefined || node === null;\r\n      while (!reachedTop) {\r\n        switch (node.nodeType) {\r\n          case Node.ELEMENT_NODE: // element node\r\n            const asElement = node as Element;\r\n            if (asElement !== undefined) {\r\n              const name = asElement.getAttribute('data-tagname');\r\n              if (asElement.className === 'sws-xml-editor-textarea') {\r\n                reachedTop = true;\r\n              } else {\r\n                collectNodes.unshift(name);\r\n              }\r\n            }\r\n        }\r\n        node = node.parentElement;\r\n        if (node === undefined || node == null) {\r\n          reachedTop = true;\r\n        }\r\n      }\r\n      this.nodes = collectNodes;\r\n    }\r\n  }\r\n}\r\n","import { NgModule } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { AngularXmlEditorComponent } from './angular-xml-editor.component';\r\nimport { XmlEditorToolbarComponent } from './components/xml-editor-toolbar/xml-editor-toolbar.component';\r\nimport { XmlEditorAttributeEditorComponent } from './components/xml-editor-attribute-editor/xml-editor-attribute-editor.component';\r\nimport { XmlEditorDebugComponent } from './components/xml-editor-debug/xml-editor-debug.component';\r\nimport { DomBreakcrumbComponent } from './components/dom-breakcrumb/dom-breakcrumb.component';\r\nimport { ReactiveFormsModule, FormsModule } from '@angular/forms';\r\n\r\n@NgModule({\r\n  imports: [CommonModule, FormsModule, ReactiveFormsModule],\r\n  declarations: [AngularXmlEditorComponent, XmlEditorToolbarComponent, XmlEditorAttributeEditorComponent, XmlEditorDebugComponent, DomBreakcrumbComponent],\r\n  exports: [AngularXmlEditorComponent, XmlEditorToolbarComponent, XmlEditorAttributeEditorComponent, XmlEditorDebugComponent, DomBreakcrumbComponent]\r\n})\r\nexport class AngularXmlEditorModule {}\r\n","export class XmlSchema {\r\n  public constructor(public xsdNodes: Map<string, Element>) {}\r\n\r\n  findXsdNodeForTagName(tagName: string): Node {\r\n    return this.xsdNodes.get(tagName);\r\n  }\r\n}\r\n","import { XmlSchema } from './xmlSchema.class';\r\n\r\nexport class XmlSchemaLoader {\r\n  public xmlSchema: XmlSchema;\r\n\r\n  public constructor(schemaContent: string) {\r\n    if (!schemaContent || schemaContent === '') {\r\n      return;\r\n    }\r\n    const domparser = new DOMParser();\r\n    const schemaDom = domparser.parseFromString(schemaContent, 'text/xml');\r\n    // const rawElements = Array.from(schemaDom.documentElement.childNodes) as Element[];\r\n    // this.xmlSchema = new XmlSchema(this.getXsdNodes(rawElements));\r\n\r\n    let result: Node[] = [];\r\n    const rawElementsAtRoot = Array.from(schemaDom.documentElement.childNodes) as Element[];\r\n    rawElementsAtRoot.forEach(e => {\r\n      const subChilds = this.getRawElements(e);\r\n      result = result.concat(subChilds);\r\n    });\r\n    this.xmlSchema = new XmlSchema(this.getXsdNodes(result as Element[]));\r\n  }\r\n\r\n  private getRawElements(node: Node): Node[] {\r\n    let result: Node[] = [];\r\n    if (this.isValidXsdNode(node)) {\r\n      result = result.concat(node);\r\n    }\r\n\r\n    const children = Array.from(node.childNodes) as Node[];\r\n    children.forEach(child => {\r\n      result = result.concat(this.getRawElements(child));\r\n    });\r\n\r\n    return result;\r\n  }\r\n\r\n  private isValidXsdNode(node: Node): boolean {\r\n    const allowedXsdTypes = ['element', 'group', 'complexType'];\r\n    const asElem = node as Element;\r\n\r\n    if (asElem) {\r\n      if (allowedXsdTypes.includes(asElem.localName)) {\r\n        if (asElem.attributes.getNamedItem('name')) {\r\n          // console.warn(asElem.attributes.getNamedItem('name').value);\r\n          return true;\r\n        } else {\r\n          return false;\r\n        }\r\n      } else {\r\n        return false;\r\n      }\r\n    } else {\r\n      return false;\r\n    }\r\n  }\r\n\r\n  private getXsdNodes(rawElements: Element[]) {\r\n    // console.warn(rawElements.length);\r\n    return new Map(rawElements.map<[string, Element]>(n => [n.attributes.getNamedItem('name').value, n as Element]));\r\n  }\r\n}\r\n","import { XmlRuleElement } from './xmlRuleElement.class';\r\n\r\nexport class XmlRules {\r\n  public constructor(public ruleElements: Map<string, XmlRuleElement>) {}\r\n}\r\n","import { XmlRuleElement } from './xmlRuleElement.class';\r\nimport { XmlEditRuleCheckTextInsert } from './xmlEditRuleCheckTextInsert.class';\r\nimport { XmlRules } from './xmlRules.class';\r\nimport { XmlSchema } from './xmlSchema.class';\r\nimport { Xml2html } from '../xml-html-converter/xml2html.class';\r\n\r\nexport class XmlRulesCreator {\r\n  public rules: XmlRules;\r\n\r\n  public constructor(private schema: XmlSchema, private _floatingElementNames: string[]) {\r\n    this.rules = new XmlRules(this.getAllElementRuleNodes(Array.from(this.schema.xsdNodes.values())));\r\n  }\r\n\r\n  private findXsdNodeForHtmlNode(node: Node): Node {\r\n    const tagName = Xml2html.getTagNameFromNode(node);\r\n    return this.schema.xsdNodes.get(tagName);\r\n  }\r\n\r\n  private getAllElementRuleNodes(xsdNodes: Element[]) {\r\n    return new Map(xsdNodes.map<[string, XmlRuleElement]>(xsdNode => [xsdNode.attributes.getNamedItem('name').value, this.getRuleElementForXsdNode(xsdNode)]));\r\n  }\r\n\r\n  private getRuleElementForXsdNode(xsdNode: Element): XmlRuleElement {\r\n    if (xsdNode) {\r\n      const tagName = xsdNode.attributes.getNamedItem('name').value;\r\n      return new XmlRuleElement({\r\n        tagName: tagName,\r\n        floating: this.isFloating(tagName),\r\n        empty: this.isEmpty(xsdNode)\r\n        // xsdRawNode: xsdNode,\r\n      });\r\n    } else {\r\n      return undefined;\r\n    }\r\n  }\r\n\r\n  private isEmpty(xsdNode: Node): boolean {\r\n    if (new XmlEditRuleCheckTextInsert(this.schema.xsdNodes).isTextAllowedInThisElement(xsdNode) === true) {\r\n      return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  private isFloating(tagName: string): boolean {\r\n    return this._floatingElementNames.includes(tagName);\r\n  }\r\n}\r\n"],"names":["Subject","Injectable","Inject","DOCUMENT","EventEmitter","Component","ViewEncapsulation","NG_VALUE_ACCESSOR","forwardRef","Renderer2","Input","ViewChild","Output","NgModule","CommonModule","FormsModule","ReactiveFormsModule"],"mappings":";;;;;;;;;;AACA,IAMA,IAAA;QAIE;2CAHiC,IAAIA,YAAO,EAAa;0CACzB,IAAIA,YAAO,EAAU;SAErC;;;;;QAEhB,8CAAkB;;;;YAAlB,UAAmB,GAAc;gBAC/B,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;aACxC;;;;;QAED,6CAAiB;;;;YAAjB,UAAkB,IAAY;gBAC5B,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACxC;;;;QAED,uCAAW;;;YAAX;gBACE,IAAI,CAAC,uBAAuB,CAAC,QAAQ,EAAE,CAAC;gBACxC,IAAI,CAAC,sBAAsB,CAAC,QAAQ,EAAE,CAAC;aACxC;gCAxBH;QAyBC,CAAA;;;;;;ICzBD,IAAA;;;;;;;QAMgB,8BAAmB;;;;sBAAC,IAAU;gBAC1C,QAAQ,IAAI,CAAC,QAAQ;oBACnB,KAAK,IAAI,CAAC,SAAS,CAAC;oBACpB,KAAK,IAAI,CAAC,YAAY;wBACpB,OAAO,IAAI,CAAC;oBACd;wBACE,OAAO,KAAK,CAAC;iBAChB;;;;;;;QAKW,8BAAmB;;;;sBAAC,IAAU;gBAC1C,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,SAAS,EAAE;oBACvC,OAAO,MAAM,CAAC;iBACf;gBAED,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,SAAS,EAAE;oBACpC,IAAI,IAAI,CAAC,WAAW,KAAK,GAAG,IAAI,IAAI,CAAC,WAAW,KAAK,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE;wBAC7E,OAAO,wBAAsB,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,UAAU,CAAG,CAAC;qBAChF;yBAAM;wBACL,OAAO,kBAAgB,IAAI,CAAC,WAAW,MAAG,CAAC;qBAC5C;iBACF;;gBAED,IAAM,MAAM,qBAAG,IAAe,EAAC;gBAC/B,IAAI,MAAM,KAAK,SAAS,EAAE;oBACxB,OAAO,gBAAc,IAAI,CAAC,QAAQ,mBAAc,IAAI,CAAC,QAAU,CAAC;iBACjE;qBAAM;oBACL,OAAO,MAAM,CAAC,SAAS,CAAC;iBACzB;;yBApCL;QAsCC,CAAA;;;;;;;QCjCC,iCAAmB,KAAe;YAAf,UAAK,GAAL,KAAK,CAAU;SAAI;;;;;;;;QAGtC,6DAA2B;;;;;;YAA3B,UAA4B,UAAmB,EAAE,WAAoB;;gBACnE,IAAM,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;gBACzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;;oBAC1C,IAAM,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;oBAC3B,IAAI,CAAC,oBAAoB,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;iBAC/D;aACF;;;;;;;;;QAGD,sDAAoB;;;;;;;YAApB,UAAqB,WAAoB,EAAE,GAAW,EAAE,KAAa;;gBACnE,IAAM,IAAI,GAAG,KAAG,uBAAuB,CAAC,iBAAiB,GAAG,GAAK,CAAC;gBAClE,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;oBAC7B,WAAW,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;iBACvC;qBAAM;oBACL,WAAW,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;iBACnC;gBACD,IAAI,CAAC,wCAAwC,CAAC,WAAW,CAAC,CAAC;aAC5D;;;;;;;;QAGD,2DAAyB;;;;;;YAAzB,UAA0B,WAAoB,EAAE,GAAW;;gBACzD,IAAM,UAAU,GAAG,WAAW,CAAC,UAAU,CAAC;gBAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;oBAC1C,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,KAAG,uBAAuB,CAAC,iBAAiB,GAAG,GAAK,EAAE;wBAC/E,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;qBAC5B;iBACF;gBACD,OAAO,SAAS,CAAC;aAClB;;;;;;;;QAGD,6DAA2B;;;;;;YAA3B,UAA4B,WAAoB,EAAE,UAAmB;;gBACnE,IAAM,UAAU,GAAG,WAAW,CAAC,UAAU,CAAC;gBAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;;oBAC1C,IAAM,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;oBAC3B,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,uBAAuB,CAAC,iBAAiB,CAAC,EAAE;wBACnE,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,uBAAuB,CAAC,iBAAiB,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;qBACzG;iBACF;aACF;;;;;;QAGO,0EAAwC;;;;;sBAAC,WAAoB;;gBACnE,IAAM,UAAU,GAAG,WAAW,CAAC,UAAU,CAAC;;gBAC1C,IAAI,aAAa,GAAG,EAAE,CAAC;gBACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;;oBAC1C,IAAM,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;oBAC3B,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,uBAAuB,CAAC,iBAAiB,CAAC,EAAE;wBACnE,aAAa,GAAM,aAAa,SAAI,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,uBAAuB,CAAC,iBAAiB,CAAC,MAAM,CAAC,WAAK,IAAI,CAAC,KAAK,OAAG,CAAC;qBAC1H;iBACF;gBACD,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE;oBAC5B,WAAW,CAAC,YAAY,CAAC,iBAAiB,EAAE,aAAa,CAAC,CAAC;iBAC5D;qBAAM;oBACL,WAAW,CAAC,eAAe,CAAC,iBAAiB,CAAC,CAAC;iBAChD;;oDA5D+B,iBAAiB;sCAHrD;;;;;;;ACCA;QAYE,kBAAmB,KAAe;YAAf,UAAK,GAAL,KAAK,CAAU;YAChC,IAAI,CAAC,eAAe,GAAG,IAAI,uBAAuB,CAAC,KAAK,CAAC,CAAC;SAC3D;;;;;QAEM,2BAAkB;;;;YAAzB,UAA0B,IAAU;;gBAClC,IAAM,IAAI,qBAAG,IAAe,EAAC;;gBAC7B,IAAI,IAAI,GAAG,EAAE,CAAC;gBACd,IAAI,IAAI,EAAE;oBACR,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;iBAChD;gBACD,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE,EAAE;oBACtD,MAAM,IAAI,KAAK,CAAC,uCAAqC,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAG,CAAC,CAAC;iBAC9F;gBACD,OAAO,IAAI,CAAC;aACb;;;;;QAEM,0BAAiB;;;;YAAxB,UAAyB,IAAU;;gBACjC,IAAM,IAAI,qBAAG,IAAe,EAAC;gBAC7B,IAAI,IAAI,IAAI,IAAI,CAAC,SAAS,EAAE;oBAC1B,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAC;iBAC/D;gBACD,OAAO,KAAK,CAAC;aACd;;;;;QAEM,2BAAkB;;;;YAAzB,UAA0B,IAAU;;gBAClC,IAAM,IAAI,qBAAG,IAAe,EAAC;gBAC7B,IAAI,IAAI,IAAI,IAAI,CAAC,SAAS,EAAE;oBAC1B,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAC;iBAChE;gBACD,OAAO,KAAK,CAAC;aACd;;;;;QAEM,yBAAM;;;;sBAAC,GAAW;gBACvB,IAAI,GAAG,KAAK,EAAE,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,EAAE;oBACnD,OAAO,EAAE,CAAC;iBACX;;;gBAKD,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;gBAC7B,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;;gBAE7B,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;;gBAEnC,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;;gBAEtC,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;;gBAEpC,IAAM,SAAS,GAAG,IAAI,SAAS,EAAE,CAAC;;gBAClC,IAAM,MAAM,GAAG,SAAS,CAAC,eAAe,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;;gBAE1D,IAAM,cAAc,GAAG,IAAI,QAAQ,EAAE,CAAC;gBAEtC,IAAI,MAAM,CAAC,eAAe,KAAK,IAAI,EAAE;oBACnC,OAAO,EAAE,CAAC;iBACX;;gBAED,IAAM,IAAI,GAAG,IAAI,CAAC,4BAA4B,CAAC,MAAM,CAAC,eAAe,EAAE,cAAc,CAAC,CAAC;gBACvF,IAAI,IAAI,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY,EAAE;;oBAC/C,IAAM,IAAI,GAAG,mBAAC,IAAe,GAAE,SAAS,CAAC;oBACzC,OAAO,IAAI,CAAC;iBACb;qBAAM;oBACL,MAAM,IAAI,KAAK,CAAC,eAAa,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,mBAAgB,CAAC,CAAC;iBACpF;;;;;;QAGH,uCAAoB;;;;YAApB,UAAqB,QAAwB;;gBAC3C,IAAM,IAAI,GAAG,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;gBAC3D,OAAO,IAAI,CAAC,SAAS,CAAC;aACvB;;;;;QAEM,yCAAsB;;;;sBAAC,OAAe;;gBAC3C,IAAM,OAAO,GAAG,IAAI,QAAQ,EAAE,CAAC;;gBAC/B,IAAM,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;;gBAEhD,IAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBAClD,IAAI,IAAI,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,EAAE;oBAClC,UAAU,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAC;iBACzD;;gBAED,IAAI,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,EAAE;oBAC/B,UAAU,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAC;iBAC1D;gBACD,UAAU,CAAC,YAAY,CAAC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;gBACvD,OAAO,UAAU,CAAC;;;;;;;QAGZ,+CAA4B;;;;;sBAAC,IAAU,EAAE,cAAwB;gBACvE,QAAQ,IAAI,CAAC,QAAQ;oBACnB,KAAK,IAAI,CAAC,YAAY;;wBACpB,IAAM,SAAS,qBAAG,IAAe,EAAC;;wBAClC,IAAM,QAAQ,GAAG,SAAS,CAAC,QAAQ,CAAC;;wBAGpC,IAAI,UAAU,GAAG,cAAc,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;;wBAGrD,IAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;wBACnD,IAAI,IAAI,IAAI,IAAI,CAAC,QAAQ,EAAE;4BACzB,UAAU,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAC;yBACzD;;wBAED,IAAI,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE;4BACtB,UAAU,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAC;yBAC1D;wBACD,UAAU,CAAC,YAAY,CAAC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;;wBAGxD,IAAM,QAAQ,GAAG,SAAS,CAAC,UAAU,CAAC;wBACtC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;4BACzB,UAAU,CAAC,WAAW,CAAC,cAAc,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC;yBAC3D;6BAAM;4BACL,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;;gCACxC,IAAM,WAAW,GAAG,IAAI,CAAC,4BAA4B,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;gCACnF,IAAI,WAAW,KAAK,SAAS,EAAE;oCAC7B,UAAU,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;iCACrC;6BACF;yBACF;;wBAGD,IAAI,CAAC,eAAe,CAAC,2BAA2B,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;wBAExE,OAAO,UAAU,CAAC;oBAEpB,KAAK,IAAI,CAAC,SAAS;;wBACjB,IAAM,OAAO,GAAG,mBAAC,IAAe,GAAE,WAAW,CAAC;wBAC9C,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;4BACtB,OAAO,cAAc,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;yBAC/C;6BAAM;4BACL,OAAO,SAAS,CAAC;yBAClB;oBAEH,KAAK,IAAI,CAAC,YAAY;;wBAEpB,UAAU,GAAG,cAAc,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;wBACjD,UAAU,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC;wBACvD,UAAU,CAAC,YAAY,CAAC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;wBACzD,UAAU,CAAC,WAAW,GAAG,mBAAC,IAAe,GAAE,WAAW,CAAC;wBACvD,OAAO,UAAU,CAAC;;oBAGpB,KAAK,IAAI,CAAC,2BAA2B;wBACnC,OAAO,CAAC,IAAI,CAAC,8CAA0C,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,yBAAsB,CAAC,CAAC;wBACnH,OAAO,SAAS,CAAC;oBAEnB,KAAK,IAAI,CAAC,aAAa;wBACrB,MAAM,IAAI,KAAK,CAAC,qCAAiC,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,yBAAsB,CAAC,CAAC;oBAC/G,KAAK,IAAI,CAAC,kBAAkB;wBAC1B,MAAM,IAAI,KAAK,CAAC,qCAAiC,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,yBAAsB,CAAC,CAAC;oBAC/G,KAAK,IAAI,CAAC,sBAAsB;wBAC9B,MAAM,IAAI,KAAK,CAAC,8CAA0C,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,yBAAsB,CAAC,CAAC;;oBAGxH,KAAK,IAAI,CAAC,cAAc;wBACtB,MAAM,IAAI,KAAK,CAAC,sCAAkC,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,mBAAgB,CAAC,CAAC;oBAC1G,KAAK,IAAI,CAAC,kBAAkB;wBAC1B,MAAM,IAAI,KAAK,CAAC,0CAAsC,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,mBAAgB,CAAC,CAAC;oBAC9G,KAAK,IAAI,CAAC,qBAAqB;wBAC7B,MAAM,IAAI,KAAK,CAAC,6CAAyC,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,mBAAgB,CAAC,CAAC;oBACjH,KAAK,IAAI,CAAC,WAAW;wBACnB,MAAM,IAAI,KAAK,CAAC,mCAA+B,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,mBAAgB,CAAC,CAAC;oBACvG,KAAK,IAAI,CAAC,aAAa;wBACrB,MAAM,IAAI,KAAK,CAAC,qCAAiC,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,mBAAgB,CAAC,CAAC;oBAEzG;;wBAEE,MAAM,IAAI,KAAK,CAAC,iCAA+B,IAAI,CAAC,QAAQ,mBAAc,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAG,CAAC,CAAC;iBACrH;;+BAhL0B,cAAc;yCACL,iBAAiB;wCAClB,UAAU;uCACX,SAAS;uBAT/C;;;;;;;ACAA;QAOE;SAAgB;;;;;QAEF,+BAAW;;;;sBAAC,IAAU;;gBAClC,IAAM,MAAM,qBAAG,IAAe,EAAC;gBAC/B,IAAI,MAAM,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY,EAAE;oBACjD,OAAO,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,mBAAmB,CAAC,kBAAkB,CAAC,CAAC;iBAC1E;gBACD,OAAO,KAAK,CAAC;;;;;;QAGD,6CAAyB;;;;sBAAC,IAAU;gBAChD,IAAI,mBAAmB,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;;oBACzC,IAAM,MAAM,qBAAG,IAAe,EAAC;oBAC/B,IAAI,MAAM,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY,EAAE;wBACjD,OAAO,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,mBAAmB,CAAC,gCAAgC,CAAC,CAAC;qBACxF;oBACD,OAAO,KAAK,CAAC;iBACd;qBAAM;oBACL,OAAO,KAAK,CAAC;iBACd;;;;;;QAIW,sCAAkB;;;;sBAAC,IAAU;gBACzC,IAAI,CAAC,IAAI,EAAE;oBACT,OAAO,SAAS,CAAC;iBAClB;gBACD,OAAO,IAAI,EAAE;oBACX,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC;oBAC5B,IAAI,IAAI,EAAE;wBACR,IAAI,mBAAmB,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAC1C;6BAAM;4BACL,OAAO,IAAI,CAAC;yBACb;qBACF;iBACF;gBACD,OAAO,SAAS,CAAC;;;;;;QAIL,kCAAc;;;;sBAAC,IAAU;gBACrC,IAAI,CAAC,IAAI,EAAE;oBACT,OAAO,SAAS,CAAC;iBAClB;gBACD,OAAO,IAAI,EAAE;oBACX,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC;oBACxB,IAAI,IAAI,EAAE;wBACR,IAAI,mBAAmB,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAC1C;6BAAM;4BACL,OAAO,IAAI,CAAC;yBACb;qBACF;iBACF;gBACD,OAAO,SAAS,CAAC;;;;;;QAIL,qCAAiB;;;;sBAAC,IAAU;gBACxC,IAAI,CAAC,IAAI,EAAE;oBACT,OAAO,CAAC,CAAC;iBACV;;gBACD,IAAI,KAAK,GAAG,CAAC,CAAC;gBACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBAC/C,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE;wBACxD,KAAK,EAAE,CAAC;qBACT;iBACF;gBACD,OAAO,KAAK,CAAC;;;;;;QAID,iCAAa;;;;sBAAC,IAAU;gBACpC,IAAI,CAAC,IAAI,EAAE;oBACT,OAAO,SAAS,CAAC;iBAClB;;gBACD,IAAI,KAAK,qBAAG,IAAI,CAAC,UAAkB,EAAC;gBACpC,OAAO,mBAAmB,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE;oBAC7C,KAAK,GAAG,KAAK,CAAC,WAAW,CAAC;iBAC3B;gBACD,OAAO,KAAK,CAAC;;;;;;QAID,gCAAY;;;;sBAAC,IAAU;gBACnC,IAAI,CAAC,IAAI,EAAE;oBACT,OAAO,SAAS,CAAC;iBAClB;;gBACD,IAAI,IAAI,qBAAG,IAAI,CAAC,SAAiB,EAAC;gBAClC,OAAO,mBAAmB,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE;oBAC5C,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC;iBAC7B;gBACD,OAAO,IAAI,CAAC;;;;;;;QAGd,iDAAmB;;;;;YAAnB,UAAoB,IAAU,EAAE,SAAa;gBAA7C,iBAsBC;gBAtB+B,0BAAA;oBAAA,aAAa;;;gBAC3C,IAAI,QAAQ,GAAW,EAAE,CAAC;gBAC1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;oBAC/C,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;iBACnC;;gBAGD,QAAQ,CAAC,OAAO,CAAC,UAAA,KAAK;oBACpB,IAAI,mBAAmB,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE;wBAC1C,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;qBACzB;iBACF,CAAC,CAAC;gBAEH,QAAQ,GAAG,EAAE,CAAC;gBACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;oBAC/C,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;iBACnC;;gBAGD,QAAQ,CAAC,OAAO,CAAC,UAAA,KAAK;oBACpB,KAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,SAAS,GAAG,CAAC,CAAC,CAAC;iBAChD,CAAC,CAAC;aACJ;;;;;;QAED,8CAAgB;;;;;YAAhB,UAAiB,IAAU,EAAE,SAAa;gBAA1C,iBAwEC;gBAxE4B,0BAAA;oBAAA,aAAa;;;gBACxC,IAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC;;gBACpC,IAAM,SAAS,qBAAG,IAAe,EAAC;;gBAElC,IAAM,QAAQ,GAAW,EAAE,CAAC;gBAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;oBAC/C,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;iBACnC;gBAED,IAAI,SAAS,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,SAAS,CAAC,aAAa,CAAC,EAAE;oBACzH,IAAI,SAAS,CAAC,QAAQ,KAAK,IAAI,CAAC,SAAS,EAAE;;wBACzC,IAAM,MAAM,GAAG,SAAS,CAAC,eAAe,CAAC;wBACzC,IAAI,MAAM,CAAC,QAAQ,KAAK,IAAI,CAAC,SAAS,EAAE,CAEvC;6BAAM;4BACL,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE;gCAC5C,SAAS,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAC,CAAC;6BAC9E;yBACF;qBACF;oBAED,IAAI,SAAS,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY,EAAE;;wBAC5C,IAAI,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;wBACjC,IAAI,CAAC,UAAU,EAAE;;4BAEf,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC;4BACjD,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;yBAC9B;wBAED,IAAI,QAAQ,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE,CACtC;6BAAM;4BACL,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;4BAE7B,IAAI,CAAC,UAAU,EAAE;;gCAEf,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC;gCACjD,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;6BAC9B;;4BAGD,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE;gCAChD,IAAI,UAAU,EAAE;oCACd,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,UAAU,CAAC,CAAC;oCAC9D,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;iCAC9B;qCAAM;oCACL,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC;iCAClD;6BACF;;4BAGD,IAAI,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;4BAC/B,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE;gCAC/C,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC;gCACjD,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;6BAC5B;;4BAGD,IAAI,SAAS,GAAG,CAAC,EAAE;gCACjB,IAAI,mBAAmB,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,mBAAmB,CAAC,yBAAyB,CAAC,UAAU,CAAC,EAAE;;oCAC7G,IAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;oCACjD,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,mBAAmB,CAAC,gCAAgC,CAAC,CAAC;oCAC9E,SAAS,CAAC,YAAY,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;iCAC/C;6BACF;yBACF;qBACF;iBACF;;gBAGD,QAAQ,CAAC,OAAO,CAAC,UAAA,KAAK;oBACpB,KAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,SAAS,GAAG,CAAC,CAAC,CAAC;iBAC7C,CAAC,CAAC;aACJ;;;;;;QAEM,6CAAe;;;;;sBAAC,cAAwB,EAAE,OAAgB;;gBAC/D,IAAM,SAAS,GAAG,cAAc,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;;gBACvD,IAAI,cAAc,CAAC;gBACnB,IAAI,OAAO,KAAK,SAAS,EAAE;oBACzB,cAAc,GAAG,cAAc,CAAC,cAAc,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,CAAC;iBACtF;qBAAM;oBACL,cAAc,GAAG,cAAc,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;iBACzD;gBACD,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,mBAAmB,CAAC,kBAAkB,CAAC,CAAC;gBAChE,SAAS,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;gBACtC,OAAO,SAAS,CAAC;;iDA9MgB,WAAW;+DACG,gBAAgB;+CAChC,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC;kCAL3D;;;;;;;ACAA,IAKA,IAAA;QAwGE;YACE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;YACvB,IAAI,CAAC,SAAS,GAAG,kBAAkB,CAAC,oBAAoB,CAAC;YACzD,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;SACxB;;;;;QAvGM,0CAA6B;;;;YAApC,UAAqC,QAA4B;gBAC/D,QAAQ,QAAQ;oBACd,KAAK,kBAAkB,CAAC,oBAAoB;wBAC1C,OAAO,sBAAsB,CAAC;oBAChC,KAAK,kBAAkB,CAAC,gBAAgB;wBACtC,OAAO,kBAAkB,CAAC;oBAC5B,KAAK,kBAAkB,CAAC,iBAAiB;wBACvC,OAAO,mBAAmB,CAAC;oBAC7B,KAAK,kBAAkB,CAAC,oBAAoB;wBAC1C,OAAO,sBAAsB,CAAC;oBAChC,KAAK,kBAAkB,CAAC,mBAAmB;wBACzC,OAAO,qBAAqB,CAAC;oBAC/B;wBACE,OAAO,uBAAqB,QAAU,CAAC;iBAC1C;aACF;;;;;QAEM,+BAAkB;;;;YAAzB,UAA0B,GAAiB;gBACzC,IAAI,mBAAmB,CAAC,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;oBACnD,MAAM,IAAI,KAAK,CAAC,kDAAgD,GAAG,CAAC,mBAAmB,EAAE,sBAAmB,CAAC,CAAC;iBAC/G;gBAED,IAAI,mBAAmB,CAAC,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,EAAE;oBACjE,MAAM,IAAI,KAAK,CAAC,gEAA8D,GAAG,CAAC,mBAAmB,EAAE,sBAAmB,CAAC,CAAC;iBAC7H;gBAED,QAAQ,GAAG,CAAC,SAAS;oBACnB,KAAK,kBAAkB,CAAC,oBAAoB;;wBAC1C,IAAI,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC,UAAU,CAAC;wBAC3C,IAAI,mBAAmB,CAAC,yBAAyB,CAAC,UAAU,CAAC,EAAE;4BAC7D,OAAO;gCACL,IAAI,EAAE,UAAU,CAAC,UAAU;;gCAC3B,MAAM,EAAE,CAAC;6BACV,CAAC;yBACH;6BAAM;4BACL,OAAO;gCACL,IAAI,EAAE,GAAG,CAAC,UAAU;gCACpB,MAAM,EAAE,CAAC;6BACV,CAAC;yBACH;oBAEH,KAAK,kBAAkB,CAAC,mBAAmB;;wBACzC,IAAI,GAAG,CAAC,UAAU,CAAC,QAAQ,KAAK,IAAI,CAAC,SAAS,EAAE;;4BAE9C,IAAM,WAAW,GAAG,GAAG,CAAC,UAAU,CAAC,eAAe,CAAC;4BACnD,IAAI,mBAAmB,CAAC,WAAW,CAAC,WAAW,CAAC,EAAE;gCAChD,OAAO;oCACL,IAAI,EAAE,WAAW,CAAC,UAAU;;oCAC5B,MAAM,EAAE,CAAC;iCACV,CAAC;6BACH;iCAAM;gCACL,MAAM,IAAI,KAAK,CAAC,2EAA2E,GAAG,GAAG,CAAC,mBAAmB,EAAE,CAAC,CAAC;6BAC1H;yBACF;6BAAM;;4BAEL,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC,UAAU,CAAC;4BACvC,IAAI,mBAAmB,CAAC,yBAAyB,CAAC,UAAU,CAAC,EAAE;gCAC7D,OAAO;oCACL,IAAI,EAAE,UAAU,CAAC,UAAU;;oCAC3B,MAAM,EAAE,CAAC;iCACV,CAAC;6BACH;4BACD,IAAI,QAAQ,CAAC,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,mBAAmB,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE;gCAC9F,OAAO,EAAE,IAAI,EAAE,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;6BACnD;4BACD,MAAM,IAAI,KAAK,CAAC,iFAAiF,CAAC,CAAC;yBACpG;wBACD,MAAM;oBAER,KAAK,kBAAkB,CAAC,gBAAgB;;wBACtC,IAAM,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC;wBAC9C,IAAI,mBAAmB,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE;4BAC/C,OAAO;gCACL,IAAI,EAAE,UAAU,CAAC,UAAU;;gCAC3B,MAAM,EAAE,CAAC;6BACV,CAAC;yBACH;6BAAM;4BACL,MAAM,IAAI,KAAK,CAAC,gGAAgG,CAAC,CAAC;yBACnH;oBAEH,KAAK,kBAAkB,CAAC,iBAAiB;;wBACvC,IAAM,SAAS,GAAG,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC;wBAC3C,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,mBAAmB,CAAC,yBAAyB,CAAC,UAAU,CAAC,EAAE;4BAC9G,OAAO;gCACL,IAAI,EAAE,SAAS,CAAC,UAAU;;gCAC1B,MAAM,EAAE,CAAC;6BACV,CAAC;yBACH;wBACD,MAAM;oBAER,KAAK,kBAAkB,CAAC,oBAAoB;wBAC1C,OAAO;4BACL,IAAI,EAAE,GAAG,CAAC,UAAU;4BACpB,MAAM,EAAE,GAAG,CAAC,aAAa;yBAC1B,CAAC;iBACL;gBACD,MAAM,IAAI,KAAK,CAAC,qDAAmD,GAAG,CAAC,mBAAmB,EAAI,CAAC,CAAC;aACjG;;;;QAQD,4BAAK;;;YAAL;;gBACE,IAAM,IAAI,GAAG,IAAI,YAAY,EAAE,CAAC;gBAChC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;gBACpE,OAAO,IAAI,CAAC;aACb;;;;;QAED,6BAAM;;;;YAAN,UAAO,QAAsB;gBAC3B,IAAI,CAAC,QAAQ,EAAE;oBACb,OAAO,KAAK,CAAC;iBACd;gBACD,IAAI,QAAQ,CAAC,UAAU,KAAK,IAAI,CAAC,UAAU,EAAE;oBAC3C,OAAO,KAAK,CAAC;iBACd;gBACD,IAAI,QAAQ,CAAC,SAAS,KAAK,IAAI,CAAC,SAAS,EAAE;oBACzC,OAAO,KAAK,CAAC;iBACd;gBACD,IAAI,IAAI,CAAC,SAAS,KAAK,kBAAkB,CAAC,oBAAoB,IAAI,IAAI,CAAC,aAAa,KAAK,QAAQ,CAAC,aAAa,EAAE;oBAC/G,OAAO,KAAK,CAAC;iBACd;gBACD,OAAO,IAAI,CAAC;aACb;;;;QAED,0CAAmB;;;YAAnB;gBACE,OAAO,UAAQ,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,UAAU,CAAC,cAAS,YAAY,CAAC,6BAA6B,CAAC,IAAI,CAAC,SAAS,CAAC,oBAAe,IAAI,CAAC,aAAe,CAAC;aACtK;;;;;;;QAED,gCAAS;;;;;;YAAT,UAAU,UAAgB,EAAE,SAA6B,EAAE,aAAyB;gBAAzB,8BAAA;oBAAA,iBAAyB;;gBAClF,IAAI,CAAC,UAAU,EAAE;oBACf,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;iBACvC;gBAGD,IAAI,UAAU,KAAK,IAAI,CAAC,UAAU,EAAE,CAEnC;qBAAM;oBACL,IAAI,SAAS,KAAK,IAAI,CAAC,SAAS,EAAE,CAEjC;yBAAM;wBACL,IAAI,aAAa,KAAK,IAAI,CAAC,aAAa,EAAE,CAIzC;qBACF;iBACF;gBAED,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;gBAC7B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;gBAC3B,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;aAOpC;;;;;QAED,mEAA4C;;;;YAA5C,UAA6C,IAAU;;gBACrD,IAAM,WAAW,GAAG,mBAAmB,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;gBAC7D,IAAI,WAAW,EAAE;oBACf,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;iBACrE;qBAAM;oBACL,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,CAAC;iBAC3D;aACF;;;;;QAED,0DAAmC;;;;YAAnC,UAAoC,IAAU;gBAC5C,IAAI,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE;;oBAExC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,kBAAkB,CAAC,oBAAoB,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;iBACzG;qBAAM;;oBACL,IAAM,cAAc,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;oBACnE,IAAI,cAAc,KAAK,CAAC,EAAE;;wBAExB,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE;;4BAEtC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;yBAC5D;6BAAM;;4BAEL,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;yBAC9D;qBACF;yBAAM;;wBAEL,IAAI,CAAC,SAAS,CAAC,mBAAmB,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,CAAC;qBAC7F;iBACF;aACF;2BAzMH;QA0MC,CAAA;AArMD;;QAwME,sBAAuB;QACvB,uBAAwB;QACxB,oBAAqB;QACrB,uBAAwB;QACxB,mBAAoB;;0CAJpB,mBAAmB;0CACnB,oBAAoB;0CACpB,iBAAiB;0CACjB,oBAAoB;0CACpB,gBAAgB;;;;;;ACjNlB,IAMA,IAAA;;;;;;;;;QACgB,0BAAQ;;;;;;sBAAC,GAAiB,EAAE,QAAiB,EAAE,QAAkB;gBAC7E,IAAI,GAAG,KAAK,SAAS,EAAE;oBACrB,OAAO,KAAK,CAAC;iBACd;gBAED,QAAQ,GAAG,CAAC,SAAS;oBACnB,KAAK,kBAAkB,CAAC,oBAAoB;;wBAE1C,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;wBACtE,MAAM;oBAER,KAAK,kBAAkB,CAAC,mBAAmB;wBACzC,IAAI,GAAG,CAAC,UAAU,KAAK,QAAQ,EAAE;4BAC/B,OAAO,KAAK,CAAC;yBACd;6BAAM;;4BACL,IAAM,eAAe,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;4BAC/E,IAAI,eAAe,EAAE;;gCAEnB,GAAG,CAAC,mCAAmC,CAAC,eAAe,CAAC,CAAC;6BAC1D;iCAAM;;gCAEL,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,UAAU,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;6BAClF;yBACF;wBACD,MAAM;oBAER,KAAK,kBAAkB,CAAC,gBAAgB;wBACtC,GAAG,CAAC,mCAAmC,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;wBACxD,MAAM;oBAER,KAAK,kBAAkB,CAAC,iBAAiB;;wBAEvC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;wBACtE,MAAM;oBAER,KAAK,kBAAkB,CAAC,oBAAoB;wBAC1C,IAAI,UAAU,CAAC,mBAAmB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;;4BAElD,IAAI,GAAG,CAAC,aAAa,GAAG,CAAC,EAAE;;gCAEzB,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;6BACrE;iCAAM;;gCAEL,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;6BACvE;yBACF;6BAAM;;4BAEL,IAAM,KAAK,qBAAG,GAAG,CAAC,UAAqB,EAAC;4BACxC,MAAM,IAAI,KAAK,CAAC,sKACkD,KAAK,GAAG,KAAK,CAAC,SAAS,GAAG,EAAE,CAAE,CAAC,CAAC;yBACnG;wBACD,MAAM;oBAER;wBACE,MAAM,IAAI,KAAK,CAAC,8CAA4C,GAAG,CAAC,SAAW,CAAC,CAAC;iBAChF;gBACD,OAAO,IAAI,CAAC;;;;;;;;QAGA,2BAAS;;;;;;sBAAC,GAAiB,EAAE,QAAiB,EAAE,QAAkB;gBAC9E,IAAI,GAAG,KAAK,SAAS,EAAE;oBACrB,OAAO,KAAK,CAAC;iBACd;gBAED,QAAQ,GAAG,CAAC,SAAS;oBACnB,KAAK,kBAAkB,CAAC,oBAAoB;;wBAE1C,IAAM,OAAO,GAAG,QAAQ,CAAC,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;;wBAC5D,IAAM,IAAI,GAAG,QAAQ,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;wBAChD,IAAI,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,EAAE;4BAC/B,GAAG,CAAC,4CAA4C,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;yBAClE;6BAAM;;4BACL,IAAM,UAAU,GAAG,mBAAmB,CAAC,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;4BACrE,IAAI,UAAU,EAAE;gCACd,GAAG,CAAC,SAAS,CAAC,UAAU,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;6BACnE;iCAAM;gCACL,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;6BACrE;yBACF;wBACD,MAAM;oBAER,KAAK,kBAAkB,CAAC,gBAAgB;;wBACtC,IAAM,WAAW,GAAG,mBAAmB,CAAC,cAAc,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;wBACvE,IAAI,WAAW,EAAE;;4BAEf,IAAM,KAAK,qBAAG,GAAG,CAAC,UAAqB,EAAC;4BACxC,MAAM,IAAI,KAAK,CAAC,0GAAuG,KAAK,GAAG,KAAK,CAAC,SAAS,GAAG,EAAE,CAAE,CAAC,CAAC;yBACxJ;6BAAM;;4BAEL,IAAM,iBAAiB,GAAG,mBAAmB,CAAC,cAAc,CAAC,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;4BAC3F,IAAI,iBAAiB,EAAE;gCACrB,GAAG,CAAC,SAAS,CAAC,iBAAiB,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;6BAC1E;iCAAM;gCACL,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,aAAa,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,CAAC;6BAClF;yBACF;wBACD,MAAM;oBAER,KAAK,kBAAkB,CAAC,iBAAiB;;wBAEvC,GAAG,CAAC,4CAA4C,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;wBACjE,MAAM;oBAER,KAAK,kBAAkB,CAAC,mBAAmB;wBACzC,IAAI,UAAU,CAAC,mBAAmB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;;4BAElD,IAAI,mBAAC,GAAG,CAAC,UAAqB,GAAE,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;;gCAEtD,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,oBAAoB,EAAE,CAAC,CAAC,CAAC;6BAC3E;iCAAM;;;gCAGL,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,CAAC;;gCAEnE,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;6BACzC;yBACF;6BAAM;;4BAEL,IAAM,cAAc,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;4BAC7E,IAAI,cAAc,KAAK,CAAC,EAAE;;gCAExB,IAAI,QAAQ,CAAC,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;;;oCAG/C,GAAG,CAAC,4CAA4C,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;iCAClE;qCAAM;;;oCAGL,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;iCACrE;6BACF;iCAAM;;gCAEL,IAAM,UAAU,GAAG,mBAAmB,CAAC,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;gCACrE,GAAG,CAAC,SAAS,CAAC,UAAU,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;6BACnE;yBACF;wBACD,MAAM;oBAER,KAAK,kBAAkB,CAAC,oBAAoB;wBAC1C,IAAI,UAAU,CAAC,mBAAmB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;;4BAElD,IAAI,mBAAC,GAAG,CAAC,UAAqB,GAAE,WAAW,CAAC,MAAM,GAAG,GAAG,CAAC,aAAa,GAAG,CAAC,EAAE;;;gCAG1E,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;6BACrE;iCAAM;;;gCAGL,GAAG,CAAC,4CAA4C,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;6BAClE;yBACF;6BAAM;;4BAEL,IAAM,KAAK,qBAAG,GAAG,CAAC,UAAqB,EAAC;4BACxC,MAAM,IAAI,KAAK,CAAC,qKAC+C,KAAK,GAAG,KAAK,CAAC,SAAS,GAAG,EAAE,CAAE,CAAC,CAAC;yBAChG;wBACD,MAAM;oBACR;wBACE,MAAM,IAAI,KAAK,CAAC,+DAA4D,GAAG,CAAC,SAAW,CAAC,CAAC;iBAChG;gBAED,OAAO,IAAI,CAAC;;gCAxKhB;QA0KC,CAAA;;;;;;AC1KD,IAIA,IAAA;;uCACiC,SAAS;uCAClB,IAAI,mBAAmB,EAAE;4BAE7B,IAAI,YAAY,EAAE;0BACpB,IAAI,YAAY,EAAE;;;;;;;;;QAKlC,oCAAgB;;;;YAAhB;gBACE,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;oBACrC,OAAO,IAAI,CAAC;iBACb;gBACD,OAAO,KAAK,CAAC;aACd;;;;QAED,mCAAe;;;YAAf;gBACE,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE;oBACtD,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE;wBAC/D,IACE,IAAI,CAAC,QAAQ,CAAC,SAAS,KAAK,kBAAkB,CAAC,oBAAoB;4BACnE,IAAI,CAAC,MAAM,CAAC,SAAS,KAAK,kBAAkB,CAAC,oBAAoB;4BACjE,IAAI,CAAC,QAAQ,CAAC,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,EACvD;4BACA,IAAI,CAAC,eAAe,EAAE,CAAC;yBACxB;qBACF;yBAAM;;wBACL,IAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,uBAAuB,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;;wBAE1F,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC,2BAA2B,CAAC,EAAE;4BAClD,IAAI,CAAC,eAAe,EAAE,CAAC;yBACxB;qBACF;iBACF;aACF;;;;QAED,mCAAe;;;YAAf;;gBACE,IAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC;;gBACtC,IAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;;gBACpC,IAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC;gBACzC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;gBAClG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;aACxC;;;;QAED,wBAAI;;;YAAJ;gBACE,IAAI,MAAM,CAAC,YAAY,EAAE;;oBACvB,IAAM,SAAS,GAAc,MAAM,CAAC,YAAY,EAAE,CAAC;oBACnD,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;iBACvB;qBAAM;oBACL,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;iBACpE;aACF;;;;;QAEO,yBAAK;;;;sBAAC,SAAoB;gBAChC,IAAI,CAAC,SAAS,EAAE;oBACd,OAAO;iBACR;;gBAGD,IAAM,KAAK,GAAG,QAAQ,CAAC,gBAAgB,CAAC,WAAW,CAAC,CAAC;gBACrD,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,UAAS,EAAE;oBAChC,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;iBACjC,CAAC,CAAC;;gBAEH,IAAM,cAAc,GAAG,YAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACtE,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;;oBAE/E,IAAM,YAAY,GAAG,YAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;oBAClE,SAAS,CAAC,gBAAgB,CAAC,cAAc,CAAC,IAAI,EAAE,cAAc,CAAC,MAAM,EAAE,YAAY,CAAC,IAAI,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;iBAChH;qBAAM;;oBAEL,SAAS,CAAC,WAAW,CAAC,cAAc,CAAC,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;;oBAGlE,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS,KAAK,kBAAkB,CAAC,oBAAoB,EAAE;;wBACvE,IAAM,MAAM,qBAAG,IAAI,CAAC,QAAQ,CAAC,UAAqB,EAAC;wBACnD,IAAI,MAAM,IAAI,MAAM,CAAC,SAAS,EAAE;4BAC9B,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;4BACjC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;yBAC1B;6BAAM;4BACL,OAAO,CAAC,KAAK,CAAC,qCAAmC,UAAU,CAAC,mBAAmB,CAAC,MAAM,CAAG,CAAC,CAAC;yBAC5F;qBACF;iBACF;;wBAxFL;QA0FC,CAAA;;;;;;AC1FD,IAKA,IAAA;;;;;;;;;;QACgB,mCAAgB;;;;;;;sBAAC,GAAiB,EAAE,mBAAyB,EAAE,qBAA6B,EAAE,QAAkC;gBAAlC,yBAAA;oBAAA,eAAkC;;gBAC5I,IAAI,mBAAmB,KAAK,SAAS,IAAI,mBAAmB,KAAK,IAAI,EAAE;;oBACrE,IAAI,IAAI,qBAAG,mBAA8B,EAAC;oBAC1C,IAAI,mBAAmB,CAAC,WAAW,CAAC,mBAAmB,CAAC,aAAa,CAAC,EAAE;;wBAEtE,IAAI,qBAAG,mBAAmB,CAAC,aAAwB,CAAA,CAAC;wBAEpD,IAAI,mBAAmB,CAAC,yBAAyB,CAAC,IAAI,CAAC,EAAE;4BACvD,QAAQ,qBAAqB;gCAC3B,KAAK,CAAC;oCACJ,IAAI,QAAQ,EAAE;wCACZ,QAAQ,CAAC,iBAAiB,CAAC,+BAA+B,CAAC,CAAC;qCAC7D;oCACD,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,EAAE,kBAAkB,CAAC,oBAAoB,EAAE,CAAC,CAAC,CAAC;oCAC9E,OAAO;gCAET,KAAK,CAAC;oCACJ,IAAI,QAAQ,EAAE;wCACZ,QAAQ,CAAC,iBAAiB,CAAC,+BAA+B,CAAC,CAAC;qCAC7D;oCACD,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,EAAE,kBAAkB,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;oCAC7E,OAAO;gCAET;oCACE,MAAM,IAAI,KAAK,CAAC,2BAAyB,qBAAqB,QAAK,CAAC,CAAC;6BACxE;yBACF;wBAED,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;4BAC9C,IAAI,QAAQ,EAAE;gCACZ,QAAQ,CAAC,iBAAiB,CAAC,oCAAoC,CAAC,CAAC;6BAClE;4BACD,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,EAAE,kBAAkB,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC;4BAC3E,OAAO;yBACR;wBAED,IAAI,IAAI,KAAK,IAAI,CAAC,aAAa,CAAC,SAAS,IAAI,qBAAqB,KAAK,CAAC,EAAE;4BACxE,IAAI,QAAQ,EAAE;gCACZ,QAAQ,CAAC,iBAAiB,CAAC,uDAAuD,CAAC,CAAC;6BACrF;4BACD,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,EAAE,kBAAkB,CAAC,oBAAoB,EAAE,CAAC,CAAC,CAAC;4BAC9E,OAAO;yBACR;;wBAED,IAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;wBACrC,IAAI,WAAW,EAAE;4BACf,IAAI,QAAQ,EAAE;gCACZ,QAAQ,CAAC,iBAAiB,CAAC,iDAAiD,CAAC,CAAC;6BAC/E;4BACD,GAAG,CAAC,SAAS,CAAC,WAAW,EAAE,kBAAkB,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;4BACtE,OAAO;yBACR;;wBAED,IAAM,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC;wBAC7C,IAAI,eAAe,EAAE;4BACnB,IAAI,QAAQ,EAAE;gCACZ,QAAQ,CAAC,iBAAiB,CAAC,2CAA2C,CAAC,CAAC;6BACzE;4BACD,GAAG,CAAC,SAAS,CAAC,eAAe,EAAE,kBAAkB,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC;4BACvE,OAAO;yBACR;qBACF;yBAAM;;wBAEL,IAAI,mBAAmB,CAAC,QAAQ,KAAK,IAAI,CAAC,SAAS,EAAE;4BACnD,IAAI,qBAAqB,KAAK,CAAC,EAAE;gCAC/B,IAAI,QAAQ,EAAE;oCACZ,QAAQ,CAAC,iBAAiB,CAAC,wBAAwB,CAAC,CAAC;iCACtD;gCACD,GAAG,CAAC,SAAS,CAAC,mBAAmB,EAAE,kBAAkB,CAAC,oBAAoB,EAAE,CAAC,CAAC,CAAC;gCAC/E,OAAO;6BACR;4BAED,IAAI,qBAAqB,KAAK,mBAAmB,CAAC,WAAW,CAAC,MAAM,EAAE;gCACpE,IAAI,QAAQ,EAAE;oCACZ,QAAQ,CAAC,iBAAiB,CAAC,oCAAoC,CAAC,CAAC;iCAClE;gCACD,GAAG,CAAC,SAAS,CAAC,mBAAmB,EAAE,kBAAkB,CAAC,oBAAoB,EAAE,mBAAmB,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;gCACpH,OAAO;6BACR;4BAED,IAAI,QAAQ,EAAE;gCACZ,QAAQ,CAAC,iBAAiB,CAAC,4BAA4B,CAAC,CAAC;6BAC1D;4BACD,IAAI,qBAAqB,GAAG,mBAAmB,CAAC,WAAW,CAAC,MAAM,EAAE;gCAClE,MAAM,IAAI,KAAK,CACb,2BAAyB,qBAAqB,+BAA0B,mBAAmB,CAAC,WAAW,CAAC,MAAM,kBAAa,mBAAmB,CAAC,WAAW,OAAI,CAC/J,CAAC;6BACH;4BACD,GAAG,CAAC,SAAS,CAAC,mBAAmB,EAAE,kBAAkB,CAAC,oBAAoB,EAAE,qBAAqB,CAAC,CAAC;4BACnG,OAAO;yBACR;qBACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsDF;gBACD,OAAO,CAAC,KAAK,CACX,qEAAmE,UAAU,CAAC,mBAAmB,CAAC,mBAAmB,CAAC,gCAA2B,qBAAuB,CACzK,CAAC;;iCA1JN;QA4JC,CAAA;;;;;;AC5JD,IAIA,IAAA;;;;;;;;QACgB,qBAAO;;;;;sBAAC,IAAU,EAAE,YAAuB;gBACvD,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;;;;;;;;;;QAM7B,6BAAe;;;;;;;;sBAAC,IAAU,EAAE,YAAuB,EAAE,SAAa;gBAAb,0BAAA;oBAAA,aAAa;;;gBAC9E,IAAI,OAAO,GAAG,IAAI,CAAC;gBAEnB,OAAO,OAAO,KAAK,IAAI,EAAE;oBACvB,OAAO,GAAG,KAAK,CAAC;oBAEhB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;;wBAC/C,IAAM,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;wBACxC,IAAI,mBAAmB,CAAC,WAAW,CAAC,YAAY,CAAC,EAAE;4BACjD,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;yBAC9E;wBACD,IAAI,YAAY,CAAC,QAAQ,KAAK,IAAI,CAAC,SAAS,EAAE;;4BAC5C,IAAM,aAAa,GAAG,YAAY,CAAC,WAAW,CAAC;4BAC/C,IAAI,aAAa,KAAK,IAAI,IAAI,aAAa,CAAC,QAAQ,KAAK,IAAI,CAAC,SAAS,EAAE;;gCAEvE,IAAI,YAAY,CAAC,QAAQ,CAAC,UAAU,KAAK,aAAa,EAAE;oCACtD,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC,YAAY,EAAE,kBAAkB,CAAC,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAAC,MAAM,GAAG,YAAY,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;iCAC/J;gCACD,IAAI,YAAY,CAAC,MAAM,CAAC,UAAU,KAAK,aAAa,EAAE;oCACpD,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,YAAY,EAAE,kBAAkB,CAAC,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAAC,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;iCAC3J;gCACD,YAAY,CAAC,WAAW,GAAG,YAAY,CAAC,WAAW,GAAG,aAAa,CAAC,WAAW,CAAC;gCAChF,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;gCAChC,OAAO,GAAG,IAAI,CAAC;6BAChB;yBACF;qBACF;iBACF;;gBAGD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;oBAC/C,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,SAAS,GAAG,CAAC,CAAC,CAAC;iBACvE;;4BA5CL;QA8CC,CAAA;;;;;;AC7CD,IAKA,IAAA;;;;;;;;;QACgB,6BAAe;;;;;;sBAAC,MAAiB,EAAE,QAAiB,EAAE,QAAkB;gBACpF,OAAO,IAAI,CAAC;;;;;;;;QAGA,yBAAW;;;;;;sBAAC,GAAiB,EAAE,QAAiB,EAAE,QAAkB;gBAChF,IAAI,GAAG,KAAK,SAAS,EAAE;oBACrB,OAAO,KAAK,CAAC;iBACd;gBAED,QAAQ,GAAG,CAAC,SAAS;oBACnB,KAAK,kBAAkB,CAAC,oBAAoB;wBAC1C,OAAO,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;oBAE7D,KAAK,kBAAkB,CAAC,gBAAgB,CAAC;oBACzC,KAAK,kBAAkB,CAAC,mBAAmB;wBACzC,iBAAiB,CAAC,SAAS,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;wBACrD,OAAO,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;oBAE7D,KAAK,kBAAkB,CAAC,iBAAiB;wBACvC,OAAO,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;oBAE7D,KAAK,kBAAkB,CAAC,oBAAoB;wBAC1C,iBAAiB,CAAC,SAAS,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;wBACrD,OAAO,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;oBAE7D;wBACE,MAAM,IAAI,KAAK,CAAC,mEAAgE,GAAG,CAAC,SAAW,CAAC,CAAC;iBACpG;gBAED,OAAO,IAAI,CAAC;;;;;;;;QAGA,0BAAY;;;;;;sBAAC,GAAiB,EAAE,QAAiB,EAAE,QAAkB;;gBACjF,IAAI,UAAU,CAAO;;gBAIrB,IAAI,GAAG,KAAK,SAAS,EAAE;oBACrB,OAAO,KAAK,CAAC;iBACd;gBACD,QAAQ,GAAG,CAAC,SAAS;oBACnB,KAAK,kBAAkB,CAAC,oBAAoB;wBAC1C,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC;wBAC5B,iBAAiB,CAAC,SAAS,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;wBACrD,UAAU,CAAC,aAAa,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;wBACjD,MAAM;oBAER,KAAK,kBAAkB,CAAC,gBAAgB;wBACtC,IAAI,GAAG,CAAC,UAAU,CAAC,QAAQ,KAAK,IAAI,CAAC,SAAS,EAAE;4BAC9C,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,oBAAoB,EAAE,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;4BAC1G,OAAO,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;yBAC5D;6BAAM;4BACL,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;yBAC1D;wBACD,MAAM;oBAER,KAAK,kBAAkB,CAAC,iBAAiB;wBACvC,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC;wBAC5B,iBAAiB,CAAC,SAAS,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;wBACrD,UAAU,CAAC,aAAa,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;wBACjD,MAAM;oBAER,KAAK,kBAAkB,CAAC,mBAAmB;wBACzC,UAAU,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;wBACpE,IAAI,CAAC,UAAU,EAAE;4BACf,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC;yBAC3C;wBACD,IAAI,UAAU,EAAE;4BACd,IAAI,UAAU,CAAC,QAAQ,KAAK,IAAI,CAAC,SAAS,EAAE;gCAC1C,GAAG,CAAC,SAAS,CAAC,UAAU,EAAE,kBAAkB,CAAC,oBAAoB,EAAE,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;gCAClG,OAAO,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;6BAC5D;iCAAM;gCACL,UAAU,CAAC,aAAa,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;6BAClD;yBACF;wBACD,MAAM;oBAER,KAAK,kBAAkB,CAAC,oBAAoB;wBAC1C,IAAI,GAAG,CAAC,aAAa,KAAK,CAAC,EAAE;4BAC3B,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;4BACzE,OAAO,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;yBAC5D;6BAAM;;4BACL,IAAI,IAAI,GAAG,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC;4BACtC,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,aAAa,EAAE,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;4BACpH,GAAG,CAAC,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC;4BAClC,iBAAiB,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;;yBAErD;wBACD,MAAM;oBAER;wBACE,MAAM,IAAI,KAAK,CAAC,6DAA0D,GAAG,CAAC,SAAW,CAAC,CAAC;iBAC9F;gBAED,OAAO,IAAI,CAAC;;4BArGhB;QAuGC,CAAA;;;;;;ACvGD,IAGA,IAAA;QAGE,oCAAoB,QAA8B;YAA9B,aAAQ,GAAR,QAAQ,CAAsB;oCAF/B,KAAK;SAE8B;;;;;QAEtD,iEAA4B;;;;YAA5B,UAA6B,gBAA8B;gBACzD,IAAI,CAAC,gBAAgB,EAAE;oBACrB,OAAO,KAAK,CAAC;iBACd;;gBACD,IAAM,UAAU,GAAG,IAAI,CAAC,iCAAiC,CAAC,gBAAgB,CAAC,CAAC;;gBAC5E,IAAM,UAAU,GAAG,QAAQ,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC;;gBAC3D,IAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;gBAC9C,IAAI,OAAO,EAAE;;oBACX,IAAM,MAAM,GAAG,IAAI,CAAC,0BAA0B,CAAC,OAAO,CAAC,CAAC;oBACxD,OAAO,MAAM,CAAC;iBACf;qBAAM;oBACL,OAAO,KAAK,CAAC;iBACd;aACF;;;;;QAED,sEAAiC;;;;YAAjC,UAAkC,gBAA8B;gBAC9D,IAAI,gBAAgB,EAAE;;oBACpB,IAAI,UAAU,GAAG,gBAAgB,CAAC,UAAU,CAAC;oBAE7C,QAAQ,UAAU,CAAC,QAAQ;wBACzB,KAAK,IAAI,CAAC,YAAY,CAAC;wBACvB,KAAK,IAAI,CAAC,SAAS;4BACjB,UAAU,GAAG,UAAU,CAAC,aAAa,CAAC;4BACtC,MAAM;wBAER,KAAK,IAAI,CAAC,YAAY;4BACpB,QAAQ,gBAAgB,CAAC,SAAS;gCAChC,KAAK,kBAAkB,CAAC,iBAAiB,CAAC;gCAC1C,KAAK,kBAAkB,CAAC,oBAAoB;oCAC1C,MAAM;gCAER,KAAK,kBAAkB,CAAC,gBAAgB,CAAC;gCACzC,KAAK,kBAAkB,CAAC,mBAAmB,CAAC;gCAC5C,KAAK,kBAAkB,CAAC,oBAAoB;oCAC1C,UAAU,GAAG,UAAU,CAAC,aAAa,CAAC;oCACtC,MAAM;gCAER;oCACE,MAAM,IAAI,KAAK,CAAC,6CAA0C,gBAAgB,CAAC,SAAS,WAAK,YAAY,CAAC,6BAA6B,CAAC,gBAAgB,CAAC,SAAS,CAAC,QAAI,CAAC,CAAC;6BACxK;4BACD,MAAM;wBAER;4BACE,MAAM,IAAI,KAAK,CAAC,sCAAmC,UAAU,CAAC,QAAQ,OAAG,CAAC,CAAC;qBAC9E;oBACD,OAAO,UAAU,CAAC;iBACnB;aACF;;;;;;QAED,+DAA0B;;;;;YAA1B,UAA2B,OAAa,EAAE,wBAAyD;gBAAnG,iBAyEC;gBAzEyC,yCAAA;oBAAA,+BAA4C,GAAG,EAAU;;;gBACjG,IAAI,WAAW,CAAS;gBAExB,IAAI,OAAO,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY,EAAE;;oBAC1C,IAAM,MAAM,qBAAG,OAAkB,EAAC;oBAClC,IAAI,MAAM,EAAE;;wBACV,IAAM,WAAW,GAAG,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;wBACjD,IAAI,WAAW,EAAE;4BACf,OAAO,IAAI,CAAC;yBACb;;wBACD,IAAM,UAAU,GAAG,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;wBAC/C,IAAI,UAAU,IAAI,UAAU,KAAQ,IAAI,CAAC,gBAAgB,WAAQ,EAAE;4BACjE,OAAO,IAAI,CAAC;yBACb;wBAED,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS,EAAE;4BAClC,WAAW,GAAG,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;4BAC1C,IAAI,WAAW,EAAE;gCACf,IAAI,wBAAwB,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE;oCAC7C,OAAO,KAAK,CAAC;iCACd;6BACF;4BACD,wBAAwB,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;yBAC3C;qBACF;iBACF;;gBAED,IAAM,UAAU,qBAAG,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAW,EAAC;;gBAE5E,IAAI,OAAO,GAAG,KAAK,CAAC;gBAEpB,UAAU,CAAC,OAAO,CAAC,UAAA,KAAK;oBACtB,IAAI,KAAK,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY,EAAE;;wBACxC,IAAM,SAAS,qBAAG,KAAgB,EAAC;wBACnC,IAAI,SAAS,EAAE;4BACb,QAAQ,SAAS,CAAC,SAAS;gCACzB,KAAK,aAAa,CAAC;gCACnB,KAAK,UAAU,CAAC;gCAChB,KAAK,QAAQ,CAAC;gCACd,KAAK,eAAe,CAAC;gCACrB,KAAK,WAAW;oCACd,IAAI,KAAI,CAAC,0BAA0B,CAAC,KAAK,EAAE,wBAAwB,CAAC,KAAK,IAAI,EAAE;wCAC7E,OAAO,GAAG,IAAI,CAAC;wCACf,MAAM;qCACP;oCACD,MAAM;gCAER,KAAK,SAAS;;oCACZ,IAAM,OAAO,GAAG,SAAS,CAAC,UAAU,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;oCACzD,IAAI,OAAO,EAAE;;wCACX,IAAM,WAAW,GAAG,KAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;wCACrD,IAAI,WAAW,EAAE;4CACf,IAAI,KAAI,CAAC,0BAA0B,CAAC,WAAW,EAAE,wBAAwB,CAAC,KAAK,IAAI,EAAE;gDACnF,OAAO,GAAG,IAAI,CAAC;gDACf,MAAM;6CACP;yCACF;6CAAM;4CACL,MAAM,IAAI,KAAK,CAAC,wBAAqB,OAAO,yBAAkB,SAAS,CAAC,SAAS,iBAAa,CAAC,CAAC;yCACjG;qCACF;oCACD,MAAM;gCAER,KAAK,WAAW;oCACd,MAAM;gCAER;oCACE,KAAK,CAAC,+BAA+B,GAAG,SAAS,CAAC,SAAS,GAAG,IAAI,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC;6BAC7F;yBACF;qBACF;iBACF,CAAC,CAAC;gBAEH,OAAO,OAAO,CAAC;aAChB;yCAlIH;QAmIC,CAAA;;;;;;ACnID,IAQA,IAAA;;;;;;;;;;;QACgB,6BAAe;;;;;;;;sBAAC,GAAc,EAAE,KAAa,EAAE,QAAiB,EAAE,QAAkB,EAAE,SAAoB;gBACtH,IAAI,GAAG,KAAK,SAAS,EAAE;oBACrB,OAAO,KAAK,CAAC;iBACd;gBACD,IAAI,KAAK,KAAK,EAAE,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,IAAI,IAAI,EAAE;oBACxD,OAAO,KAAK,CAAC;iBACd;gBAED,IAAI,GAAG,CAAC,gBAAgB,EAAE,KAAK,KAAK,EAAE;oBACpC,IAAI,aAAa,CAAC,eAAe,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK,KAAK,EAAE;wBACpE,OAAO,KAAK,CAAC;qBACd;iBACF;gBAED,OAAO,aAAa,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;;;;;;;;;;QAGtE,wBAAU;;;;;;;;sBAAC,GAAiB,EAAE,KAAa,EAAE,QAAiB,EAAE,QAAkB,EAAE,SAAoB;gBACpH,IAAI,GAAG,KAAK,SAAS,EAAE;oBACrB,OAAO,KAAK,CAAC;iBACd;gBAED,IAAI,KAAK,KAAK,EAAE,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,IAAI,IAAI,EAAE;oBACxD,OAAO,KAAK,CAAC;iBACd;gBAED,QAAQ,GAAG,CAAC,SAAS;oBACnB,KAAK,kBAAkB,CAAC,oBAAoB;;wBAC1C,IAAI,WAAW,GAAG,aAAa,CAAC,yBAAyB,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;wBAC1E,IAAI,WAAW,KAAK,IAAI,EAAE;;4BACxB,IAAM,WAAW,GAAG,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;4BACvE,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,YAAY,CAAC,WAAW,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;4BACvE,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;;4BACzD,IAAM,WAAW,GAAG,mBAAmB,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;4BACpE,IAAI,WAAW,EAAE;gCACf,GAAG,CAAC,SAAS,CAAC,WAAW,EAAE,kBAAkB,CAAC,mBAAmB,CAAC,CAAC;6BACpE;iCAAM;gCACL,GAAG,CAAC,SAAS,CAAC,WAAW,EAAE,kBAAkB,CAAC,gBAAgB,CAAC,CAAC;6BACjE;4BACD,OAAO,IAAI,CAAC;yBACb;6BAAM;4BACL,OAAO,KAAK,CAAC;yBACd;oBAEH,KAAK,kBAAkB,CAAC,gBAAgB;wBACtC,IAAI,GAAG,CAAC,UAAU,CAAC,QAAQ,KAAK,IAAI,CAAC,SAAS,EAAE;4BAC9C,GAAG,CAAC,UAAU,CAAC,WAAW,GAAG,GAAG,CAAC,UAAU,CAAC,WAAW,GAAG,KAAK,CAAC;4BAChE,OAAO,IAAI,CAAC;yBACb;6BAAM;4BACL,WAAW,GAAG,aAAa,CAAC,yBAAyB,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;4BACtE,IAAI,WAAW,KAAK,IAAI,EAAE;;gCACxB,IAAM,WAAW,GAAG,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;gCACvE,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,YAAY,CAAC,WAAW,EAAE,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;gCACnF,OAAO,IAAI,CAAC;6BACb;iCAAM;gCACL,OAAO,KAAK,CAAC;6BACd;yBACF;oBAEH,KAAK,kBAAkB,CAAC,mBAAmB;wBACzC,IAAI,GAAG,CAAC,UAAU,CAAC,QAAQ,KAAK,IAAI,CAAC,SAAS,EAAE;4BAC9C,GAAG,CAAC,UAAU,CAAC,WAAW,GAAG,KAAK,GAAG,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC;4BAChE,OAAO,IAAI,CAAC;yBACb;6BAAM;4BACL,WAAW,GAAG,aAAa,CAAC,yBAAyB,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;4BACtE,IAAI,WAAW,KAAK,IAAI,EAAE;;gCACxB,IAAM,WAAW,GAAG,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;gCACvE,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,YAAY,CAAC,WAAW,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;gCACvE,OAAO,IAAI,CAAC;6BACb;iCAAM;gCACL,OAAO,KAAK,CAAC;6BACd;yBACF;oBAEH,KAAK,kBAAkB,CAAC,iBAAiB;wBACvC,WAAW,GAAG,IAAI,0BAA0B,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,4BAA4B,CAAC,GAAG,CAAC,CAAC;wBACnG,IAAI,WAAW,KAAK,IAAI,EAAE;;4BACxB,IAAM,WAAW,GAAG,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;4BACvE,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;4BACxC,OAAO,IAAI,CAAC;yBACb;6BAAM;4BACL,OAAO,KAAK,CAAC;yBACd;oBAEH,KAAK,kBAAkB,CAAC,oBAAoB;;wBAC1C,IAAM,IAAI,GAAG,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC;wBACxC,GAAG,CAAC,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,aAAa,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;wBACrH,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,oBAAoB,EAAE,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;wBAC9F,MAAM;oBAER;wBACE,MAAM,IAAI,KAAK,CAAC,8DAA2D,GAAG,CAAC,mBAAmB,EAAI,CAAC,CAAC;iBAC3G;gBAED,OAAO,IAAI,CAAC;;;;;;;QAGC,uCAAyB;;;;;sBAAC,GAAiB,EAAE,SAAoB;;gBAC9E,IAAM,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC,aAAa,CAAC;;gBAChD,IAAM,eAAe,GAAG,GAAG,CAAC,KAAK,EAAE,CAAC;gBACpC,eAAe,CAAC,SAAS,CAAC,UAAU,EAAE,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;gBAC5E,OAAO,IAAI,0BAA0B,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,4BAA4B,CAAC,eAAe,CAAC,CAAC;;4BA9G5G;QAgHC,CAAA;;;;;;AChHD,QAgBA;QAcE,0BAAoB,SAAmB;YAAnB,cAAS,GAAT,SAAS,CAAU;gCATxB,IAAI,SAAS,EAAE;oCACX,IAAI,mBAAmB,EAAE;YAS1C,IAAI,CAAC,mBAAmB,GAAG,IAAIA,YAAO,EAAa,CAAC;YACpD,IAAI,CAAC,YAAY,GAAG,IAAI,iBAAiB,EAAE,CAAC;SAC7C;;;;QAED,sCAAW;;;YAAX;gBACE,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,CAAC;aACxC;;;;;QAED,uCAAY;;;;YAAZ,UAAa,SAAoB;gBAC/B,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;gBAC9B,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;gBACzC,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;aACjD;;;;;;;;;;;;;;;;;;;QAiBD,kCAAO;;;;YAAP,UAAQ,UAAsB;gBAC5B,IAAI,MAAM,CAAC,YAAY,EAAE;;oBACvB,IAAI,aAAa,UAAY;oBAC7B,aAAa,GAAG,MAAM,CAAC,YAAY,EAAE,CAAC;oBACtC,kBAAkB,CAAC,gBAAgB,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,aAAa,CAAC,UAAU,EAAE,aAAa,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;oBACzI,kBAAkB,CAAC,gBAAgB,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,aAAa,CAAC,SAAS,EAAE,aAAa,CAAC,WAAW,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;oBACrI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;oBACrC,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE,CAAC;oBACpC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;iBAC1B;qBAAM;oBACL,MAAM,IAAI,KAAK,CAAC,2CAAyC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAG,CAAC,CAAC;iBAC/F;aACF;;;;;QAED,kCAAO;;;;YAAP,UAAQ,KAAoB;gBAC1B,OAAO,CAAC,GAAG,CAAC,eAAe,GAAG,KAAK,CAAC,GAAG,GAAG,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;gBAEnE,QAAQ,KAAK,CAAC,GAAG;oBACf,KAAK,SAAS;wBACZ,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;wBAC1B,MAAM;oBAER,KAAK,OAAO;wBACV,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;wBAC3B,MAAM;oBAER,KAAK,GAAG;wBACN,IAAI,IAAI,CAAC,aAAa,EAAE;;4BAEtB,OAAO,KAAK,CAAC;yBACd;6BAAM;4BACL,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;gCACxB,OAAO,KAAK,CAAC;6BACd;yBACF;wBACD,MAAM;oBAER,KAAK,SAAS,CAAC;oBACf,KAAK,WAAW;wBACd,OAAO,IAAI,CAAC;oBAEd,KAAK,YAAY;wBACf,IAAI,IAAI,CAAC,cAAc,EAAE;4BACvB,iBAAiB,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;yBACjH;6BAAM;4BACL,iBAAiB,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;4BAChH,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;yBACvJ;wBACD,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE,CAAC;wBACpC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;wBACzB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;wBACrC,OAAO,KAAK,CAAC;oBAEf,KAAK,WAAW;wBACd,IAAI,IAAI,CAAC,cAAc,EAAE;4BACvB,iBAAiB,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;yBAChH;6BAAM;4BACL,iBAAiB,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;4BACjH,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;yBAC3J;wBACD,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE,CAAC;wBACpC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;wBACzB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;wBACrC,OAAO,KAAK,CAAC;oBAEf,KAAK,WAAW;wBACd,IAAI,IAAI,CAAC,YAAY,CAAC,gBAAgB,EAAE,EAAE;4BACxC,aAAa,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;yBAClH;6BAAM;4BACL,aAAa,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;yBAC5G;wBACD,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;wBAC1J,IAAI,CAAC,6BAA6B,EAAE,CAAC;wBACrC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;wBACzB,OAAO,KAAK,CAAC;oBAEf,KAAK,QAAQ;wBACX,IAAI,IAAI,CAAC,YAAY,CAAC,gBAAgB,EAAE,EAAE;4BACxC,aAAa,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;yBACjH;6BAAM;4BACL,aAAa,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;yBAC5G;wBACD,IAAI,CAAC,6BAA6B,EAAE,CAAC;wBACrC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;wBACzB,OAAO,KAAK,CAAC;oBAEf,KAAK,OAAO;wBACV,OAAO,KAAK,CAAC;oBAEf;;wBACE,IAAM,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC;wBAC7B,IAAI,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE;4BAC/B,OAAO,KAAK,CAAC;yBACd;wBACD,MAAM;iBACT;gBAED,OAAO,IAAI,CAAC;aACb;;;;;QAED,gCAAK;;;;YAAL,UAAM,KAAoB;gBACxB,QAAQ,KAAK,CAAC,GAAG;oBACf,KAAK,SAAS;wBACZ,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;wBAC3B,MAAM;oBACR,KAAK,OAAO;wBACV,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE,CAAC;wBACpC,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;wBAC5B,MAAM;oBAER,KAAK,WAAW,CAAC;oBACjB,KAAK,YAAY;wBACf,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;wBACzB,MAAM;oBAER,KAAK,SAAS,CAAC;oBACf,KAAK,WAAW,CAAC;oBACjB,KAAK,WAAW,CAAC;oBACjB,KAAK,QAAQ,CAAC;oBACd,KAAK,OAAO,CAAC;oBACb,KAAK,SAAS,CAAC;oBACf,KAAK,OAAO;wBACV,MAAM;iBACT;gBAED,OAAO,IAAI,CAAC;aACb;;;;;QAED,iCAAM;;;;YAAN,UAAO,IAAY;gBACjB,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;gBACzB,OAAO,KAAK,CAAC;aACd;;;;QAED,iCAAM;;;YAAN;gBACE,KAAK,CAAC,QAAQ,CAAC,CAAC;gBAChB,OAAO,KAAK,CAAC;aACd;;;;;QAED,qCAAU;;;;YAAV,UAAW,KAAa;gBACtB,IAAI,KAAK,KAAK,EAAE,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE;oBACzD,OAAO,IAAI,CAAC;iBACb;;gBAED,IAAI,QAAQ,GAAG,KAAK,CAAC;gBAErB,IAAI,IAAI,CAAC,YAAY,CAAC,gBAAgB,EAAE,EAAE;oBACxC,QAAQ,GAAG,aAAa,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;iBACvJ;qBAAM;oBACL,QAAQ,GAAG,aAAa,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;iBACrJ;gBAED,IAAI,QAAQ,EAAE;;;;;oBAKZ,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;oBACtJ,IAAI,CAAC,6BAA6B,EAAE,CAAC;oBACrC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;oBACzB,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;oBAC/B,OAAO,IAAI,CAAC;iBACb;qBAAM;oBACL,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;oBACnC,OAAO,KAAK,CAAC;iBACd;aACF;;;;;;;QAGD,wCAAa;;;;;YAAb,UAAc,OAAuB;;gBACnC,IAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;gBAC3E,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;gBACzB,IAAI,CAAC,6BAA6B,EAAE,CAAC;;gBAErC,OAAO,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;aACnC;;;;;;QAMM,wCAAa;;;;;sBAAC,IAAY;gBAC/B,IAAI,QAAQ,CAAC,YAAY,EAAE;;oBACzB,IAAM,KAAK,GAAG,QAAQ,CAAC,YAAY,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;oBACpD,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,wBAAwB,CAAC,IAAI,CAAC,CAAC,CAAC;iBACxD;qBAAM;oBACL,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;iBACvD;gBACD,IAAI,CAAC,6BAA6B,EAAE,CAAC;gBACrC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;;;;;;;;;QAM3B,wCAAa;;;;YAAb;gBACE,IAAI,MAAM,CAAC,YAAY,EAAE;;oBACvB,IAAM,GAAG,GAAG,MAAM,CAAC,YAAY,EAAE,CAAC;oBAClC,IAAI,GAAG,CAAC,UAAU,IAAI,GAAG,CAAC,UAAU,EAAE;wBACpC,IAAI,CAAC,cAAc,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;wBACxC,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC;qBACpC;iBACF;qBAAM,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,IAAI,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE;oBACpE,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;iBAC9C;qBAAM;oBACL,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;iBAC5B;aACF;;;;;;;;QAKD,2CAAgB;;;;YAAhB;gBACE,IAAI,IAAI,CAAC,cAAc,EAAE;oBACvB,IAAI,MAAM,CAAC,YAAY,EAAE;;wBACvB,IAAM,GAAG,GAAG,MAAM,CAAC,YAAY,EAAE,CAAC;wBAClC,GAAG,CAAC,eAAe,EAAE,CAAC;wBACtB,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;wBAClC,OAAO,IAAI,CAAC;qBACb;yBAAM,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,oCAAoC;;wBAExE,OAAO,IAAI,CAAC;qBACb;iBACF;qBAAM;oBACL,OAAO,KAAK,CAAC;iBACd;aACF;;;;QAED,wDAA6B;;;YAA7B;gBACE,IAAI,CAAC,gBAAgB,CAAC,mBAAmB,CAAC,IAAI,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC;gBACjF,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;gBAChF,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,IAAI,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC;gBAC9E,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE,CAAC;aACrC;+BApSH;QAoTC;;;;;;ACpTD;;;;QAWE,iCAAsC,SAAmB;YAAnB,cAAS,GAAT,SAAS,CAAU;4BAFtC,IAAI,GAAG,EAA4B;SAEO;;;;QAE7D,uDAAqB;;;YAArB;;gBACE,IAAI,EAAE,GAAG,CAAC,CAAC;gBACX,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,EAAE;oBACvC,EAAE,EAAE,CAAC;iBACN;gBACD,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC;aACtB;;;;;QAED,kDAAgB;;;;YAAhB,UAAiB,SAAiB;;gBAChC,IAAI,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;gBAC3C,IAAI,OAAO,KAAK,SAAS,EAAE;oBACzB,OAAO,GAAG,IAAI,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;oBAC/C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;iBACvC;gBACD,OAAO,OAAO,CAAC;aAChB;;;;;QAED,sDAAoB;;;;YAApB,UAAqB,SAAiB;gBACpC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;aACjC;;oBA3BFC,aAAU,SAAC;wBACV,UAAU,EAAE,MAAM;qBACnB;;;;;wBAIkD,QAAQ,uBAA5CC,SAAM,SAACC,WAAQ;;;;sCAX9B;;;;;;;ACCA,IAKA,IAAA;QAGE,kBAAmB,KAAe;YAAf,UAAK,GAAL,KAAK,CAAU;YAChC,IAAI,CAAC,eAAe,GAAG,IAAI,uBAAuB,CAAC,KAAK,CAAC,CAAC;SAC3D;;;;;QAEM,wBAAK;;;;sBAAC,IAAY;gBACvB,IAAI,IAAI,KAAK,EAAE,EAAE;oBACf,OAAO,EAAE,CAAC;iBACX;;gBAKD,IAAM,SAAS,GAAG,IAAI,CAAC,4BAA4B,CAAC,IAAI,CAAC,CAAC;;gBAC1D,IAAM,SAAS,GAAG,IAAI,SAAS,EAAE,CAAC;;gBAClC,IAAM,MAAM,GAAG,SAAS,CAAC,eAAe,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;;gBAChE,IAAM,cAAc,GAAG,IAAI,QAAQ,EAAE,CAAC;gBACtC,IAAI,MAAM,CAAC,eAAe,KAAK,IAAI,EAAE;oBACnC,OAAO,EAAE,CAAC;iBACX;;gBAED,IAAM,IAAI,GAAG,IAAI,CAAC,4BAA4B,CAAC,MAAM,CAAC,eAAe,EAAE,cAAc,CAAC,CAAC;gBACvF,IAAI,IAAI,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY,EAAE;;oBAC/C,IAAM,GAAG,GAAG,mBAAC,IAAe,GAAE,SAAS,CAAC;oBACxC,OAAO,GAAG,CAAC;iBACZ;qBAAM;oBACL,MAAM,IAAI,KAAK,CAAC,eAAa,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,mBAAgB,CAAC,CAAC;iBACpF;;;;;;QAGK,+CAA4B;;;;sBAAC,IAAY;;gBAC/C,IAAM,SAAS,GAAG,IAAI,SAAS,EAAE,CAAC;;gBAClC,IAAM,MAAM,GAAG,SAAS,CAAC,eAAe,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;gBAC5D,IAAI,mBAAmB,EAAE,CAAC,mBAAmB,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;;gBACtE,IAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC;gBACxC,OAAO,SAAS,CAAC;;;;;;;QAGX,+CAA4B;;;;;sBAAC,IAAU,EAAE,cAAwB;gBACvE,QAAQ,IAAI,CAAC,QAAQ;oBACnB,KAAK,IAAI,CAAC,YAAY;;wBACpB,IAAM,SAAS,qBAAG,IAAe,EAAC;;wBAClC,IAAM,OAAO,GAAG,QAAQ,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;wBAElD,IAAI,CAAC,OAAO,IAAI,OAAO,KAAK,EAAE,EAAE;4BAC9B,MAAM,IAAI,KAAK,CAAC,mBAAiB,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAG,CAAC,CAAC;yBAC1E;;wBAGD,IAAM,UAAU,GAAG,cAAc,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;;wBAGzD,IAAM,QAAQ,GAAG,SAAS,CAAC,UAAU,CAAC;wBACtC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,qBAAqB,CAAC,EAAE;4BAC1F,UAAU,CAAC,WAAW,CAAC,cAAc,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC;yBAC3D;6BAAM;4BACL,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;;gCACxC,IAAM,WAAW,GAAG,IAAI,CAAC,4BAA4B,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;gCACnF,IAAI,WAAW,KAAK,SAAS,EAAE;oCAC7B,UAAU,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;iCACrC;6BACF;yBACF;;wBAGD,IAAI,CAAC,eAAe,CAAC,2BAA2B,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;wBAExE,OAAO,UAAU,CAAC;oBAEpB,KAAK,IAAI,CAAC,SAAS;;wBACjB,IAAM,OAAO,GAAG,mBAAC,IAAe,GAAE,WAAW,CAAC;wBAC9C,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;4BACtB,OAAO,cAAc,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;yBAC/C;6BAAM;4BACL,OAAO,SAAS,CAAC;yBAClB;oBAEH;;wBAEE,MAAM,IAAI,KAAK,CAAC,mCAAiC,IAAI,CAAC,QAAQ,mBAAc,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAG,CAAC,CAAC;iBACvH;;uBAxFL;QA0FC,CAAA;;;;;;AC1FD;QA+DE,mCAAoB,SAAoB,EAAU,aAAsC;YAApE,cAAS,GAAT,SAAS,CAAW;YAAU,kBAAa,GAAb,aAAa,CAAyB;+BArC1E,KAAK;+BA6BE,IAAIC,eAAY,EAAE;;uCAGjB,IAAI,mBAAmB,EAAE;SAK6C;QAnC5F,sBACI,6CAAM;;;gBADV;gBAEE,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,KAAK,SAAS,EAAE;oBAC/E,OAAO,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC;iBACxD;gBACD,OAAO,SAAS,CAAC;aAClB;;;WAAA;QAED,sBACI,sDAAe;;;;gBADnB,UACoB,KAAa;gBAC/B,IAAI,CAAC,KAAK,EAAE;oBACV,OAAO;iBACR;gBACD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;aACjE;;;WAAA;QAED,sBACI,gDAAS;;;;gBADb,UACc,KAAc;gBAC1B,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;aAC1B;;;WAAA;;;;QAkBD,+CAAW;;;YAAX,eAAgB;;;;QAEhB,+CAAW;;;YAAX,eAAsB;;;;QAEtB,+CAAW;;;YAAX;gBACE,IAAI,CAAC,aAAa,CAAC,aAAa,EAAE,CAAC;gBACnC,IAAI,OAAO,IAAI,CAAC,iBAAiB,KAAK,UAAU,EAAE;oBAChD,IAAI,CAAC,iBAAiB,EAAE,CAAC;iBAC1B;gBACD,OAAO;aACR;;;;QAED,8CAAU;;;YAAV;gBACE,IAAI,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAC;gBACtC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;aACrC;;;;QAED,2CAAO;;;YAAP,eAAY;;;;QAEZ,6CAAS;;;YAAT,eAAc;;;;;QAEd,2CAAO;;;;YAAP,UAAQ,UAAsB;gBAC5B,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;aAC/C;;;;;QAED,0CAAM;;;;YAAN,UAAO,IAAY;gBACjB,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;aACxC;;;;QAED,0CAAM;;;YAAN;gBACE,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC;aACpC;;;;;QAED,2CAAO;;;;YAAP,UAAQ,KAAoB;gBAC1B,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;aAC1C;;;;;QAED,yCAAK;;;;YAAL,UAAM,KAAoB;gBACxB,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;aACxC;;;;;;;;;;;;;;;;QAgBD,2CAAO;;;;YAAP,UAAQ,GAAW;gBACjB,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,EAAE;oBACvG,IAAI,GAAG,KAAK,SAAS,EAAE;wBACrB,OAAO;qBACR;;oBAED,IAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;;oBAC/D,IAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;;oBAClC,IAAM,eAAe,GAAG,GAAG,KAAK,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC;oBACjD,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,WAAW,EAAE,eAAe,CAAC,CAAC;iBACvF;aACF;;;;;;;;;;QAOD,oDAAgB;;;;;YAAhB,UAAiB,IAAS;gBACxB,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;aAC9B;;;;;;;;;QAKD,qDAAiB;;;;;YAAjB,UAAkB,IAAS;gBACzB,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;aAC/B;;;;;;;;;QAKD,8CAAU;;;;;YAAV,UAAW,KAAU;gBACnB,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE;oBACnD,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE,EAAE;wBACzD,KAAK,GAAG,SAAS,CAAC;qBACnB;oBAED,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;oBAEpB,IAAI,KAAK,KAAK,SAAS,EAAE;wBACvB,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,mBAAmB,GAAG,SAAS,CAAC;qBACjE;yBAAM;;wBACL,IAAM,EAAE,qBAAG,IAAI,CAAC,QAAQ,CAAC,aAAwB,EAAC;;wBAClD,IAAM,IAAI,qBAAG,EAAE,CAAC,UAAqB,EAAC;wBACtC,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,mBAAmB,GAAG,IAAI,CAAC;wBAC3D,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,mBAAmB,EAAE,kBAAkB,CAAC,oBAAoB,CAAC,CAAC;wBACjJ,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,mBAAmB,CAAC,CAAC;qBAChG;iBACF;aACF;;;;;;;;;;QAMD,mDAAe;;;;;YAAf,UAAgB,IAAY;gBAC1B,IAAI,OAAO,IAAI,CAAC,gBAAgB,KAAK,UAAU,EAAE;;oBAC/C,IAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;;oBAC/D,IAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;;oBACjC,IAAM,eAAe,GAAG,GAAG,KAAK,IAAI,GAAG,EAAE,GAAG,GAAG,CAAC;oBAChD,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,CAAC;iBACxC;gBACD,OAAO;aACR;;;;;;;;;QAKD,oDAAgB;;;;;YAAhB,UAAiB,UAAmB;;gBAClC,IAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC;;gBACxC,IAAM,MAAM,GAAG,UAAU,GAAG,UAAU,GAAG,aAAa,CAAC;gBACvD,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;aACzC;;oBAtLFC,YAAS,SAAC;wBACT,QAAQ,EAAE,aAAa;wBACvB,ylBAAkD;wBAElD,aAAa,EAAEC,oBAAiB,CAAC,IAAI;;wBACrC,SAAS,EAAE;4BACT;gCACE,OAAO,EAAEC,uBAAiB;gCAC1B,WAAW,EAAEC,aAAU,CAAC,cAAM,OAAA,yBAAyB,GAAA,CAAC;gCACxD,KAAK,EAAE,IAAI;6BACZ;yBACF;;qBACF;;;;;wBAnBsEC,YAAS;wBACvE,uBAAuB;;;;6BAuB7BC,QAAK,SAAC,QAAQ;sCAQdA,QAAK,SAAC,iBAAiB;gCAQvBA,QAAK,SAAC,WAAW;+BAKjBC,YAAS,SAAC,QAAQ;oCAElBA,YAAS,SAAC,eAAe;kCAGzBC,SAAM;;wCAtDT;;;;;;;ICAA,IAAA;gCAkBqB,IAA8B;YAC/C,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;;;;;;QAdd,qBAAM;;;;sBAAC,QAA0B;;gBAC7C,IAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,UAAC,EAAE,EAAE,EAAE;oBAClC,IAAI,EAAE,CAAC,OAAO,GAAG,EAAE,CAAC,OAAO,EAAE;wBAC3B,OAAO,CAAC,CAAC;qBACV;oBACD,IAAI,EAAE,CAAC,OAAO,GAAG,EAAE,CAAC,OAAO,EAAE;wBAC3B,OAAO,CAAC,CAAC,CAAC;qBACX;oBACD,OAAO,CAAC,CAAC;iBACV,CAAC,CAAC;gBACH,OAAO,MAAM,CAAC;;6BAflB;QAqBC,CAAA;;;;;;ACrBD,IAGA,IAAA;QACE,kCAAoB,QAA8B;YAA9B,aAAQ,GAAR,QAAQ,CAAsB;SAAI;;;;;QAEtD,iEAA8B;;;;YAA9B,UAA+B,gBAA8B;gBAC3D,IAAI,CAAC,gBAAgB,EAAE;oBACrB,OAAO,EAAE,CAAC;iBACX;;gBACD,IAAM,UAAU,GAAG,IAAI,CAAC,iCAAiC,CAAC,gBAAgB,CAAC,CAAC;;gBAC5E,IAAM,UAAU,GAAG,QAAQ,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC;;gBAC3D,IAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;gBAC9C,IAAI,OAAO,EAAE;;oBACX,IAAM,MAAM,GAAG,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;oBACpD,OAAO,MAAM,CAAC;iBACf;qBAAM;;oBAEL,OAAO,EAAE,CAAC;iBACX;aACF;;;;;QAED,oEAAiC;;;;YAAjC,UAAkC,gBAA8B;gBAC9D,IAAI,gBAAgB,EAAE;;oBACpB,IAAI,UAAU,GAAG,gBAAgB,CAAC,UAAU,CAAC;oBAE7C,QAAQ,UAAU,CAAC,QAAQ;wBACzB,KAAK,IAAI,CAAC,YAAY,CAAC;wBACvB,KAAK,IAAI,CAAC,SAAS;4BACjB,UAAU,GAAG,UAAU,CAAC,aAAa,CAAC;4BACtC,MAAM;wBAER,KAAK,IAAI,CAAC,YAAY;4BACpB,QAAQ,gBAAgB,CAAC,SAAS;gCAChC,KAAK,kBAAkB,CAAC,iBAAiB,CAAC;gCAC1C,KAAK,kBAAkB,CAAC,oBAAoB;oCAC1C,MAAM;gCAER,KAAK,kBAAkB,CAAC,gBAAgB,CAAC;gCACzC,KAAK,kBAAkB,CAAC,mBAAmB,CAAC;gCAC5C,KAAK,kBAAkB,CAAC,oBAAoB;oCAC1C,UAAU,GAAG,UAAU,CAAC,aAAa,CAAC;oCACtC,MAAM;gCAER;oCACE,MAAM,IAAI,KAAK,CAAC,6CAA0C,gBAAgB,CAAC,SAAS,WAAK,YAAY,CAAC,6BAA6B,CAAC,gBAAgB,CAAC,SAAS,CAAC,QAAI,CAAC,CAAC;6BACxK;4BACD,MAAM;wBAER;4BACE,MAAM,IAAI,KAAK,CAAC,sCAAmC,UAAU,CAAC,QAAQ,OAAG,CAAC,CAAC;qBAC9E;oBACD,OAAO,UAAU,CAAC;iBACnB;aACF;;;;;;;QAEM,qDAAkB;;;;;;sBAAC,OAAa,EAAE,wBAAkC,EAAE,KAAiB;;gBAAjB,sBAAA;oBAAA,SAAiB;;;gBAC5F,IAAI,YAAY,GAAa,EAAE,CAAC;;gBAChC,IAAI,WAAW,CAAS;gBAExB,IAAI,OAAO,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY,EAAE;;oBAC1C,IAAM,MAAM,qBAAG,OAAkB,EAAC;oBAClC,IAAI,MAAM,EAAE;wBACV,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS,EAAE;4BAClC,WAAW,GAAG,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;yBAC3C;qBACF;iBACF;gBAED,IAAI,WAAW,EAAE;;oBAEf,IAAI,wBAAwB,CAAC,MAAM,KAAK,CAAC,EAAE;wBACzC,IAAI,wBAAwB,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE;4BACxD,OAAO,YAAY,CAAC;yBACrB;wBACD,IAAI,KAAK,KAAK,CAAC,EAAE,CAEhB;6BAAM;4BACL,YAAY,GAAG,YAAY,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;4BAChD,OAAO,YAAY,CAAC;yBACrB;qBACF;oBACD,wBAAwB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;iBAC5C;;gBAED,IAAM,UAAU,qBAAG,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAW,EAAC;gBAE5E,KAAK,EAAE,CAAC;gBAER,UAAU,CAAC,OAAO,CAAC,UAAA,KAAK;oBACtB,IAAI,KAAK,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY,EAAE;;wBACxC,IAAM,SAAS,qBAAG,KAAgB,EAAC;wBACnC,IAAI,SAAS,EAAE;4BACb,QAAQ,SAAS,CAAC,SAAS;gCACzB,KAAK,aAAa,CAAC;gCACnB,KAAK,UAAU,CAAC;gCAChB,KAAK,QAAQ,CAAC;gCACd,KAAK,eAAe,CAAC;gCACrB,KAAK,WAAW;oCACd,YAAY,GAAG,YAAY,CAAC,MAAM,CAAC,KAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,wBAAwB,EAAE,KAAK,CAAC,CAAC,CAAC;oCACpG,MAAM;gCAER,KAAK,SAAS;;oCACZ,IAAM,OAAO,GAAG,SAAS,CAAC,UAAU,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;oCACzD,IAAI,OAAO,EAAE;;wCACX,IAAM,WAAW,GAAG,KAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;wCACrD,IAAI,WAAW,EAAE;4CACf,YAAY,GAAG,YAAY,CAAC,MAAM,CAAC,KAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,wBAAwB,EAAE,KAAK,CAAC,CAAC,CAAC;yCAC3G;6CAAM;4CACL,MAAM,IAAI,KAAK,CAAC,wBAAqB,OAAO,yBAAkB,SAAS,CAAC,SAAS,iBAAa,CAAC,CAAC;yCACjG;qCACF;yCAAM;wCACL,YAAY,GAAG,YAAY,CAAC,MAAM,CAAC,KAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,wBAAwB,EAAE,KAAK,CAAC,CAAC,CAAC;qCACrG;oCACD,MAAM;gCAER,KAAK,WAAW;oCACd,MAAM;gCAER;oCACE,MAAM,IAAI,KAAK,CAAC,mCAAgC,SAAS,CAAC,SAAS,WAAK,SAAS,CAAC,SAAW,CAAC,CAAC;6BAClG;yBACF;qBACF;iBACF,CAAC,CAAC;gBAEH,OAAO,YAAY,CAAC;;uCA9HxB;QAgIC,CAAA;;;;;;AChID;QA+CE,mCAAoB,aAAsC;YAAtC,kBAAa,GAAb,aAAa,CAAyB;iCAVnB,EAAE;SAUqB;QA7B9D,sBACI,6CAAM;;;gBADV;gBAEE,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,KAAK,SAAS,EAAE;oBAC/E,OAAO,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC;iBACxD;gBACD,OAAO,SAAS,CAAC;aAClB;;;WAAA;QAED,sBACI,sDAAe;;;;gBADnB,UACoB,KAAa;gBADjC,iBASC;gBAPC,IAAI,CAAC,KAAK,EAAE;oBACV,OAAO;iBACR;gBACD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;gBAChE,IAAI,CAAC,kCAAkC,GAAG,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,SAAS,CAAC,UAAA,GAAG;oBAC5F,KAAI,CAAC,aAAa,GAAG,KAAI,CAAC,4BAA4B,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;iBACtE,CAAC,CAAC;aACJ;;;WAAA;;;;;;;QAOD,iDAAa;;;;;YAAb,UAAc,OAAuB;;gBACnC,IAAM,IAAI,GAAG,IAAI,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;gBACzF,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;aACxC;;;;QAID,mDAAe;;;YAAf,eAA0B;;;;QAC1B,+CAAW;;;YAAX,eAAsB;;;;QAEtB,+CAAW;;;YAAX;gBACE,IAAI,CAAC,kCAAkC,CAAC,WAAW,EAAE,CAAC;aACvD;;;;;QAED,gEAA4B;;;;YAA5B,UAA6B,GAAiB;;gBAC5C,IAAM,eAAe,GAAG,IAAI,wBAAwB,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,8BAA8B,CAAC,GAAG,CAAC,CAAC;gBAEvI,OAAO,IAAI,CAAC,mBAAmB,EAAE;qBAC9B,GAAG,CAAC,UAAA,CAAC;oBACJ,yBAAO;wBACL,KAAK,EAAE,CAAC,CAAC,KAAK;wBACd,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAA,CAAC,IAAI,OAAA,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,GAAA,CAAC;qBAC/C,EAAC;iBAC1B,CAAC;qBACD,MAAM,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,GAAA,CAAC,CAAC;aACvC;;;;QAED,uDAAmB;;;YAAnB;gBAAA,iBAqBC;;gBApBC,IAAM,cAAc,GAAG,cAAc,CAAC,MAAM,CAC1C,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,UAAA,IAAI;oBAC3E,OAAA,KAAI,CAAC,aAAa,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,UAAA,KAAK,IAAI,OAAA,CAAC,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,GAAA,CAAC;iBAAA,CAClG,CACF,CAAC;;gBAEF,IAAM,kBAAkB,qBAAG;oBACzB,KAAK,EAAE,OAAO;oBACd,QAAQ,EAAE,cAAc;iBACF,EAAC;gBAEzB,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,aAAa;qBAC3C,GAAG,CAAC,UAAA,CAAC;oBACJ,yBAAO;wBACL,KAAK,EAAE,CAAC,CAAC,KAAK;wBACd,QAAQ,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,UAAA,WAAW,IAAI,OAAA,KAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,WAAW,CAAC,GAAA,CAAC,CAAC,MAAM,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,KAAK,SAAS,GAAA,CAAC,CAAC;qBACxI,EAAC;iBAC1B,CAAC;qBACD,MAAM,CAAC,kBAAkB,CAAC;qBAC1B,MAAM,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,GAAA,CAAC,CAAC;aACzC;;oBAhFFP,YAAS,SAAC;wBACT,QAAQ,EAAE,cAAc;wBACxB,s1TAAkD;;qBAEnD;;;;;wBAVQ,uBAAuB;;;;6BAc7BK,QAAK,SAAC,QAAQ;sCAQdA,QAAK,SAAC,iBAAiB;;wCA1B1B;;;;;;;ICAA,IAAA;iCAcqB,IAA+B;YAChD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YAC1B,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;;;;;QAG3B,gCAAM;;;YAAN;gBACE,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;oBACnD,OAAO,kBAAkB,CAAC,IAAI,CAAC;iBAChC;gBACD,OAAO,kBAAkB,CAAC,MAAM,CAAC;aAClC;8BAxBH;QAyBC,CAAA;AAzBD;;QA4BE,SAAU;QACV,OAAQ;QACR,SAAU;;0CAFV,MAAM;0CACN,IAAI;0CACJ,MAAM;;;;;;AC9BR,IAKA,IAAA;QACE,oCAAoB,SAAoB;YAApB,cAAS,GAAT,SAAS,CAAW;SAAI;;;;;QAE5C,qEAAgC;;;;YAAhC,UAAiC,gBAA8B;gBAC7D,IAAI,CAAC,gBAAgB,EAAE;oBACrB,OAAO,EAAE,CAAC;iBACX;;gBACD,IAAM,UAAU,GAAG,IAAI,CAAC,iCAAiC,CAAC,gBAAgB,CAAC,CAAC;;gBAC5E,IAAM,UAAU,GAAG,QAAQ,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC;gBAC3D,OAAO,IAAI,CAAC,2BAA2B,CAAC,UAAU,CAAC,CAAC;aACrD;;;;;QAED,sEAAiC;;;;YAAjC,UAAkC,gBAA8B;gBAC9D,IAAI,gBAAgB,EAAE;;oBACpB,IAAI,UAAU,GAAG,gBAAgB,CAAC,UAAU,CAAC;oBAE7C,QAAQ,UAAU,CAAC,QAAQ;wBACzB,KAAK,IAAI,CAAC,YAAY,CAAC;wBACvB,KAAK,IAAI,CAAC,SAAS;4BACjB,UAAU,GAAG,UAAU,CAAC,aAAa,CAAC;4BACtC,MAAM;wBAER,KAAK,IAAI,CAAC,YAAY;4BACpB,QAAQ,gBAAgB,CAAC,SAAS;gCAChC,KAAK,kBAAkB,CAAC,iBAAiB,CAAC;gCAC1C,KAAK,kBAAkB,CAAC,oBAAoB,CAAC;gCAC7C,KAAK,kBAAkB,CAAC,oBAAoB;oCAC1C,MAAM;gCAER,KAAK,kBAAkB,CAAC,gBAAgB,CAAC;gCACzC,KAAK,kBAAkB,CAAC,mBAAmB;oCACzC,UAAU,GAAG,UAAU,CAAC,aAAa,CAAC;oCACtC,MAAM;gCAER;oCACE,MAAM,IAAI,KAAK,CAAC,4CAAyC,gBAAgB,CAAC,SAAS,WAAK,YAAY,CAAC,6BAA6B,CAAC,gBAAgB,CAAC,SAAS,CAAC,QAAI,CAAC,CAAC;6BACvK;4BACD,MAAM;wBAER;4BACE,MAAM,IAAI,KAAK,CAAC,qCAAkC,UAAU,CAAC,QAAQ,OAAG,CAAC,CAAC;qBAC7E;oBACD,OAAO,UAAU,CAAC;iBACnB;aACF;;;;;QAED,gEAA2B;;;;YAA3B,UAA4B,WAAmB;;gBAC7C,IAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC;gBAClE,OAAO,IAAI,CAAC,uBAAuB,CAAC,OAAO,EAAE,IAAI,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;aAClE;;;;;;QAED,4DAAuB;;;;;YAAvB,UAAwB,OAAa,EAAE,oBAA+B;gBAAtE,iBAsCC;;gBArCC,IAAI,UAAU,GAAsB,EAAE,CAAC;gBAEvC,IAAI,OAAO,EAAE;oBACX,oBAAoB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;;oBAElC,IAAM,UAAU,GAAG,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;oBAElE,UAAU,CAAC,OAAO,CAAC,UAAA,KAAK;wBACtB,IAAI,OAAO,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY,EAAE;;4BAC1C,IAAM,SAAS,qBAAG,KAAgB,EAAC;4BACnC,IAAI,SAAS,EAAE;gCACb,IAAI,KAAK,CAAC,SAAS,KAAK,WAAW,EAAE;;oCAEnC,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC;wCAC7B,IAAI,eAAe,CAAC;4CAClB,UAAU,EAAE,SAAS,CAAC,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,KAAK;4CAC3D,QAAQ,EAAE,KAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC;4CAC7C,UAAU,EAAE,SAAS;4CACrB,WAAW,EAAE,KAAI,CAAC,cAAc,CAAC,SAAS,CAAC;4CAC3C,YAAY,EAAE,KAAI,CAAC,eAAe,CAAC,SAAS,CAAC;yCAC9C,CAAC;qCACH,CAAC,CAAC;iCACJ;qCAAM;;oCAEL,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;;wCACpC,IAAM,iBAAiB,GAAG,KAAI,CAAC,uBAAuB,CAAC,KAAK,EAAE,oBAAoB,CAAC,CAAC;wCACpF,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;qCACnD,AAEA;iCACF;6BACF;yBACF;qBACF,CAAC,CAAC;iBACJ;gBAED,OAAO,UAAU,CAAC;aACnB;;;;;;QAGO,oDAAe;;;;;sBAAC,SAAkB;;gBACxC,IAAM,MAAM,GAAG,SAAS,CAAC,UAAU,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;gBAC5D,IAAI,MAAM,KAAK,IAAI,EAAE;oBACnB,OAAO,MAAM,CAAC,KAAK,CAAC;iBACrB;gBACD,OAAO,SAAS,CAAC;;;;;;;QAIX,wDAAmB;;;;;sBAAC,SAAkB;;gBAC5C,IAAM,MAAM,GAAG,SAAS,CAAC,UAAU,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;;gBACxD,IAAM,KAAK,GAAG,MAAM,KAAK,IAAI,IAAI,MAAM,CAAC,KAAK,KAAK,UAAU,CAAC;gBAC7D,OAAO,KAAK,CAAC;;;;;;;;QAIP,mDAAc;;;;;;sBAAC,OAAgB,EAAE,cAA2B;;gBAA3B,+BAAA;oBAAA,mBAA2B;;;gBAClE,IAAI,MAAM,GAAa,EAAE,CAAC;;gBAE1B,IAAM,UAAU,GAAG,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;gBAClE,UAAU,CAAC,OAAO,CAAC,UAAA,KAAK;oBACtB,IAAI,OAAO,CAAC,QAAQ,KAAK,IAAI,CAAC,YAAY,EAAE;;wBAC1C,IAAM,SAAS,qBAAG,KAAgB,EAAC;wBACnC,IAAI,SAAS,EAAE;4BACb,IAAI,KAAK,CAAC,SAAS,KAAK,aAAa,EAAE;gCACrC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;6BAC5E;iCAAM;;gCAEL,IAAI,cAAc,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE;;oCACxC,IAAM,iBAAiB,GAAG,KAAI,CAAC,cAAc,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;oCACrE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;iCAC3C,AAEA;6BACF;yBACF;qBACF;iBACF,CAAC,CAAC;gBAEH,OAAO,MAAM,CAAC;;yCAxIlB;QA0IC,CAAA;;;;;;AC1ID;QAsCE,2CAAoB,aAAsC;YAAtC,kBAAa,GAAb,aAAa,CAAyB;+BAN5C,kBAAkB;8BAEI,EAAE;SAIwB;QApB9D,sBACI,8DAAe;;;;gBADnB,UACoB,KAAa;gBADjC,iBAUC;gBARC,IAAI,CAAC,KAAK,EAAE;oBACV,OAAO;iBACR;gBACD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;gBAChE,IAAI,CAAC,kCAAkC,GAAG,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,SAAS,CAAC,UAAA,GAAG;oBAC5F,KAAI,CAAC,UAAU,GAAG,KAAI,CAAC,yBAAyB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;oBAC/D,KAAI,CAAC,WAAW,GAAG,KAAI,CAAC,0BAA0B,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;iBAClE,CAAC,CAAC;aACJ;;;WAAA;;;;QAYD,oDAAQ;;;YAAR,eAAa;;;;QAEb,uDAAW;;;YAAX;gBACE,IAAI,CAAC,kCAAkC,CAAC,WAAW,EAAE,CAAC;aACvD;;;;;;QAED,iEAAqB;;;;;YAArB,UAAsB,GAAW,EAAE,KAAa;gBAC9C,IAAI,IAAI,CAAC,aAAa,EAAE;;oBACtB,IAAM,YAAY,GAAG,IAAI,uBAAuB,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;oBAClF,YAAY,CAAC,oBAAoB,CAAC,IAAI,CAAC,aAAa,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;iBACnE;aACF;;;;;QAED,sEAA0B;;;;YAA1B,UAA2B,GAAiB;;gBAC1C,IAAM,UAAU,GAAG,IAAI,0BAA0B,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;;gBACvF,IAAM,UAAU,qBAAG,UAAU,CAAC,iCAAiC,CAAC,GAAG,CAAY,EAAC;gBAChF,IAAI,UAAU,EAAE;oBACd,OAAO,QAAQ,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC;iBAChD;gBACD,OAAO,SAAS,CAAC;aAClB;;;;;QAED,qEAAyB;;;;YAAzB,UAA0B,GAAiB;;gBACzC,IAAM,YAAY,GAAG,IAAI,uBAAuB,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;;gBAClF,IAAM,UAAU,GAAG,IAAI,0BAA0B,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;;gBACvF,IAAM,UAAU,qBAAG,UAAU,CAAC,iCAAiC,CAAC,GAAG,CAAY,EAAC;gBAChF,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC;gBAChC,IAAI,UAAU,EAAE;;oBACd,IAAM,iBAAiB,GAAG,UAAU,CAAC,gCAAgC,CAAC,GAAG,CAAC,CAAC;oBAC3E,OAAO,iBAAiB,CAAC,GAAG,CAAC,UAAA,CAAC;wBAC5B,yBAAO;4BACL,KAAK,EAAE,CAAC;4BACR,KAAK,EAAE,YAAY,CAAC,yBAAyB,CAAC,UAAU,EAAE,CAAC,CAAC,UAAU,CAAC;yBACjD,EAAC;qBAC1B,CAAC,CAAC;iBACJ;gBACD,OAAO,EAAE,CAAC;aACX;;oBAnEFL,YAAS,SAAC;wBACT,QAAQ,EAAE,uBAAuB;wBACjC,sjCAA2D;;qBAE5D;;;;;wBAVQ,uBAAuB;;;;sCAc7BK,QAAK,SAAC,iBAAiB;;gDAlB1B;;;;;;;ACAA;QAkCE,iCAAoB,aAAsC;YAAtC,kBAAa,GAAb,aAAa,CAAyB;SAAI;QApB9D,sBACI,oDAAe;;;;gBADnB,UACoB,KAAa;gBADjC,iBAYC;gBAVC,IAAI,CAAC,KAAK,EAAE;oBACV,OAAO;iBACR;gBACD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;gBAChE,IAAI,CAAC,kCAAkC,GAAG,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,uBAAuB,CAAC,SAAS,CAAC,UAAA,GAAG;oBAC7G,KAAI,CAAC,aAAa,GAAG,GAAG,CAAC,QAAQ,CAAC,mBAAmB,EAAE,CAAC;iBACzD,CAAC,CAAC;gBACH,IAAI,CAAC,0BAA0B,GAAG,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,sBAAsB,CAAC,SAAS,CAAC,UAAA,IAAI;oBACrG,KAAI,CAAC,cAAc,GAAG,IAAI,CAAC;iBAC5B,CAAC,CAAC;aACJ;;;WAAA;;;;QAUD,0CAAQ;;;YAAR,eAAa;;;;QAEb,6CAAW;;;YAAX;gBACE,IAAI,CAAC,kCAAkC,CAAC,WAAW,EAAE,CAAC;gBACtD,IAAI,CAAC,0BAA0B,CAAC,WAAW,EAAE,CAAC;aAC/C;;oBAnCFL,YAAS,SAAC;wBACT,QAAQ,EAAE,YAAY;wBACtB,0SAAgD;;qBAEjD;;;;;wBAPQ,uBAAuB;;;;sCAW7BK,QAAK,SAAC,iBAAiB;;sCAd1B;;;;;;;ACAA;QAUE;yBAFkB,EAAE;SAEJ;;;;QAEhB,yCAAQ;;;YAAR,eAAa;;;;;QAEb,8CAAa;;;;YAAb,UAAc,SAAoB;gBAChC,IAAI,SAAS,KAAK,SAAS,EAAE;oBAC3B,IAAI,CAAC,KAAK,GAAG,CAAC,MAAM,CAAC,CAAC;iBACvB;qBAAM;;oBACL,IAAM,YAAY,GAAG,EAAE,CAAC;;oBACxB,IAAI,IAAI,GAAG,SAAS,CAAC,SAAS,CAAC;;oBAC/B,IAAI,UAAU,GAAG,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,IAAI,CAAC;oBACrD,OAAO,CAAC,UAAU,EAAE;wBAClB,QAAQ,IAAI,CAAC,QAAQ;4BACnB,KAAK,IAAI,CAAC,YAAY;;gCACpB,IAAM,SAAS,qBAAG,IAAe,EAAC;gCAClC,IAAI,SAAS,KAAK,SAAS,EAAE;;oCAC3B,IAAM,MAAI,GAAG,SAAS,CAAC,YAAY,CAAC,cAAc,CAAC,CAAC;oCACpD,IAAI,SAAS,CAAC,SAAS,KAAK,yBAAyB,EAAE;wCACrD,UAAU,GAAG,IAAI,CAAC;qCACnB;yCAAM;wCACL,YAAY,CAAC,OAAO,CAAC,MAAI,CAAC,CAAC;qCAC5B;iCACF;yBACJ;wBACD,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC;wBAC1B,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,IAAI,IAAI,EAAE;4BACtC,UAAU,GAAG,IAAI,CAAC;yBACnB;qBACF;oBACD,IAAI,CAAC,KAAK,GAAG,YAAY,CAAC;iBAC3B;aACF;;oBAvCFL,YAAS,SAAC;wBACT,QAAQ,EAAE,qBAAqB;wBAC/B,uGAA8C;;qBAE/C;;;;qCAND;;;;;;;ACAA;;;;oBASCQ,WAAQ,SAAC;wBACR,OAAO,EAAE,CAACC,eAAY,EAAEC,iBAAW,EAAEC,yBAAmB,CAAC;wBACzD,YAAY,EAAE,CAAC,yBAAyB,EAAE,yBAAyB,EAAE,iCAAiC,EAAE,uBAAuB,EAAE,sBAAsB,CAAC;wBACxJ,OAAO,EAAE,CAAC,yBAAyB,EAAE,yBAAyB,EAAE,iCAAiC,EAAE,uBAAuB,EAAE,sBAAsB,CAAC;qBACpJ;;qCAbD;;;;;;;ACAA,QAAA;2BAC4B,QAA8B;YAA9B,aAAQ,GAAR,QAAQ,CAAsB;;;;;;QAExD,yCAAqB;;;;YAArB,UAAsB,OAAe;gBACnC,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;aACnC;wBALH;QAMC;;;;;;ACND,QAEA;iCAGqB,aAAqB;;YACtC,IAAI,CAAC,aAAa,IAAI,aAAa,KAAK,EAAE,EAAE;gBAC1C,OAAO;aACR;;YACD,IAAM,SAAS,GAAG,IAAI,SAAS,EAAE,CAAC;;YAClC,IAAM,SAAS,GAAG,SAAS,CAAC,eAAe,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;;YAIvE,IAAI,MAAM,GAAW,EAAE,CAAC;;YACxB,IAAM,iBAAiB,qBAAG,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,UAAU,CAAc,EAAC;YACxF,iBAAiB,CAAC,OAAO,CAAC,UAAA,CAAC;;gBACzB,IAAM,SAAS,GAAG,KAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;gBACzC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;aACnC,CAAC,CAAC;YACH,IAAI,CAAC,SAAS,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,WAAW,mBAAC,MAAmB,EAAC,CAAC,CAAC;;;;;;QAGhE,wCAAc;;;;sBAAC,IAAU;;;gBAC/B,IAAI,MAAM,GAAW,EAAE,CAAC;gBACxB,IAAI,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE;oBAC7B,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;iBAC9B;;gBAED,IAAM,QAAQ,qBAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAW,EAAC;gBACvD,QAAQ,CAAC,OAAO,CAAC,UAAA,KAAK;oBACpB,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,KAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC;iBACpD,CAAC,CAAC;gBAEH,OAAO,MAAM,CAAC;;;;;;QAGR,wCAAc;;;;sBAAC,IAAU;;gBAC/B,IAAM,eAAe,GAAG,CAAC,SAAS,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC;;gBAC5D,IAAM,MAAM,qBAAG,IAAe,EAAC;gBAE/B,IAAI,MAAM,EAAE;oBACV,IAAI,eAAe,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE;wBAC9C,IAAI,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE;;4BAE1C,OAAO,IAAI,CAAC;yBACb;6BAAM;4BACL,OAAO,KAAK,CAAC;yBACd;qBACF;yBAAM;wBACL,OAAO,KAAK,CAAC;qBACd;iBACF;qBAAM;oBACL,OAAO,KAAK,CAAC;iBACd;;;;;;QAGK,qCAAW;;;;sBAAC,WAAsB;;gBAExC,OAAO,IAAI,GAAG,CAAC,WAAW,CAAC,GAAG,CAAoB,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,CAAC,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,KAAK,oBAAE,CAAY,EAAC,GAAA,CAAC,CAAC,CAAC;;8BA3DrH;QA6DC;;;;;;IC3DD,IAAA;0BAC4B,YAAyC;YAAzC,iBAAY,GAAZ,YAAY,CAA6B;;uBAHrE;QAIC,CAAA;;;;;;ACJD,QAMA;iCAG6B,MAAiB,EAAU,qBAA+B;YAA1D,WAAM,GAAN,MAAM,CAAW;YAAU,0BAAqB,GAArB,qBAAqB,CAAU;YACnF,IAAI,CAAC,KAAK,GAAG,IAAI,QAAQ,CAAC,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;;;;;;QAG5F,gDAAsB;;;;sBAAC,IAAU;;gBACvC,IAAM,OAAO,GAAG,QAAQ,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;gBAClD,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;;;;;;QAGnC,gDAAsB;;;;sBAAC,QAAmB;;gBAChD,OAAO,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAA2B,UAAA,OAAO,IAAI,OAAA,CAAC,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,KAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC,GAAA,CAAC,CAAC,CAAC;;;;;;QAGrJ,kDAAwB;;;;sBAAC,OAAgB;gBAC/C,IAAI,OAAO,EAAE;;oBACX,IAAM,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC;oBAC9D,OAAO,IAAI,cAAc,CAAC;wBACxB,OAAO,EAAE,OAAO;wBAChB,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;wBAClC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;qBAE7B,CAAC,CAAC;iBACJ;qBAAM;oBACL,OAAO,SAAS,CAAC;iBAClB;;;;;;QAGK,iCAAO;;;;sBAAC,OAAa;gBAC3B,IAAI,IAAI,0BAA0B,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,0BAA0B,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE;oBACrG,OAAO,KAAK,CAAC;iBACd;gBACD,OAAO,IAAI,CAAC;;;;;;QAGN,oCAAU;;;;sBAAC,OAAe;gBAChC,OAAO,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;;8BA5CxD;QA8CC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}