qms-angular 1.0.36 → 1.0.40

package/esm2015/lib/qms-ckeditor-components/services/qms-ckeditor-bpmn.service.js

@@ -0,0 +1,1156 @@
+/* eslint-disable no-use-before-define */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable no-param-reassign */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-shadow */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-new */
+import { Injectable } from '@angular/core';
+import * as $ from 'jquery';
+import * as _ from 'lodash';
+import InspectorFunction from '../common/bpmn/inspector.function';
+import ToolbarFunction from '../common/bpmn/toolbar.function';
+import { FlowChartConst } from '../common/constants/ckeditorFlowchart.const';
+import { FlowchartViewMode } from '../common/enums/flowchart-view-mode.enum';
+import * as i0 from "@angular/core";
+let graph;
+let paper;
+let toolbarConfig;
+const bpmn2 = joint.shapes.bpmn2;
+export class BpmnService {
+    constructor() {
+        this.isSaveAsTemplate = false;
+        this.isDeleteTemplate = false;
+        this.isDisableToolbar = false;
+        this.isTemp = true;
+        this.jsonTempContent = '';
+        this.isReset = false;
+        this.isSelectedTemplate = false;
+        this.jsonOriginalContent = '';
+    }
+    buildDiagram(diagramTemplates, diagramTemplate, bpmnTheme, jsonContent, editMode, LANG) {
+        window[`IS_NOT_SHOW_AGAIN`] = false;
+        window[FlowChartConst.EDIT_MODE] = editMode;
+        joint.setTheme(bpmnTheme);
+        if (jsonContent) {
+            jsonContent = JSON.parse(jsonContent);
+        }
+        else {
+            jsonContent = '';
+        }
+        const gdAuth = window[`gdAuth`];
+        const gdLoad = window[`gdLoad`];
+        const gdSave = window[`gdSave`];
+        const inputs = InspectorFunction.getInspectorConfiguration(bpmn2, LANG);
+        let freeTransform = null;
+        toolbarConfig = ToolbarFunction.getToolbarConfiguration(LANG);
+        /* QMS-1404: Customization: Add template list */
+        if (toolbarConfig.tools && diagramTemplates) {
+            const arrSelect = toolbarConfig.tools.filter((item) => {
+                return item.type === 'select-box';
+            });
+            if (arrSelect) {
+                diagramTemplates.forEach((item) => {
+                    const option = {
+                        index: item.index,
+                        content: item.templateName,
+                        flowChartId: item.id,
+                        name: item.templateName,
+                        jsonContent: item.jsonContent,
+                        selected: false
+                    };
+                    const index = arrSelect[0].options.findIndex((x) => {
+                        return x.index === option.index;
+                    });
+                    if (index < 0) {
+                        arrSelect[0].options.push(option);
+                    }
+                });
+            }
+        }
+        graph = new joint.dia.Graph({ type: 'bpmn' });
+        const commandManager = new joint.dia.CommandManager({ graph });
+        const keyboard = new joint.ui.Keyboard();
+        const clipboard = new joint.ui.Clipboard();
+        paper = new joint.dia.Paper({
+            width: 800,
+            height: 600,
+            model: graph,
+            gridSize: 10,
+            drawGrid: true,
+            async: true,
+            sorting: joint.dia.Paper.sorting.APPROX,
+            interactive: { linkMove: false },
+            snapLabels: true,
+            // Connections
+            defaultLink(elementView) {
+                return new bpmn2.Flow({
+                    z: elementView.model.get('z') - 1,
+                    attrs: {
+                        line: {
+                            flowType: 'sequence'
+                        }
+                    }
+                });
+            },
+            validateConnection(cellViewS, magnetS, cellViewT, magnetT, end) {
+                const source = cellViewS.model;
+                const target = cellViewT.model;
+                // don't allow loop links
+                if (source === target) {
+                    return false;
+                }
+                // don't allow link to link connection
+                if (source.isLink()) {
+                    return false;
+                }
+                if (target.isLink()) {
+                    return false;
+                }
+                // don't allow group connections
+                const sourceType = source.get('type');
+                const targetType = target.get('type');
+                if (sourceType === 'bpmn2.Group' || targetType === 'bpmn2.Group') {
+                    return false;
+                }
+                return true;
+            },
+            defaultAnchor: {
+                name: 'perpendicular'
+            },
+            defaultConnectionPoint: {
+                name: 'boundary',
+                args: { stroke: true }
+            },
+            // Embedding
+            embeddingMode: true,
+            frontParentOnly: false,
+            validateEmbedding(childView, parentView) {
+                const parentType = parentView.model.get('type');
+                const childType = childView.model.get('type');
+                if (parentType === 'bpmn2.HeaderedPool' && childType !== 'bpmn2.HeaderedPool') {
+                    return true;
+                }
+                if (parentType === 'bpmn2.Activity' && childType === 'bpmn2.Event') {
+                    return true;
+                }
+                return false;
+            },
+            // Highlighting
+            highlighting: {
+                default: {
+                    name: 'mask',
+                    options: {
+                        attrs: {
+                            stroke: '#3498db',
+                            'stroke-width': 3,
+                            'stroke-linejoin': 'round'
+                        }
+                    }
+                }
+            }
+        }).on({
+            'blank:pointerdown': (evt, x, y) => {
+                closeTools();
+                // selection.startSelecting(evt, x, y);
+                if (keyboard.isActive('shift', evt)) {
+                    selection.startSelecting(evt, x, y);
+                }
+                else {
+                    selection.cancelSelection();
+                    paperScroller.startPanning(evt, x, y);
+                }
+            },
+            'blank:contextmenu': (evt, x, y) => {
+                paperScroller.startPanning(evt, x, y);
+            },
+            'cell:pointerup': (cellView) => {
+                openTools(cellView);
+            },
+            'link:mouseenter': (linkView) => {
+                // Open tool only if there is none yet
+                if (linkView.hasTools()) {
+                    return;
+                }
+                const ns = joint.linkTools;
+                const toolsView = new joint.dia.ToolsView({
+                    name: 'link-hover',
+                    tools: [
+                        new ns.Vertices({ vertexAdding: false }),
+                        new ns.SourceArrowhead(),
+                        new ns.TargetArrowhead()
+                    ]
+                });
+                linkView.addTools(toolsView);
+            },
+            'link:mouseleave': (linkView) => {
+                // Remove only the hover tool, not the pointerdown tool
+                if (linkView.hasTools('link-hover')) {
+                    linkView.removeTools();
+                }
+            },
+            'link:connect': (linkView) => {
+                // Change the link type based on the connected elements
+                const link = linkView.model;
+                const source = link.getSourceCell();
+                const target = link.getTargetCell();
+                if (!source || !target) {
+                    return;
+                }
+                link.set('z', -1);
+                const types = [source.get('type'), target.get('type')];
+                const linkType = link.get('type');
+                if (types.indexOf('bpmn2.Annotation') > -1) {
+                    if (linkType === 'bpmn2.AnnotationLink') {
+                        return;
+                    }
+                    replaceLink(graph, link, bpmn2.AnnotationLink);
+                    return;
+                }
+                if (types.indexOf('bpmn2.Conversation') > -1) {
+                    if (linkType === 'bpmn2.ConversationLink') {
+                        return;
+                    }
+                    replaceLink(graph, link, bpmn2.ConversationLink);
+                    return;
+                }
+                if (types.indexOf('bpmn2.DataObject') > -1) {
+                    if (linkType === 'bpmn2.DataAssociation') {
+                        return;
+                    }
+                    replaceLink(graph, link, bpmn2.DataAssociation);
+                    return;
+                }
+                if (types.indexOf('bpmn2.DataStore') > -1) {
+                    if (linkType === 'bpmn2.DataAssociation') {
+                        return;
+                    }
+                    replaceLink(graph, link, bpmn2.DataAssociation);
+                    return;
+                }
+                if (linkType !== 'bpmn2.Flow') {
+                    replaceLink(graph, link, bpmn2.Flow);
+                }
+            }
+        });
+        const snaplines = new joint.ui.Snaplines({ paper });
+        const paperScroller = new joint.ui.PaperScroller({
+            autoResizePaper: true,
+            padding: 20,
+            paper,
+            scrollWhileDragging: true
+        });
+        paperScroller.$el.appendTo('#paper-container');
+        paperScroller.setCursor('grab');
+        paperScroller.render().center();
+        paper.on('blank:mousewheel', _.partial(onMousewheel, null), this);
+        paper.on('cell:mousewheel', onMousewheel, this);
+        function onMousewheel(cellView, evt, x, y, delta) {
+            paperScroller.zoom(delta * 0.1, { min: 0.2, max: 5, grid: 0.1, ox: x, oy: y });
+        }
+        /* SELECTION */
+        const selection = new joint.ui.Selection({
+            paper,
+            graph,
+            useModelGeometry: true,
+            filter: ['bpmn2.HeaderedPool'] // don't allow to select a pool
+        });
+        /* STENCIL */
+        const stencil = new joint.ui.Stencil({
+            graph,
+            paper,
+            width: '100%',
+            height: '100%',
+            dragEndClone(cell) {
+                const clone = cell.clone();
+                const type = clone.get('type');
+                // some types of the elements need resizing after they are dropped
+                const sizeMultiplier = { 'bpmn2.HeaderedPool': 8, 'bpmn.Choreography': 2 }[type];
+                if (sizeMultiplier) {
+                    const originalSize = clone.get('size');
+                    clone.set('size', {
+                        width: originalSize.width * sizeMultiplier,
+                        height: originalSize.height * sizeMultiplier
+                    });
+                    if (type === 'bpmn2.HeaderedPool') {
+                        clone.set('padding', { top: 0, left: 30, right: 0, bottom: 0 });
+                    }
+                }
+                return clone;
+            }
+        });
+        stencil.render().$el.appendTo('#stencil-container');
+        stencil.load([
+            new bpmn2.Activity({
+                attrs: {
+                    label: {
+                        stroke: 'white',
+                        strokeWidth: 2,
+                        paintOrder: 'stroke'
+                    }
+                }
+            }),
+            new bpmn2.Gateway({
+                attrs: {
+                    label: {
+                        stroke: 'white',
+                        strokeWidth: 2,
+                        paintOrder: 'stroke'
+                    }
+                }
+            }),
+            new bpmn2.Event({
+                attrs: {
+                    label: {
+                        stroke: 'white',
+                        strokeWidth: 2,
+                        paintOrder: 'stroke'
+                    }
+                }
+            }),
+            new bpmn2.Conversation({
+                attrs: {
+                    label: {
+                        stroke: 'white',
+                        strokeWidth: 2,
+                        paintOrder: 'stroke'
+                    }
+                }
+            }),
+            new bpmn2.DataObject({
+                attrs: {
+                    label: {
+                        stroke: 'white',
+                        strokeWidth: 2,
+                        paintOrder: 'stroke'
+                    }
+                }
+            }),
+            new bpmn2.DataStore({
+                attrs: {
+                    label: {
+                        stroke: 'white',
+                        strokeWidth: 2,
+                        paintOrder: 'stroke'
+                    }
+                }
+            }),
+            new bpmn2.Annotation({
+                attrs: {
+                    body: {
+                        fill: '#ffffff'
+                    },
+                    label: {
+                        stroke: 'white',
+                        strokeWidth: 2,
+                        paintOrder: 'stroke'
+                    }
+                }
+            }),
+            new bpmn2.Group({
+                size: {
+                    width: 80,
+                    height: 80
+                },
+                attrs: {
+                    label: {
+                        text: 'Group',
+                        stroke: 'white',
+                        strokeWidth: 2,
+                        paintOrder: 'stroke'
+                    }
+                }
+            }),
+            // Legacy BPMN Shapes
+            new bpmn2.HeaderedPool({
+                padding: { top: 0, left: 15, right: 0, bottom: 0 },
+                size: { width: 80, height: 50 },
+                lanes: [{ label: 'Lane 1' }, { label: 'Lane 2' }],
+                attrs: {
+                    body: { fill: '#FFFFFF' },
+                    headerLabel: { text: 'Header' }
+                }
+            }),
+            new joint.shapes.bpmn.Choreography({
+                participants: ['Participant 1', 'Participant 2'],
+                attrs: {
+                    label: {
+                        stroke: 'white',
+                        strokeWidth: 2,
+                        paintOrder: 'stroke'
+                    }
+                }
+            }),
+            new joint.shapes.bpmn.Message({
+                attrs: {
+                    text: {
+                        stroke: 'white',
+                        strokeWidth: 2,
+                        paintOrder: 'stroke'
+                    }
+                }
+            })
+        ]);
+        joint.layout.GridLayout.layout(stencil.getGraph(), {
+            columns: 100,
+            columnWidth: 'compact',
+            marginX: 20,
+            marginY: 20,
+            columnGap: 40,
+            verticalGap: 20,
+            resizeToFit: false
+        });
+        // Create tooltips for all the shapes in stencil.
+        stencil.on('element:drop', (elementView) => {
+            // open inspector after a new element dropped from stencil
+            openTools(elementView);
+        });
+        /* KEYBOARD */
+        if (editMode === FlowchartViewMode.Edit) {
+            initializeKeyboardShortcuts();
+        }
+        function initializeKeyboardShortcuts() {
+            keyboard.on({
+                'ctrl+c': () => {
+                    // Copy all selected elements and their associated links.
+                    clipboard.copyElements(selection.collection, graph);
+                },
+                'ctrl+v': () => {
+                    const pastedCells = clipboard.pasteCells(graph, {
+                        translate: { dx: 20, dy: 20 },
+                        useLocalStorage: true
+                    });
+                    const elements = _.filter(pastedCells, (cell) => {
+                        return cell.isElement();
+                    });
+                    // Make sure pasted elements get selected immediately. This makes the UX better as
+                    // the user can immediately manipulate the pasted elements.
+                    selection.collection.reset(elements);
+                },
+                'ctrl+x shift+delete': () => {
+                    clipboard.cutElements(selection.collection, graph);
+                },
+                'delete backspace': (evt) => {
+                    evt.preventDefault();
+                    graph.removeCells(selection.collection.toArray());
+                },
+                'ctrl+z': () => {
+                    commandManager.undo();
+                    selection.cancelSelection();
+                },
+                'ctrl+y': () => {
+                    commandManager.redo();
+                    selection.cancelSelection();
+                },
+                'ctrl+a': () => {
+                    selection.collection.reset(graph.getElements());
+                },
+                'ctrl+plus': (evt) => {
+                    evt.preventDefault();
+                    paperScroller.zoom(0.2, { max: 5, grid: 0.2 });
+                },
+                'ctrl+minus': (evt) => {
+                    evt.preventDefault();
+                    paperScroller.zoom(-0.2, { min: 0.2, grid: 0.2 });
+                },
+                'keydown:shift': (evt) => {
+                    paperScroller.setCursor('crosshair');
+                },
+                'keyup:shift': () => {
+                    paperScroller.setCursor('grab');
+                }
+            }, this);
+        }
+        function openTools(cellView) {
+            if (!cellView) {
+                return;
+            }
+            closeTools();
+            window[`my_cellView`] = cellView;
+            const cell = cellView.model;
+            const type = cell.get('type');
+            // const tablName = window[FlowChartConst.TAB_NAME];
+            // if (tablName === FlowChartConst.TAB_BPMN_CHOREOGRAPHY) {
+            //   const inspector = joint.ui.Inspector.create('#inspector-container', {
+            //     cell,
+            //     inputs: inputs[type],
+            //     groups: {
+            //       general: { label: type, index: 1 },
+            //       defaults: { index: 2 },
+            //       fontsize: { index: 3 },
+            //       appearance: { index: 4 }
+            //     }
+            //   });
+            // }
+            const inspector = joint.ui.Inspector.create('#inspector-container', {
+                cell,
+                inputs: inputs[type],
+                groups: {
+                    general: { label: type, index: 1 },
+                    defaults: { index: 2 },
+                    fontsize: { index: 3 },
+                    appearance: { index: 4 }
+                }
+            });
+            selection.collection.reset([]);
+            // Add the cell into the selection collection silently
+            // so no selection box is rendered above the cellView.
+            selection.collection.add(cell, { silent: true });
+            if (cell.isElement()) {
+                let minSize;
+                if (cell instanceof bpmn2.HeaderedPool) {
+                    minSize = cell.getMinimalSize();
+                }
+                else {
+                    minSize = { width: 30, height: 30 };
+                }
+                freeTransform = new joint.ui.FreeTransform({
+                    cellView,
+                    allowOrthogonalResize: false,
+                    allowRotation: false,
+                    minWidth: minSize.width,
+                    minHeight: minSize.height
+                }).render();
+                const halo = new joint.ui.Halo({
+                    cellView,
+                    theme: 'default',
+                    type: 'toolbar',
+                    useModelGeometry: true,
+                    boxContent: (cellView) => {
+                        return cellView.model.get('type');
+                    }
+                });
+                if (type === 'bpmn2.HeaderedPool') {
+                    halo.removeHandle('link');
+                    halo.removeHandle('fork');
+                    halo.removeHandle('unlink');
+                }
+                halo.render();
+            }
+            if (cell.isLink()) {
+                const ns = joint.linkTools;
+                const toolsView = new joint.dia.ToolsView({
+                    name: 'link-pointerdown',
+                    tools: [
+                        new ns.Vertices(),
+                        new ns.SourceAnchor(),
+                        new ns.TargetAnchor(),
+                        new ns.SourceArrowhead(),
+                        new ns.TargetArrowhead(),
+                        new ns.Segments(),
+                        new ns.Boundary({ padding: 15 }),
+                        new ns.Remove({ offset: -20, distance: 40 })
+                    ]
+                });
+                cellView.addTools(toolsView);
+            }
+            /* QMS-2364: show link and poiter change to hand */
+            // if (window[`event`][`type`] === 'mouseover' && editMode === FlowchartViewMode.View) {
+            //   const list = document.getElementsByClassName(`joint-element`);
+            //   if (list && list.length > 0) {
+            //     const shapeId = cellView.model.attributes.id;
+            //     // tslint:disable-next-line:prefer-for-of
+            //     for (let i = 0; i < list.length; i++) {
+            //       if (list[i].attributes[0].nodeValue !== shapeId) {
+            //         list[i][`style`].cursor = 'move';
+            //         continue;
+            //       }
+            //       const shapeDetailModel = window[`SHAPE_DETAIL_MODEL`];
+            //       if (!shapeDetailModel) {
+            //         list[i][`style`].cursor = 'move';
+            //         continue;
+            //       }
+            //       const index = shapeDetailModel.findIndex((x) => {
+            //         return x.shapeId === shapeId;
+            //       });
+            //       if (index < 0) {
+            //         list[i][`style`].cursor = 'move';
+            //         continue;
+            //       }
+            //       const shapeDetail = shapeDetailModel[index];
+            //       let connectionName = '';
+            //       if (shapeDetail.connectionTypeId === ShapeFlowChartConnectionType.Activity) {
+            //         list[i][`style`].cursor = 'move';
+            //         connectionName = translate.instant('PROCESS.LINK_TO_ACTIVITY');
+            //       } else if (shapeDetail.connectionTypeId === ShapeFlowChartConnectionType.Link) {
+            //         connectionName = translate.instant('PROCESS.LINK');
+            //       } else if (shapeDetail.connectionTypeId === ShapeFlowChartConnectionType.DocumentOrProcess) {
+            //         // eslint-disable-next-line default-case
+            //         switch (shapeDetail.documentModel.relatedItems[0].itemType) {
+            //           case RelatedItemType.document:
+            //             connectionName = translate.instant('PROCESS.LINK_TO_DOCUMENT');
+            //             break;
+            //           case RelatedItemType.process:
+            //             connectionName = translate.instant('PROCESS.LINK_TO_PROCESS');
+            //             break;
+            //           case RelatedItemType.area:
+            //             connectionName = translate.instant('PROCESS.LINK_TO_AREA');
+            //             break;
+            //           case RelatedItemType.handbook:
+            //             connectionName = translate.instant('PROCESS.LINK_TO_FOLDER');
+            //             break;
+            //         }
+            //       }
+            //       if (shapeDetail.connectionTypeId !== ShapeFlowChartConnectionType.Activity) {
+            //         list[i][`style`].cursor = 'pointer';
+            //       }
+            //       const halo = new joint.ui.Halo({
+            //         cellView,
+            //         theme: 'default',
+            //         boxContent: connectionName
+            //       });
+            //       halo.render();
+            //       halo.removeHandle('remove');
+            //       halo.removeHandle('resize');
+            //       halo.removeHandle('clone');
+            //       halo.removeHandle('link');
+            //       halo.removeHandle('fork');
+            //       halo.removeHandle('unlink');
+            //       halo.removeHandle('rotate');
+            //     }
+            //   }
+            //   const shapeElement = document.getElementsByClassName('no-rotation');
+            //   if (shapeElement && shapeElement.length > 0) {
+            //     for (let i = 0; i < shapeElement.length; i++) {
+            //       if (!shapeElement[i].classList.contains('joint-free-transform')) {
+            //         shapeElement[i].classList.add('joint-free-transform');
+            //       }
+            //     }
+            //   }
+            // } else if (window[`event`][`type`] === 'mouseout' && editMode === FlowchartViewMode.View) {
+            //   const halo = new joint.ui.Halo({
+            //     cellView,
+            //     theme: 'default',
+            //     boxContent: ''
+            //   });
+            //   halo.render();
+            //   halo.removeHandle('remove');
+            //   halo.removeHandle('resize');
+            //   halo.removeHandle('clone');
+            //   halo.removeHandle('link');
+            //   halo.removeHandle('fork');
+            //   halo.removeHandle('unlink');
+            //   halo.removeHandle('rotate');
+            //   const shapeElement = document.getElementsByClassName('no-rotation');
+            //   if (shapeElement && shapeElement.length > 0) {
+            //     for (let i = 0; i < shapeElement.length; i++) {
+            //       shapeElement[i].classList.remove('joint-free-transform');
+            //     }
+            //   }
+            // } else {
+            //   /* QMS-2125: Show process connect type */
+            //   window[FlowChartConst.IS_SHOW_CONNECTYPE] = true;
+            //   window[FlowChartConst.SELECTED_SHAPE_ID] = cellView.model.attributes.id;
+            //   window[FlowChartConst.SHAPE_TYPE] = cellView.model.attributes.type;
+            //   window[FlowChartConst.SHAPE_FLOWCHART_LOADING] = true;
+            // }
+            /* QMS-2125: Show process connect type */
+            window[FlowChartConst.IS_SHOW_CONNECTYPE] = true;
+            window[FlowChartConst.SELECTED_SHAPE_ID] = cellView.model.attributes.id;
+            window[FlowChartConst.SHAPE_TYPE] = cellView.model.attributes.type;
+            window[FlowChartConst.SHAPE_FLOWCHART_LOADING] = true;
+            /* QMS-1404: Customization */
+            window[FlowChartConst.PAPER] = paper;
+        }
+        function closeTools() {
+            paper.removeTools();
+            joint.ui.Inspector.close();
+            joint.ui.FreeTransform.clear(paper);
+            freeTransform = null;
+            joint.ui.Halo.clear(paper);
+        }
+        function showStatus(message, type) {
+            $('.status').removeClass('info error success').addClass(type).html(message);
+            $('#statusbar-container')
+                .dequeue()
+                .addClass('active')
+                .delay(3000)
+                .queue(() => {
+                $(this).removeClass('active');
+            });
+        }
+        function replaceLink(graph, link, linkConstructor) {
+            // eslint-disable-next-line new-cap
+            const link2 = new linkConstructor({
+                source: link.source(),
+                target: link.target(),
+                vertices: link.vertices()
+            });
+            link.remove();
+            link2.set('z', -1);
+            link2.addTo(graph);
+        }
+        graph.on('change', (cell, opt) => {
+            this.onChangeTextInside(cell);
+            this.onChangeLinkLabel(cell, 12);
+            this.onChangeAlligment(cell, opt);
+            if (!opt.inspector || !freeTransform || cell.get('type') !== 'bpmn2.HeaderedPool') {
+                return;
+            }
+            const minSize = cell.getMinimalSize();
+            freeTransform.options.minWidth = minSize.width;
+            freeTransform.options.minHeight = minSize.height;
+        });
+        /* TOOLBAR */
+        const toolbar = new joint.ui.Toolbar({
+            tools: toolbarConfig.tools,
+            references: {
+                paperScroller,
+                commandManager
+            }
+        });
+        const toolbarCommands = {
+            toJSON: () => {
+                const windowFeatures = 'menubar=no,location=no,resizable=yes,scrollbars=yes,status=no';
+                const windowName = _.uniqueId('json_output');
+                const jsonWindow = window.open('', windowName, windowFeatures);
+                jsonWindow.document.write(JSON.stringify(graph.toJSON()));
+            },
+            loadGraph: () => {
+                gdAuth(() => {
+                    showStatus('loading..', 'info');
+                    gdLoad((name, content) => {
+                        try {
+                            const json = JSON.parse(content);
+                            graph.fromJSON(json);
+                            const elFileName = document.getElementById('fileName');
+                            elFileName.value = name.replace(/.json$/, '');
+                            showStatus('loaded.', 'success');
+                        }
+                        catch (e) {
+                            showStatus('failed.', 'error');
+                        }
+                    });
+                }, true);
+            },
+            saveGraph: () => {
+                gdAuth(() => {
+                    showStatus('saving..', 'info');
+                    // let name = document.getElementById('fileName').value;
+                    const name = document.getElementById('fileName');
+                    gdSave(name.value, JSON.stringify(graph.toJSON()), (file) => {
+                        if (file) {
+                            showStatus('saved.', 'success');
+                        }
+                        else {
+                            showStatus('failed.', 'error');
+                        }
+                    });
+                }, true);
+            },
+            onSelected: (event) => {
+                if (event.jsonContent) {
+                    window[FlowChartConst.SELECTED_FLOWCHART_ID] = event.flowChartId;
+                    window[FlowChartConst.SELECTED_JSON_CONTENT] = event.jsonContent;
+                    window[FlowChartConst.IS_SELECTED_TEMPLATE] = true;
+                    this.jsonOriginalContent = JSON.stringify(graph.toJSON());
+                    window[FlowChartConst.ORG_JSONCONTENT] = this.jsonOriginalContent;
+                    window.postMessage(FlowChartConst.CHANGING_TEMPLATE, this.getOriginForSelf());
+                }
+            },
+            onDeleteTemplate: () => {
+                this.isSelectedTemplate = window[FlowChartConst.IS_SELECTED_TEMPLATE];
+                if (this.isSelectedTemplate) {
+                    window.postMessage(FlowChartConst.DELETE_TEMPLATE, this.getOriginForSelf());
+                }
+                else {
+                    window.postMessage(FlowChartConst.MUST_SELECT_TEMPLATE, this.getOriginForSelf());
+                }
+            },
+            onSaveAsTemplate: () => {
+                window.postMessage(FlowChartConst.SAVE_AS_TEMPLATE, this.getOriginForSelf());
+            },
+            onResetToTempTemplate: () => {
+                this.isSelectedTemplate = window[FlowChartConst.IS_SELECTED_TEMPLATE];
+                if (this.isSelectedTemplate) {
+                    window.postMessage(FlowChartConst.RESET_TEMPLATE, this.getOriginForSelf());
+                }
+            },
+            changeSnapLines(checked) {
+                if (checked) {
+                    snaplines.startListening();
+                    stencil.options.snaplines = this.snaplines;
+                }
+                else {
+                    snaplines.stopListening();
+                    stencil.options.snaplines = null;
+                }
+            },
+            applyOnSelection(method) {
+                graph.startBatch('selection');
+                selection.collection.models.forEach((model) => {
+                    model[method]();
+                });
+                graph.stopBatch('selection');
+            }
+        };
+        toolbar.on({
+            'tojson:pointerclick': toolbarCommands.toJSON,
+            'load:pointerclick': toolbarCommands.loadGraph,
+            'save:pointerclick': toolbarCommands.saveGraph,
+            'clear:pointerclick': _.bind(graph.clear, graph),
+            'print:pointerclick': _.bind(paper.print, paper),
+            'saveAsTemplate:pointerclick': toolbarCommands.onSaveAsTemplate,
+            'selectTemplate:option:select': toolbarCommands.onSelected,
+            'deleteTemplate:pointerclick': toolbarCommands.onDeleteTemplate,
+            'resetToTempTemplate:pointerclick': toolbarCommands.onResetToTempTemplate,
+            'to-front:pointerclick': toolbarCommands.applyOnSelection.bind(this, 'toFront'),
+            'to-back:pointerclick': toolbarCommands.applyOnSelection.bind(this, 'toBack'),
+            'snapline:change': toolbarCommands.changeSnapLines.bind(this),
+            'grid-size:change': paper.setGridSize.bind(paper)
+        });
+        toolbar.render().$el.appendTo('#toolbar-container');
+        // const zoomTool = new joint.ui.Toolbar({
+        //   // initi alize tools with default settings
+        //   tools: ['zoomToFit', 'zoomIn', 'zoomOut'],
+        //   references: {
+        //     paperScroller,
+        //     commandManager
+        //   }
+        // });
+        // zoomTool.render().$el.appendTo('#zoomToolbar');
+        new joint.ui.Tooltip({
+            target: '[data-tooltip]',
+            content(el) {
+                return el.dataset.tooltip;
+            },
+            top: '.joint-toolbar',
+            padding: 10,
+            direction: 'top'
+        });
+        // Create tooltips for all the shapes in stencil.
+        stencil
+            .getGraph()
+            .get('cells')
+            .each((cell) => {
+            new joint.ui.Tooltip({
+                target: `.joint-stencil [model-id="${cell.id}"]`,
+                content: cell.get('type').split('.')[1],
+                bottom: '.joint-stencil',
+                direction: 'bottom',
+                padding: 0
+            });
+        });
+        Object.assign(joint.shapes.bpmn.icons, this.buildNewIcons());
+        /* Load  process digram */
+        this.loadProcessDiagram(jsonContent);
+        this.jsonOriginalContent = JSON.stringify(graph.toJSON());
+        paperScroller.positionContent('top-left', { padding: 50, useModelGeometry: true });
+        /* Set g raph object */
+        window[FlowChartConst.GRAPH] = graph;
+        window[FlowChartConst.PAPER] = paper;
+        window[FlowChartConst.PAPER_SCROLLER] = paperScroller;
+        window[FlowChartConst.ORG_JSONCONTENT] = this.jsonOriginalContent;
+        window.postMessage(FlowChartConst.DIAGRAM_LOADED, this.getOriginForSelf());
+    }
+    buildNewIcons({ color = '#000' } = {}) {
+        const svgIcons = {
+            message1: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="12 12 16 16"><path fill="none" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.2" d="M12.5 15.313v9.374h15v-9.375zm0 0l7.5 5.624 7.5-5.625"/></svg>`,
+            message2: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="12 12 16 16"><path fill="${color}" d="M12.5 14.344l7.5 5.625 7.5-5.625zm0 .937v9.375h15v-9.375L20 20.906z"/></svg>`,
+            timer1: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><g fill="none" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5"><circle cx="20" cy="20" r="10"/><path d="M20 10v3m5-2l-1.5 3m5.5 1l-3 1.5m4 3.5h-3m2 5l-3-1.5M25 29l-1.5-3M20 30v-3m-5 2l1.5-3M11 25l3-1.5M10 20h3m-2-5l3 1.5m1-5.5l1.5 3m5.5-1l-2 7h4"/></g></svg>`,
+            conditional1: `<svg xmlns="http://www.w3.org/2000/svg" ><path fill="none" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M11.563 11.563h16.874v16.874H11.563V11.563m2.813 2.813h11.25m-11.25 3.75h11.25m-11.25 3.75h11.25m-11.25 3.75h11.25z"/></svg>`,
+            link1: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><path fill="none" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M14.406 18.125h8.438v-2.813L27.53 20l-4.687 4.688v-2.813h-9.375v-3.75"/></svg>`,
+            link2: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><path fill="${color}" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M14.406 18.125h8.438v-2.813L27.53 20l-4.687 4.688v-2.813h-9.375v-3.75"/></svg>`,
+            signal1: `<svg xmlns="http://www.w3.org/2000/svg"  viewBox="8 8 24 24"><path fill="none" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M13.17 24.851h13.706l-6.853-11.879-6.854 11.88z"/></svg>`,
+            signal2: `<svg xmlns="http://www.w3.org/2000/svg"  viewBox="8 8 24 24"><path fill="${color}" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M13.17 24.851h13.706l-6.853-11.879-6.854 11.88z"/></svg>`,
+            error1: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><path fill="none" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M26.4 15.455l-3.238 12.58L17.7 18.37 13.76 23.8l3.478-12.412 5.576 8.72 3.586-4.652z"/></svg>`,
+            error2: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><path fill="${color}" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M26.4 15.455l-3.238 12.58L17.7 18.37 13.76 23.8l3.478-12.412 5.576 8.72 3.586-4.652z"/></svg>`,
+            escalation1: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><path fill="none" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M20 13.219l5.625 14.062L20 20.953l-5.625 6.328z"/></svg>`,
+            escalation2: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><path fill="${color}" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M20 13.219l5.625 14.062L20 20.953l-5.625 6.328z"/></svg>`,
+            termination1: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><circle cx="20" cy="20" r="10.5" fill="none" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5"/></svg>`,
+            termination2: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><circle cx="20" cy="20" r="10.5" fill="${color}" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5"/></svg>`,
+            compensation1: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><path fill="none" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M19 13.438v13.124L12.437 20 19 13.437m6.563 0v13.126L19 20l6.563-6.563z"/></svg>`,
+            compensation2: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><path fill="${color}" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M19 13.438v13.124L12.437 20 19 13.437m6.563 0v13.126L19 20l6.563-6.563z"/></svg>`,
+            cancel1: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><path fill="none" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M11.284 14.274l2.867-2.868 5.735 5.735 5.735-5.735 2.868 2.868-5.735 5.735 5.735 5.735-2.868 2.867-5.735-5.735-5.735 5.735-2.867-2.867 5.735-5.735-5.735-5.735z"/></svg>`,
+            cancel2: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><path fill="${color}" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M11.284 14.274l2.867-2.868 5.735 5.735 5.735-5.735 2.868 2.868-5.735 5.735 5.735 5.735-2.868 2.867-5.735-5.735-5.735 5.735-2.867-2.867 5.735-5.735-5.735-5.735z"/></svg>`,
+            multiple1: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><path fill="none" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M24.52 26.39h-9.443l-2.918-8.982 7.64-5.55 7.64 5.551-2.919 8.98z"/></svg>`,
+            multiple2: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><path fill="${color}" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M24.52 26.39h-9.443l-2.918-8.982 7.64-5.55 7.64 5.551-2.919 8.98z"/></svg>`,
+            parallel1: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><path fill="none" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M11.344 17.203v5.625h5.86v6.328h5.624v-6.328h6.328v-5.625h-6.328v-5.86h-5.625v5.86z"/></svg>`,
+            parallel2: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="8 8 24 24"><path fill="${color}" stroke="${color}" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" d="M11.344 17.203v5.625h5.86v6.328h5.624v-6.328h6.328v-5.625h-6.328v-5.86h-5.625v5.86z"/></svg>`
+        };
+        const icons = {};
+        Object.keys(svgIcons).forEach((iconName) => {
+            icons[iconName] = `data:image/svg+xml,${encodeURIComponent(svgIcons[iconName])}`;
+        });
+        return icons;
+    }
+    loadProcessDiagram(jsonContent) {
+        if (!jsonContent) {
+            return;
+        }
+        graph.fromJSON(jsonContent);
+    }
+    addItemTemplate(flowChartId, diagramTemplate) {
+        if (toolbarConfig.tools) {
+            const arrSelect = toolbarConfig.tools.filter((item) => {
+                return item.type === 'select-box';
+            });
+            if (arrSelect) {
+                const option = {
+                    index: 1,
+                    content: diagramTemplate.templateName,
+                    flowChartId,
+                    name: diagramTemplate.name,
+                    jsonContent: diagramTemplate.jsonContent,
+                    selected: false
+                };
+                arrSelect[0].options.push(option);
+            }
+        }
+    }
+    removeSelectItem(flowChartId) {
+        if (toolbarConfig.tools) {
+            const arrSelect = toolbarConfig.tools.filter((item) => {
+                return item.type === 'select-box';
+            });
+            if (arrSelect) {
+                arrSelect[0].options.splice(arrSelect[0].options.findIndex((i) => {
+                    return i.flowChartId === flowChartId;
+                }), 1);
+            }
+        }
+    }
+    getTempGraph() {
+        if (this.jsonTempContent) {
+            this.loadProcessDiagram(JSON.parse(this.jsonTempContent));
+        }
+        this.isTemp = true;
+        this.isReset = false;
+        this.isDisableToolbar = false;
+    }
+    getOriginForSelf() {
+        return '*';
+    }
+    setDefaultSelectedValue() {
+        if (toolbarConfig.tools) {
+            const arrSelect = toolbarConfig.tools.filter((item) => {
+                return item.type === 'select-box';
+            });
+            if (arrSelect) {
+                arrSelect[0].options[0].selected = true;
+                const list = document.getElementsByClassName(`select-box-selection`)[0];
+                list.getElementsByClassName(`select-box-option-content`)[0].innerHTML = FlowChartConst.SELECT_TEMPLATE;
+            }
+        }
+    }
+    isShowConfirmMessage() {
+        const myGraph = window[FlowChartConst.GRAPH];
+        const json = myGraph.toJSON();
+        if (json.cells.length === 0) {
+            window[FlowChartConst.IS_NOT_SHOW_AGAIN] = true;
+            return false;
+        }
+        if (!window[FlowChartConst.IS_NOT_SHOW_AGAIN]) {
+            return true;
+        }
+        return false;
+    }
+    setTransitionPoint(jsonContent, paperScroller) {
+        if (jsonContent) {
+            const cells = jsonContent[`cells`];
+            if (cells) {
+                let x = 0;
+                let y = 0;
+                cells.forEach((e) => {
+                    if (e.position && e.position) {
+                        if (x === 0 && y === 0) {
+                            x = e.position.x;
+                            y = e.position.y;
+                        }
+                        if (e.position.x < x) {
+                            x = e.position.x;
+                        }
+                        if (e.position.y < y) {
+                            y = e.position.y;
+                        }
+                    }
+                });
+                if (x !== 0 && y !== 0) {
+                    x = x > 20 ? x - 20 : x;
+                    y = y > 20 ? y - 20 : y;
+                    paperScroller.transitionToPoint(x, y);
+                }
+            }
+        }
+    }
+    openShapeFunctionality(LANG) {
+        const myCellView = window[`my_cellView`];
+        const inputs = InspectorFunction.getInspectorConfiguration(bpmn2, LANG);
+        const cell = myCellView.model;
+        const type = cell.get('type');
+        const inspector = joint.ui.Inspector.create('#inspector-container', {
+            cell,
+            inputs: inputs[type],
+            groups: {
+                general: { label: type, index: 1 },
+                defaults: { index: 2 },
+                fontsize: { index: 3 },
+                appearance: { index: 4 }
+            }
+        });
+    }
+    setZoomToFit(editMode) {
+        if (editMode === FlowchartViewMode.View) {
+            const paperScroller = window[FlowChartConst.PAPER_SCROLLER];
+            paperScroller.zoomToFit({ padding: 20, scaleGrid: 0.2, minScale: 0.2, maxScale: 5 });
+        }
+    }
+    setPaperCenter(editMode) {
+        if (editMode === FlowchartViewMode.View) {
+            const paperScroller = window[FlowChartConst.PAPER_SCROLLER];
+            paperScroller.contentToCenter({ padding: 20, scaleGrid: 0.2, minScale: 0.2, maxScale: 5 });
+        }
+    }
+    setPaperTopLeft(editMode) {
+        if (editMode === FlowchartViewMode.View) {
+            const paperScroller = window[FlowChartConst.PAPER_SCROLLER];
+            paperScroller.contentToTopLeft({ padding: 50, scaleGrid: 0.2, minScale: 0.2, maxScale: 5 });
+        }
+    }
+    setScrollToContent() {
+        const graph = window[`graph`];
+        const paperScroller = window[FlowChartConst.PAPER_SCROLLER];
+        if (graph && paperScroller) {
+            const jsonContentObj = graph.toJSON();
+            if (jsonContentObj && jsonContentObj.cells.length > 0) {
+                paperScroller.scrollToContent();
+            }
+            else {
+                paperScroller.center();
+            }
+        }
+    }
+    onChangeTextInside(cell) {
+        if (cell.get('type') === 'bpmn2.Event') {
+            if (cell.attributes.attrs.text.style['text-inside']) {
+                cell.attributes.attrs.label.textVerticalAnchor = 'middle';
+                cell.attributes.attrs.icon.refWidth = '20%';
+                cell.attributes.attrs.icon.refHeight = '20%';
+            }
+            else {
+                cell.attributes.attrs.label.textVerticalAnchor = 'top';
+                cell.attributes.attrs.icon.refWidth = '70%';
+                cell.attributes.attrs.icon.refHeight = '70%';
+            }
+        }
+        else if (cell.get('type') === 'bpmn2.Gateway' ||
+            cell.get('type') === 'bpmn2.Conversation' ||
+            cell.get('type') === 'bpmn2.DataObject' ||
+            cell.get('type') === 'bpmn2.DataStore') {
+            if (cell.attributes.attrs.text.style['text-inside']) {
+                cell.attributes.attrs.label.textVerticalAnchor = 'middle';
+            }
+            else {
+                cell.attributes.attrs.label.textVerticalAnchor = 'top';
+            }
+        }
+    }
+    onChangeLinkLabel(cell, defSize) {
+        if (cell.isLink()) {
+            let size = defSize;
+            let refPos = 0;
+            const linkId = cell.id;
+            // eslint-disable-next-line func-names
+            graph.getLinks().every(function (e) {
+                if (linkId === e.id) {
+                    return false;
+                }
+                refPos += 1;
+                return true;
+            });
+            if (graph.getLinks()[refPos].attributes.attrs.text &&
+                graph.getLinks()[refPos].attributes.attrs.text['font-size']) {
+                size = graph.getLinks()[refPos].attributes.attrs.text['font-size'];
+            }
+            graph.getLinks()[refPos].prop('labels/0/attrs/label/fontSize', size);
+        }
+    }
+    onChangeAlligment(cell, opt) {
+        if (cell.get('type') !== 'bpmn2.HeaderedPool') {
+            return;
+        }
+        if (opt.direction &&
+            (opt.direction === 'top-right' ||
+                opt.direction === 'top-right' ||
+                opt.direction === 'bottom-right' ||
+                opt.direction === 'bottom-left')) {
+            const height = cell.attributes.size.height;
+            const headerLabelAnchor = cell.attributes.attrs.headerLabel['text-anchor'];
+            this.setHeaderAttribute(cell, headerLabelAnchor, height);
+            // update last lane value
+            if (!this.isUndefinedSize(cell.attributes)) {
+                const h = cell.attributes.size.height;
+                const t = this.getTotalLaneHeight(cell.attributes);
+                const b = h - t;
+                if (b > 0) {
+                    const s = cell.attributes.lanes.slice(-1)[0].size + b;
+                    const index = cell.attributes.lanes.length - 1;
+                    cell.attributes.lanes[index].size = s;
+                    const lane = `lanes_${index}`;
+                    cell.metrics.lanes[lane].size = s;
+                    cell.metrics.lanes[lane].takenUpSpaceByLaneAndSublanes = s;
+                }
+                else {
+                    const s = cell.attributes.lanes.slice(-1)[0].size + b;
+                    const index = cell.attributes.lanes.length - 1;
+                    cell.attributes.lanes[index].size = s;
+                    const lane = `lanes_${index}`;
+                    cell.metrics.lanes[lane].size = s;
+                    cell.metrics.lanes[lane].takenUpSpaceByLaneAndSublanes = s;
+                }
+            }
+        }
+        else if (opt.propertyPath && opt.propertyPath === 'attrs/headerLabel/text-anchor') {
+            const height = cell.attributes.size.height;
+            const textAnchor = opt.propertyValue;
+            this.setHeaderAttribute(cell, textAnchor, height);
+        }
+    }
+    setHeaderAttribute(cell, textAnchor, height) {
+        switch (textAnchor) {
+            case 'end':
+                cell.attributes.attrs.headerLabel.refY = 8;
+                break;
+            case 'middle':
+                cell.attributes.attrs.headerLabel.refY = height / 2;
+                break;
+            case 'start':
+                cell.attributes.attrs.headerLabel.refY = height - 8;
+                break;
+            default:
+                cell.attributes.attrs.headerLabel.refY = height / 2;
+                break;
+        }
+    }
+    isUndefinedSize(attributes) {
+        let bResult = false;
+        if (attributes && attributes.lanes.length > 0) {
+            attributes.lanes.every((e) => {
+                if (!e.size) {
+                    bResult = true;
+                    return false;
+                }
+                return true;
+            });
+        }
+        return bResult;
+    }
+    getTotalLaneHeight(attributes) {
+        let total = 0;
+        if (attributes && attributes.lanes.length > 0) {
+            attributes.lanes.forEach((e) => {
+                if (e.size) {
+                    total += e.size;
+                }
+            });
+        }
+        return total;
+    }
+}
+BpmnService.ɵprov = i0.ɵɵdefineInjectable({ factory: function BpmnService_Factory() { return new BpmnService(); }, token: BpmnService, providedIn: "root" });
+BpmnService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"qms-ckeditor-bpmn.service.js","sourceRoot":"","sources":["../../../../../../projects/qms-angular/src/lib/qms-ckeditor-components/services/qms-ckeditor-bpmn.service.ts"],"names":[],"mappings":"AAAA,yCAAyC;AACzC,4DAA4D;AAC5D,sCAAsC;AACtC,uDAAuD;AACvD,iDAAiD;AACjD,sDAAsD;AACtD,2BAA2B;AAC3B,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,iBAAiB,MAAM,mCAAmC,CAAC;AAClE,OAAO,eAAe,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,6CAA6C,CAAC;AAC7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAC;;AAK7E,IAAI,KAAU,CAAC;AACf,IAAI,KAAU,CAAC;AACf,IAAI,aAAkB,CAAC;AACvB,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC;AAIjC,MAAM,OAAO,WAAW;IAHxB;QAIS,qBAAgB,GAAG,KAAK,CAAC;QACzB,qBAAgB,GAAG,KAAK,CAAC;QACzB,qBAAgB,GAAG,KAAK,CAAC;QACzB,WAAM,GAAG,IAAI,CAAC;QACd,oBAAe,GAAG,EAAE,CAAC;QACrB,YAAO,GAAG,KAAK,CAAC;QAChB,uBAAkB,GAAG,KAAK,CAAC;QAC3B,wBAAmB,GAAG,EAAE,CAAC;KA0sCjC;IAxsCC,YAAY,CACV,gBAAqB,EACrB,eAAoB,EACpB,SAAiB,EACjB,WAAgB,EAChB,QAAa,EACb,IAAS;QAET,MAAM,CAAC,mBAAmB,CAAC,GAAG,KAAK,CAAC;QACpC,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,GAAG,QAAQ,CAAC;QAC5C,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QAE1B,IAAI,WAAW,EAAE;YACf,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;SACvC;aAAM;YACL,WAAW,GAAG,EAAE,CAAC;SAClB;QAED,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAChC,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAChC,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAChC,MAAM,MAAM,GAAG,iBAAiB,CAAC,yBAAyB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAExE,IAAI,aAAa,GAAG,IAAI,CAAC;QAEzB,aAAa,GAAG,eAAe,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;QAC9D,gDAAgD;QAChD,IAAI,aAAa,CAAC,KAAK,IAAI,gBAAgB,EAAE;YAC3C,MAAM,SAAS,GAAG,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;gBACpD,OAAO,IAAI,CAAC,IAAI,KAAK,YAAY,CAAC;YACpC,CAAC,CAAC,CAAC;YACH,IAAI,SAAS,EAAE;gBACb,gBAAgB,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;oBAChC,MAAM,MAAM,GAAG;wBACb,KAAK,EAAE,IAAI,CAAC,KAAK;wBACjB,OAAO,EAAE,IAAI,CAAC,YAAY;wBAC1B,WAAW,EAAE,IAAI,CAAC,EAAE;wBACpB,IAAI,EAAE,IAAI,CAAC,YAAY;wBACvB,WAAW,EAAE,IAAI,CAAC,WAAW;wBAC7B,QAAQ,EAAE,KAAK;qBAChB,CAAC;oBACF,MAAM,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE;wBACjD,OAAO,CAAC,CAAC,KAAK,KAAK,MAAM,CAAC,KAAK,CAAC;oBAClC,CAAC,CAAC,CAAC;oBACH,IAAI,KAAK,GAAG,CAAC,EAAE;wBACb,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;qBACnC;gBACH,CAAC,CAAC,CAAC;aACJ;SACF;QAED,KAAK,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;QAC9C,MAAM,cAAc,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QAC/D,MAAM,QAAQ,GAAG,IAAI,KAAK,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC;QACzC,MAAM,SAAS,GAAG,IAAI,KAAK,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC;QAE3C,KAAK,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC;YAC1B,KAAK,EAAE,GAAG;YACV,MAAM,EAAE,GAAG;YACX,KAAK,EAAE,KAAK;YACZ,QAAQ,EAAE,EAAE;YACZ,QAAQ,EAAE,IAAI;YACd,KAAK,EAAE,IAAI;YACX,OAAO,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM;YACvC,WAAW,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE;YAChC,UAAU,EAAE,IAAI;YAChB,cAAc;YACd,WAAW,CAAC,WAAW;gBACrB,OAAO,IAAI,KAAK,CAAC,IAAI,CAAC;oBACpB,CAAC,EAAE,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC;oBACjC,KAAK,EAAE;wBACL,IAAI,EAAE;4BACJ,QAAQ,EAAE,UAAU;yBACrB;qBACF;iBACF,CAAC,CAAC;YACL,CAAC;YACD,kBAAkB,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG;gBAC5D,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC;gBAC/B,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC;gBAC/B,yBAAyB;gBACzB,IAAI,MAAM,KAAK,MAAM,EAAE;oBACrB,OAAO,KAAK,CAAC;iBACd;gBACD,sCAAsC;gBACtC,IAAI,MAAM,CAAC,MAAM,EAAE,EAAE;oBACnB,OAAO,KAAK,CAAC;iBACd;gBACD,IAAI,MAAM,CAAC,MAAM,EAAE,EAAE;oBACnB,OAAO,KAAK,CAAC;iBACd;gBACD,gCAAgC;gBAChC,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBACtC,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBACtC,IAAI,UAAU,KAAK,aAAa,IAAI,UAAU,KAAK,aAAa,EAAE;oBAChE,OAAO,KAAK,CAAC;iBACd;gBACD,OAAO,IAAI,CAAC;YACd,CAAC;YACD,aAAa,EAAE;gBACb,IAAI,EAAE,eAAe;aACtB;YACD,sBAAsB,EAAE;gBACtB,IAAI,EAAE,UAAU;gBAChB,IAAI,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;aACvB;YACD,YAAY;YACZ,aAAa,EAAE,IAAI;YACnB,eAAe,EAAE,KAAK;YACtB,iBAAiB,CAAC,SAAS,EAAE,UAAU;gBACrC,MAAM,UAAU,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBAChD,MAAM,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBAC9C,IAAI,UAAU,KAAK,oBAAoB,IAAI,SAAS,KAAK,oBAAoB,EAAE;oBAC7E,OAAO,IAAI,CAAC;iBACb;gBACD,IAAI,UAAU,KAAK,gBAAgB,IAAI,SAAS,KAAK,aAAa,EAAE;oBAClE,OAAO,IAAI,CAAC;iBACb;gBACD,OAAO,KAAK,CAAC;YACf,CAAC;YACD,eAAe;YACf,YAAY,EAAE;gBACZ,OAAO,EAAE;oBACP,IAAI,EAAE,MAAM;oBACZ,OAAO,EAAE;wBACP,KAAK,EAAE;4BACL,MAAM,EAAE,SAAS;4BACjB,cAAc,EAAE,CAAC;4BACjB,iBAAiB,EAAE,OAAO;yBAC3B;qBACF;iBACF;aACF;SACF,CAAC,CAAC,EAAE,CAAC;YACJ,mBAAmB,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;gBACjC,UAAU,EAAE,CAAC;gBACb,uCAAuC;gBACvC,IAAI,QAAQ,CAAC,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,EAAE;oBACnC,SAAS,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;iBACrC;qBAAM;oBACL,SAAS,CAAC,eAAe,EAAE,CAAC;oBAC5B,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;iBACvC;YACH,CAAC;YAED,mBAAmB,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;gBACjC,aAAa,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;YACxC,CAAC;YAED,gBAAgB,EAAE,CAAC,QAAQ,EAAE,EAAE;gBAC7B,SAAS,CAAC,QAAQ,CAAC,CAAC;YACtB,CAAC;YAED,iBAAiB,EAAE,CAAC,QAAQ,EAAE,EAAE;gBAC9B,sCAAsC;gBACtC,IAAI,QAAQ,CAAC,QAAQ,EAAE,EAAE;oBACvB,OAAO;iBACR;gBAED,MAAM,EAAE,GAAG,KAAK,CAAC,SAAS,CAAC;gBAC3B,MAAM,SAAS,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC;oBACxC,IAAI,EAAE,YAAY;oBAClB,KAAK,EAAE;wBACL,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC;wBACxC,IAAI,EAAE,CAAC,eAAe,EAAE;wBACxB,IAAI,EAAE,CAAC,eAAe,EAAE;qBACzB;iBACF,CAAC,CAAC;gBAEH,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;YAC/B,CAAC;YAED,iBAAiB,EAAE,CAAC,QAAQ,EAAE,EAAE;gBAC9B,uDAAuD;gBACvD,IAAI,QAAQ,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE;oBACnC,QAAQ,CAAC,WAAW,EAAE,CAAC;iBACxB;YACH,CAAC;YAED,cAAc,EAAE,CAAC,QAAQ,EAAE,EAAE;gBAC3B,uDAAuD;gBACvD,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC;gBAC5B,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;gBACpC,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;gBACpC,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,EAAE;oBACtB,OAAO;iBACR;gBACD,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;gBAClB,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;gBACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBAClC,IAAI,KAAK,CAAC,OAAO,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,EAAE;oBAC1C,IAAI,QAAQ,KAAK,sBAAsB,EAAE;wBACvC,OAAO;qBACR;oBACD,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;oBAC/C,OAAO;iBACR;gBACD,IAAI,KAAK,CAAC,OAAO,CAAC,oBAAoB,CAAC,GAAG,CAAC,CAAC,EAAE;oBAC5C,IAAI,QAAQ,KAAK,wBAAwB,EAAE;wBACzC,OAAO;qBACR;oBACD,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;oBACjD,OAAO;iBACR;gBACD,IAAI,KAAK,CAAC,OAAO,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,EAAE;oBAC1C,IAAI,QAAQ,KAAK,uBAAuB,EAAE;wBACxC,OAAO;qBACR;oBACD,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;oBAChD,OAAO;iBACR;gBACD,IAAI,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,EAAE;oBACzC,IAAI,QAAQ,KAAK,uBAAuB,EAAE;wBACxC,OAAO;qBACR;oBACD,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;oBAChD,OAAO;iBACR;gBACD,IAAI,QAAQ,KAAK,YAAY,EAAE;oBAC7B,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;iBACtC;YACH,CAAC;SACF,CAAC,CAAC;QAEH,MAAM,SAAS,GAAG,IAAI,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QAEpD,MAAM,aAAa,GAAG,IAAI,KAAK,CAAC,EAAE,CAAC,aAAa,CAAC;YAC/C,eAAe,EAAE,IAAI;YACrB,OAAO,EAAE,EAAE;YACX,KAAK;YACL,mBAAmB,EAAE,IAAI;SAC1B,CAAC,CAAC;QAEH,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC;QAC/C,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAChC,aAAa,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,CAAC;QAEhC,KAAK,CAAC,EAAE,CAAC,kBAAkB,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;QAClE,KAAK,CAAC,EAAE,CAAC,iBAAiB,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC;QAChD,SAAS,YAAY,CAAC,QAAQ,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK;YAC9C,aAAa,CAAC,IAAI,CAAC,KAAK,GAAG,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;QACjF,CAAC;QAED,eAAe;QACf,MAAM,SAAS,GAAG,IAAI,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC;YACvC,KAAK;YACL,KAAK;YACL,gBAAgB,EAAE,IAAI;YACtB,MAAM,EAAE,CAAC,oBAAoB,CAAC,CAAC,+BAA+B;SAC/D,CAAC,CAAC;QAEH,aAAa;QAEb,MAAM,OAAO,GAAG,IAAI,KAAK,CAAC,EAAE,CAAC,OAAO,CAAC;YACnC,KAAK;YACL,KAAK;YACL,KAAK,EAAE,MAAM;YACb,MAAM,EAAE,MAAM;YACd,YAAY,CAAC,IAAI;gBACf,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;gBAC3B,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBAE/B,kEAAkE;gBAClE,MAAM,cAAc,GAAG,EAAE,oBAAoB,EAAE,CAAC,EAAE,mBAAmB,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;gBACjF,IAAI,cAAc,EAAE;oBAClB,MAAM,YAAY,GAAG,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;oBACvC,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE;wBAChB,KAAK,EAAE,YAAY,CAAC,KAAK,GAAG,cAAc;wBAC1C,MAAM,EAAE,YAAY,CAAC,MAAM,GAAG,cAAc;qBAC7C,CAAC,CAAC;oBACH,IAAI,IAAI,KAAK,oBAAoB,EAAE;wBACjC,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;qBACjE;iBACF;gBACD,OAAO,KAAK,CAAC;YACf,CAAC;SACF,CAAC,CAAC;QAEH,OAAO,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAC;QAEpD,OAAO,CAAC,IAAI,CAAC;YACX,IAAI,KAAK,CAAC,QAAQ,CAAC;gBACjB,KAAK,EAAE;oBACL,KAAK,EAAE;wBACL,MAAM,EAAE,OAAO;wBACf,WAAW,EAAE,CAAC;wBACd,UAAU,EAAE,QAAQ;qBACrB;iBACF;aACF,CAAC;YACF,IAAI,KAAK,CAAC,OAAO,CAAC;gBAChB,KAAK,EAAE;oBACL,KAAK,EAAE;wBACL,MAAM,EAAE,OAAO;wBACf,WAAW,EAAE,CAAC;wBACd,UAAU,EAAE,QAAQ;qBACrB;iBACF;aACF,CAAC;YACF,IAAI,KAAK,CAAC,KAAK,CAAC;gBACd,KAAK,EAAE;oBACL,KAAK,EAAE;wBACL,MAAM,EAAE,OAAO;wBACf,WAAW,EAAE,CAAC;wBACd,UAAU,EAAE,QAAQ;qBACrB;iBACF;aACF,CAAC;YACF,IAAI,KAAK,CAAC,YAAY,CAAC;gBACrB,KAAK,EAAE;oBACL,KAAK,EAAE;wBACL,MAAM,EAAE,OAAO;wBACf,WAAW,EAAE,CAAC;wBACd,UAAU,EAAE,QAAQ;qBACrB;iBACF;aACF,CAAC;YACF,IAAI,KAAK,CAAC,UAAU,CAAC;gBACnB,KAAK,EAAE;oBACL,KAAK,EAAE;wBACL,MAAM,EAAE,OAAO;wBACf,WAAW,EAAE,CAAC;wBACd,UAAU,EAAE,QAAQ;qBACrB;iBACF;aACF,CAAC;YACF,IAAI,KAAK,CAAC,SAAS,CAAC;gBAClB,KAAK,EAAE;oBACL,KAAK,EAAE;wBACL,MAAM,EAAE,OAAO;wBACf,WAAW,EAAE,CAAC;wBACd,UAAU,EAAE,QAAQ;qBACrB;iBACF;aACF,CAAC;YACF,IAAI,KAAK,CAAC,UAAU,CAAC;gBACnB,KAAK,EAAE;oBACL,IAAI,EAAE;wBACJ,IAAI,EAAE,SAAS;qBAChB;oBACD,KAAK,EAAE;wBACL,MAAM,EAAE,OAAO;wBACf,WAAW,EAAE,CAAC;wBACd,UAAU,EAAE,QAAQ;qBACrB;iBACF;aACF,CAAC;YACF,IAAI,KAAK,CAAC,KAAK,CAAC;gBACd,IAAI,EAAE;oBACJ,KAAK,EAAE,EAAE;oBACT,MAAM,EAAE,EAAE;iBACX;gBACD,KAAK,EAAE;oBACL,KAAK,EAAE;wBACL,IAAI,EAAE,OAAO;wBACb,MAAM,EAAE,OAAO;wBACf,WAAW,EAAE,CAAC;wBACd,UAAU,EAAE,QAAQ;qBACrB;iBACF;aACF,CAAC;YACF,qBAAqB;YACrB,IAAI,KAAK,CAAC,YAAY,CAAC;gBACrB,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE;gBAClD,IAAI,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;gBAC/B,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;gBACjD,KAAK,EAAE;oBACL,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;oBACzB,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;iBAChC;aACF,CAAC;YACF,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC;gBACjC,YAAY,EAAE,CAAC,eAAe,EAAE,eAAe,CAAC;gBAChD,KAAK,EAAE;oBACL,KAAK,EAAE;wBACL,MAAM,EAAE,OAAO;wBACf,WAAW,EAAE,CAAC;wBACd,UAAU,EAAE,QAAQ;qBACrB;iBACF;aACF,CAAC;YACF,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC;gBAC5B,KAAK,EAAE;oBACL,IAAI,EAAE;wBACJ,MAAM,EAAE,OAAO;wBACf,WAAW,EAAE,CAAC;wBACd,UAAU,EAAE,QAAQ;qBACrB;iBACF;aACF,CAAC;SACH,CAAC,CAAC;QAEH,KAAK,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE;YACjD,OAAO,EAAE,GAAG;YACZ,WAAW,EAAE,SAAS;YACtB,OAAO,EAAE,EAAE;YACX,OAAO,EAAE,EAAE;YACX,SAAS,EAAE,EAAE;YACb,WAAW,EAAE,EAAE;YACf,WAAW,EAAE,KAAK;SACnB,CAAC,CAAC;QAEH,iDAAiD;QACjD,OAAO,CAAC,EAAE,CAAC,cAAc,EAAE,CAAC,WAAW,EAAE,EAAE;YACzC,0DAA0D;YAC1D,SAAS,CAAC,WAAW,CAAC,CAAC;QACzB,CAAC,CAAC,CAAC;QAEH,cAAc;QACd,IAAI,QAAQ,KAAK,iBAAiB,CAAC,IAAI,EAAE;YACvC,2BAA2B,EAAE,CAAC;SAC/B;QAED,SAAS,2BAA2B;YAClC,QAAQ,CAAC,EAAE,CACT;gBACE,QAAQ,EAAE,GAAG,EAAE;oBACb,yDAAyD;oBACzD,SAAS,CAAC,YAAY,CAAC,SAAS,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;gBACtD,CAAC;gBAED,QAAQ,EAAE,GAAG,EAAE;oBACb,MAAM,WAAW,GAAG,SAAS,CAAC,UAAU,CAAC,KAAK,EAAE;wBAC9C,SAAS,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE;wBAC7B,eAAe,EAAE,IAAI;qBACtB,CAAC,CAAC;oBAEH,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE;wBAC9C,OAAO,IAAI,CAAC,SAAS,EAAE,CAAC;oBAC1B,CAAC,CAAC,CAAC;oBAEH,kFAAkF;oBAClF,2DAA2D;oBAC3D,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;gBACvC,CAAC;gBAED,qBAAqB,EAAE,GAAG,EAAE;oBAC1B,SAAS,CAAC,WAAW,CAAC,SAAS,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;gBACrD,CAAC;gBAED,kBAAkB,EAAE,CAAC,GAAG,EAAE,EAAE;oBAC1B,GAAG,CAAC,cAAc,EAAE,CAAC;oBACrB,KAAK,CAAC,WAAW,CAAC,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC;gBACpD,CAAC;gBAED,QAAQ,EAAE,GAAG,EAAE;oBACb,cAAc,CAAC,IAAI,EAAE,CAAC;oBACtB,SAAS,CAAC,eAAe,EAAE,CAAC;gBAC9B,CAAC;gBAED,QAAQ,EAAE,GAAG,EAAE;oBACb,cAAc,CAAC,IAAI,EAAE,CAAC;oBACtB,SAAS,CAAC,eAAe,EAAE,CAAC;gBAC9B,CAAC;gBAED,QAAQ,EAAE,GAAG,EAAE;oBACb,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;gBAClD,CAAC;gBAED,WAAW,EAAE,CAAC,GAAG,EAAE,EAAE;oBACnB,GAAG,CAAC,cAAc,EAAE,CAAC;oBACrB,aAAa,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;gBACjD,CAAC;gBAED,YAAY,EAAE,CAAC,GAAG,EAAE,EAAE;oBACpB,GAAG,CAAC,cAAc,EAAE,CAAC;oBACrB,aAAa,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;gBACpD,CAAC;gBAED,eAAe,EAAE,CAAC,GAAG,EAAE,EAAE;oBACvB,aAAa,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;gBACvC,CAAC;gBAED,aAAa,EAAE,GAAG,EAAE;oBAClB,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;gBAClC,CAAC;aACF,EACD,IAAI,CACL,CAAC;QACJ,CAAC;QAED,SAAS,SAAS,CAAC,QAAQ;YACzB,IAAI,CAAC,QAAQ,EAAE;gBACb,OAAO;aACR;YACD,UAAU,EAAE,CAAC;YACb,MAAM,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC;YACjC,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC;YAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAC9B,oDAAoD;YACpD,2DAA2D;YAC3D,0EAA0E;YAC1E,YAAY;YACZ,4BAA4B;YAC5B,gBAAgB;YAChB,4CAA4C;YAC5C,gCAAgC;YAChC,gCAAgC;YAChC,iCAAiC;YACjC,QAAQ;YACR,QAAQ;YACR,IAAI;YAEJ,MAAM,SAAS,GAAG,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,sBAAsB,EAAE;gBAClE,IAAI;gBACJ,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC;gBACpB,MAAM,EAAE;oBACN,OAAO,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE;oBAClC,QAAQ,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE;oBACtB,QAAQ,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE;oBACtB,UAAU,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE;iBACzB;aACF,CAAC,CAAC;YAEH,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAC/B,sDAAsD;YACtD,sDAAsD;YACtD,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;YAEjD,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE;gBACpB,IAAI,OAAO,CAAC;gBAEZ,IAAI,IAAI,YAAY,KAAK,CAAC,YAAY,EAAE;oBACtC,OAAO,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;iBACjC;qBAAM;oBACL,OAAO,GAAG,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;iBACrC;gBAED,aAAa,GAAG,IAAI,KAAK,CAAC,EAAE,CAAC,aAAa,CAAC;oBACzC,QAAQ;oBACR,qBAAqB,EAAE,KAAK;oBAC5B,aAAa,EAAE,KAAK;oBACpB,QAAQ,EAAE,OAAO,CAAC,KAAK;oBACvB,SAAS,EAAE,OAAO,CAAC,MAAM;iBAC1B,CAAC,CAAC,MAAM,EAAE,CAAC;gBAEZ,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC;oBAC7B,QAAQ;oBACR,KAAK,EAAE,SAAS;oBAChB,IAAI,EAAE,SAAS;oBACf,gBAAgB,EAAE,IAAI;oBACtB,UAAU,EAAE,CAAC,QAAQ,EAAE,EAAE;wBACvB,OAAO,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;oBACpC,CAAC;iBACF,CAAC,CAAC;gBAEH,IAAI,IAAI,KAAK,oBAAoB,EAAE;oBACjC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;oBAC1B,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;oBAC1B,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;iBAC7B;gBACD,IAAI,CAAC,MAAM,EAAE,CAAC;aACf;YAED,IAAI,IAAI,CAAC,MAAM,EAAE,EAAE;gBACjB,MAAM,EAAE,GAAG,KAAK,CAAC,SAAS,CAAC;gBAC3B,MAAM,SAAS,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC;oBACxC,IAAI,EAAE,kBAAkB;oBACxB,KAAK,EAAE;wBACL,IAAI,EAAE,CAAC,QAAQ,EAAE;wBACjB,IAAI,EAAE,CAAC,YAAY,EAAE;wBACrB,IAAI,EAAE,CAAC,YAAY,EAAE;wBACrB,IAAI,EAAE,CAAC,eAAe,EAAE;wBACxB,IAAI,EAAE,CAAC,eAAe,EAAE;wBACxB,IAAI,EAAE,CAAC,QAAQ,EAAE;wBACjB,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;wBAChC,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;qBAC7C;iBACF,CAAC,CAAC;gBAEH,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;aAC9B;YAED,mDAAmD;YACnD,wFAAwF;YACxF,mEAAmE;YACnE,mCAAmC;YACnC,oDAAoD;YACpD,gDAAgD;YAChD,8CAA8C;YAC9C,2DAA2D;YAC3D,4CAA4C;YAC5C,oBAAoB;YACpB,UAAU;YACV,+DAA+D;YAC/D,iCAAiC;YACjC,4CAA4C;YAC5C,oBAAoB;YACpB,UAAU;YACV,0DAA0D;YAC1D,wCAAwC;YACxC,YAAY;YACZ,yBAAyB;YACzB,4CAA4C;YAC5C,oBAAoB;YACpB,UAAU;YACV,qDAAqD;YACrD,iCAAiC;YACjC,sFAAsF;YACtF,4CAA4C;YAC5C,0EAA0E;YAC1E,yFAAyF;YACzF,8DAA8D;YAC9D,sGAAsG;YACtG,mDAAmD;YACnD,wEAAwE;YACxE,2CAA2C;YAC3C,8EAA8E;YAC9E,qBAAqB;YACrB,0CAA0C;YAC1C,6EAA6E;YAC7E,qBAAqB;YACrB,uCAAuC;YACvC,0EAA0E;YAC1E,qBAAqB;YACrB,2CAA2C;YAC3C,4EAA4E;YAC5E,qBAAqB;YACrB,YAAY;YACZ,UAAU;YACV,sFAAsF;YACtF,+CAA+C;YAC/C,UAAU;YACV,yCAAyC;YACzC,oBAAoB;YACpB,4BAA4B;YAC5B,qCAAqC;YACrC,YAAY;YACZ,uBAAuB;YACvB,qCAAqC;YACrC,qCAAqC;YACrC,oCAAoC;YACpC,mCAAmC;YACnC,mCAAmC;YACnC,qCAAqC;YACrC,qCAAqC;YACrC,QAAQ;YACR,MAAM;YAEN,yEAAyE;YACzE,mDAAmD;YACnD,sDAAsD;YACtD,2EAA2E;YAC3E,iEAAiE;YACjE,UAAU;YACV,QAAQ;YACR,MAAM;YACN,8FAA8F;YAC9F,qCAAqC;YACrC,gBAAgB;YAChB,wBAAwB;YACxB,qBAAqB;YACrB,QAAQ;YACR,mBAAmB;YACnB,iCAAiC;YACjC,iCAAiC;YACjC,gCAAgC;YAChC,+BAA+B;YAC/B,+BAA+B;YAC/B,iCAAiC;YACjC,iCAAiC;YACjC,yEAAyE;YACzE,mDAAmD;YACnD,sDAAsD;YACtD,kEAAkE;YAClE,QAAQ;YACR,MAAM;YACN,WAAW;YACX,8CAA8C;YAC9C,sDAAsD;YACtD,6EAA6E;YAC7E,wEAAwE;YACxE,2DAA2D;YAC3D,IAAI;YACJ,yCAAyC;YACzC,MAAM,CAAC,cAAc,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC;YACjD,MAAM,CAAC,cAAc,CAAC,iBAAiB,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC;YACxE,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC;YACnE,MAAM,CAAC,cAAc,CAAC,uBAAuB,CAAC,GAAG,IAAI,CAAC;YACtD,6BAA6B;YAC7B,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;QACvC,CAAC;QAED,SAAS,UAAU;YACjB,KAAK,CAAC,WAAW,EAAE,CAAC;YACpB,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;YAC3B,KAAK,CAAC,EAAE,CAAC,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACpC,aAAa,GAAG,IAAI,CAAC;YACrB,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;QAED,SAAS,UAAU,CAAC,OAAO,EAAE,IAAI;YAC/B,CAAC,CAAC,SAAS,CAAC,CAAC,WAAW,CAAC,oBAAoB,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC5E,CAAC,CAAC,sBAAsB,CAAC;iBACtB,OAAO,EAAE;iBACT,QAAQ,CAAC,QAAQ,CAAC;iBAClB,KAAK,CAAC,IAAI,CAAC;iBACX,KAAK,CAAC,GAAG,EAAE;gBACV,CAAC,CAAC,IAAI,CAAC,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;YAChC,CAAC,CAAC,CAAC;QACP,CAAC;QAED,SAAS,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,eAAe;YAC/C,mCAAmC;YACnC,MAAM,KAAK,GAAG,IAAI,eAAe,CAAC;gBAChC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE;gBACrB,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE;gBACrB,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE;aAC1B,CAAC,CAAC;YACH,IAAI,CAAC,MAAM,EAAE,CAAC;YACd,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;YACnB,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC;QAED,KAAK,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE;YAC/B,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;YAC9B,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YACjC,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;YAClC,IAAI,CAAC,GAAG,CAAC,SAAS,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,oBAAoB,EAAE;gBACjF,OAAO;aACR;YACD,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;YACtC,aAAa,CAAC,OAAO,CAAC,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC;YAC/C,aAAa,CAAC,OAAO,CAAC,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC;QACnD,CAAC,CAAC,CAAC;QAEH,aAAa;QACb,MAAM,OAAO,GAAG,IAAI,KAAK,CAAC,EAAE,CAAC,OAAO,CAAC;YACnC,KAAK,EAAE,aAAa,CAAC,KAAK;YAC1B,UAAU,EAAE;gBACV,aAAa;gBACb,cAAc;aACf;SACF,CAAC,CAAC;QAEH,MAAM,eAAe,GAAG;YACtB,MAAM,EAAE,GAAG,EAAE;gBACX,MAAM,cAAc,GAAG,+DAA+D,CAAC;gBACvF,MAAM,UAAU,GAAG,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;gBAC7C,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,UAAU,EAAE,cAAc,CAAC,CAAC;gBAE/D,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;YAC5D,CAAC;YACD,SAAS,EAAE,GAAG,EAAE;gBACd,MAAM,CAAC,GAAG,EAAE;oBACV,UAAU,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;oBAChC,MAAM,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE;wBACvB,IAAI;4BACF,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;4BACjC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;4BACrB,MAAM,UAAU,GAAsB,QAAQ,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;4BAC1E,UAAU,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;4BAC9C,UAAU,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;yBAClC;wBAAC,OAAO,CAAC,EAAE;4BACV,UAAU,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;yBAChC;oBACH,CAAC,CAAC,CAAC;gBACL,CAAC,EAAE,IAAI,CAAC,CAAC;YACX,CAAC;YAED,SAAS,EAAE,GAAG,EAAE;gBACd,MAAM,CAAC,GAAG,EAAE;oBACV,UAAU,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;oBAC/B,wDAAwD;oBACxD,MAAM,IAAI,GAAsB,QAAQ,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;oBACpE,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE;wBAC1D,IAAI,IAAI,EAAE;4BACR,UAAU,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;yBACjC;6BAAM;4BACL,UAAU,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;yBAChC;oBACH,CAAC,CAAC,CAAC;gBACL,CAAC,EAAE,IAAI,CAAC,CAAC;YACX,CAAC;YACD,UAAU,EAAE,CAAC,KAAK,EAAE,EAAE;gBACpB,IAAI,KAAK,CAAC,WAAW,EAAE;oBACrB,MAAM,CAAC,cAAc,CAAC,qBAAqB,CAAC,GAAG,KAAK,CAAC,WAAW,CAAC;oBACjE,MAAM,CAAC,cAAc,CAAC,qBAAqB,CAAC,GAAG,KAAK,CAAC,WAAW,CAAC;oBACjE,MAAM,CAAC,cAAc,CAAC,oBAAoB,CAAC,GAAG,IAAI,CAAC;oBACnD,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;oBAC1D,MAAM,CAAC,cAAc,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC,mBAAmB,CAAC;oBAClE,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC,iBAAiB,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;iBAC/E;YACH,CAAC;YAED,gBAAgB,EAAE,GAAG,EAAE;gBACrB,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC,cAAc,CAAC,oBAAoB,CAAC,CAAC;gBACtE,IAAI,IAAI,CAAC,kBAAkB,EAAE;oBAC3B,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC,eAAe,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;iBAC7E;qBAAM;oBACL,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC,oBAAoB,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;iBAClF;YACH,CAAC;YAED,gBAAgB,EAAE,GAAG,EAAE;gBACrB,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;YAC/E,CAAC;YAED,qBAAqB,EAAE,GAAG,EAAE;gBAC1B,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC,cAAc,CAAC,oBAAoB,CAAC,CAAC;gBACtE,IAAI,IAAI,CAAC,kBAAkB,EAAE;oBAC3B,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC,cAAc,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;iBAC5E;YACH,CAAC;YAED,eAAe,CAAC,OAAO;gBACrB,IAAI,OAAO,EAAE;oBACX,SAAS,CAAC,cAAc,EAAE,CAAC;oBAC3B,OAAO,CAAC,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;iBAC5C;qBAAM;oBACL,SAAS,CAAC,aAAa,EAAE,CAAC;oBAC1B,OAAO,CAAC,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;iBAClC;YACH,CAAC;YAED,gBAAgB,CAAC,MAAM;gBACrB,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;gBAC9B,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;oBAC5C,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;gBAClB,CAAC,CAAC,CAAC;gBACH,KAAK,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;YAC/B,CAAC;SACF,CAAC;QACF,OAAO,CAAC,EAAE,CAAC;YACT,qBAAqB,EAAE,eAAe,CAAC,MAAM;YAC7C,mBAAmB,EAAE,eAAe,CAAC,SAAS;YAC9C,mBAAmB,EAAE,eAAe,CAAC,SAAS;YAC9C,oBAAoB,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC;YAChD,oBAAoB,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC;YAChD,6BAA6B,EAAE,eAAe,CAAC,gBAAgB;YAC/D,8BAA8B,EAAE,eAAe,CAAC,UAAU;YAC1D,6BAA6B,EAAE,eAAe,CAAC,gBAAgB;YAC/D,kCAAkC,EAAE,eAAe,CAAC,qBAAqB;YACzE,uBAAuB,EAAE,eAAe,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC;YAC/E,sBAAsB,EAAE,eAAe,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC;YAC7E,iBAAiB,EAAE,eAAe,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC;YAC7D,kBAAkB,EAAE,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC;SAClD,CAAC,CAAC;QAEH,OAAO,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAC;QAEpD,0CAA0C;QAC1C,+CAA+C;QAC/C,+CAA+C;QAC/C,kBAAkB;QAClB,qBAAqB;QACrB,qBAAqB;QACrB,MAAM;QACN,MAAM;QAEN,kDAAkD;QAElD,IAAI,KAAK,CAAC,EAAE,CAAC,OAAO,CAAC;YACnB,MAAM,EAAE,gBAAgB;YACxB,OAAO,CAAC,EAAE;gBACR,OAAO,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC;YAC5B,CAAC;YACD,GAAG,EAAE,gBAAgB;YACrB,OAAO,EAAE,EAAE;YACX,SAAS,EAAE,KAAK;SACjB,CAAC,CAAC;QAEH,iDAAiD;QACjD,OAAO;aACJ,QAAQ,EAAE;aACV,GAAG,CAAC,OAAO,CAAC;aACZ,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;YACb,IAAI,KAAK,CAAC,EAAE,CAAC,OAAO,CAAC;gBACnB,MAAM,EAAE,6BAA6B,IAAI,CAAC,EAAE,IAAI;gBAChD,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBACvC,MAAM,EAAE,gBAAgB;gBACxB,SAAS,EAAE,QAAQ;gBACnB,OAAO,EAAE,CAAC;aACX,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEL,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;QAC7D,0BAA0B;QAC1B,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC;QACrC,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;QAC1D,aAAa,CAAC,eAAe,CAAC,UAAU,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,gBAAgB,EAAE,IAAI,EAAE,CAAC,CAAC;QAEnF,uBAAuB;QACvB,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;QACrC,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;QACrC,MAAM,CAAC,cAAc,CAAC,cAAc,CAAC,GAAG,aAAa,CAAC;QACtD,MAAM,CAAC,cAAc,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC,mBAAmB,CAAC;QAClE,MAAM,CAAC,WAAW,CAAC,cAAc,CAAC,cAAc,EAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAC7E,CAAC;IAED,aAAa,CAAC,EAAE,KAAK,GAAG,MAAM,EAAE,GAAG,EAAE;QACnC,MAAM,QAAQ,GAAG;YACf,QAAQ,EAAE,2FAA2F,KAAK,uIAAuI;YACjP,QAAQ,EAAE,6EAA6E,KAAK,mFAAmF;YAC/K,MAAM,EAAE,sFAAsF,KAAK,yQAAyQ;YAC5W,YAAY,EAAE,sEAAsE,KAAK,qMAAqM;YAC9R,KAAK,EAAE,yFAAyF,KAAK,uJAAuJ;YAC5P,KAAK,EAAE,2EAA2E,KAAK,aAAa,KAAK,uJAAuJ;YAChQ,OAAO,EAAE,0FAA0F,KAAK,iIAAiI;YACzO,OAAO,EAAE,4EAA4E,KAAK,aAAa,KAAK,iIAAiI;YAC7O,MAAM,EAAE,yFAAyF,KAAK,sKAAsK;YAC5Q,MAAM,EAAE,2EAA2E,KAAK,aAAa,KAAK,sKAAsK;YAChR,WAAW,EAAE,yFAAyF,KAAK,iIAAiI;YAC5O,WAAW,EAAE,2EAA2E,KAAK,aAAa,KAAK,iIAAiI;YAChP,YAAY,EAAE,oHAAoH,KAAK,6EAA6E;YACpN,YAAY,EAAE,sGAAsG,KAAK,aAAa,KAAK,6EAA6E;YACxN,aAAa,EAAE,yFAAyF,KAAK,yJAAyJ;YACtQ,aAAa,EAAE,2EAA2E,KAAK,aAAa,KAAK,yJAAyJ;YAC1Q,OAAO,EAAE,yFAAyF,KAAK,iPAAiP;YACxV,OAAO,EAAE,2EAA2E,KAAK,aAAa,KAAK,iPAAiP;YAC5V,SAAS,EAAE,yFAAyF,KAAK,mJAAmJ;YAC5P,SAAS,EAAE,2EAA2E,KAAK,aAAa,KAAK,mJAAmJ;YAChQ,SAAS,EAAE,yFAAyF,KAAK,qKAAqK;YAC9Q,SAAS,EAAE,2EAA2E,KAAK,aAAa,KAAK,qKAAqK;SACnR,CAAC;QAEF,MAAM,KAAK,GAAG,EAAE,CAAC;QAEjB,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;YACzC,KAAK,CAAC,QAAQ,CAAC,GAAG,sBAAsB,kBAAkB,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC;QACnF,CAAC,CAAC,CAAC;QACH,OAAO,KAAK,CAAC;IACf,CAAC;IAED,kBAAkB,CAAC,WAAoB;QACrC,IAAI,CAAC,WAAW,EAAE;YAChB,OAAO;SACR;QACD,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;IAC9B,CAAC;IAED,eAAe,CAAC,WAAoB,EAAE,eAAqB;QACzD,IAAI,aAAa,CAAC,KAAK,EAAE;YACvB,MAAM,SAAS,GAAG,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;gBACpD,OAAO,IAAI,CAAC,IAAI,KAAK,YAAY,CAAC;YACpC,CAAC,CAAC,CAAC;YACH,IAAI,SAAS,EAAE;gBACb,MAAM,MAAM,GAAG;oBACb,KAAK,EAAE,CAAC;oBACR,OAAO,EAAE,eAAe,CAAC,YAAY;oBACrC,WAAW;oBACX,IAAI,EAAE,eAAe,CAAC,IAAI;oBAC1B,WAAW,EAAE,eAAe,CAAC,WAAW;oBACxC,QAAQ,EAAE,KAAK;iBAChB,CAAC;gBACF,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aACnC;SACF;IACH,CAAC;IAED,gBAAgB,CAAC,WAAoB;QACnC,IAAI,aAAa,CAAC,KAAK,EAAE;YACvB,MAAM,SAAS,GAAG,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;gBACpD,OAAO,IAAI,CAAC,IAAI,KAAK,YAAY,CAAC;YACpC,CAAC,CAAC,CAAC;YACH,IAAI,SAAS,EAAE;gBACb,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CACzB,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE;oBACnC,OAAO,CAAC,CAAC,WAAW,KAAK,WAAW,CAAC;gBACvC,CAAC,CAAC,EACF,CAAC,CACF,CAAC;aACH;SACF;IACH,CAAC;IAED,YAAY;QACV,IAAI,IAAI,CAAC,eAAe,EAAE;YACxB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC;SAC3D;QACD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;IAChC,CAAC;IAED,gBAAgB;QACd,OAAO,GAAG,CAAC;IACb,CAAC;IAED,uBAAuB;QACrB,IAAI,aAAa,CAAC,KAAK,EAAE;YACvB,MAAM,SAAS,GAAG,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;gBACpD,OAAO,IAAI,CAAC,IAAI,KAAK,YAAY,CAAC;YACpC,CAAC,CAAC,CAAC;YACH,IAAI,SAAS,EAAE;gBACb,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,IAAI,CAAC;gBACxC,MAAM,IAAI,GAAG,QAAQ,CAAC,sBAAsB,CAAC,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC;gBACxE,IAAI,CAAC,sBAAsB,CAAC,2BAA2B,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,cAAc,CAAC,eAAe,CAAC;aACxG;SACF;IACH,CAAC;IAGD,oBAAoB;QAClB,MAAM,OAAO,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAC7C,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;QAC9B,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,MAAM,CAAC,cAAc,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAC;YAChD,OAAO,KAAK,CAAC;SACd;QACD,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,iBAAiB,CAAC,EAAE;YAC7C,OAAO,IAAI,CAAC;SACb;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED,kBAAkB,CAAC,WAAmB,EAAE,aAAkB;QACxD,IAAI,WAAW,EAAE;YACf,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;YACnC,IAAI,KAAK,EAAE;gBACT,IAAI,CAAC,GAAG,CAAC,CAAC;gBACV,IAAI,CAAC,GAAG,CAAC,CAAC;gBACV,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;oBAClB,IAAI,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,QAAQ,EAAE;wBAC5B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;4BACtB,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;4BACjB,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;yBAClB;wBACD,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,EAAE;4BACpB,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;yBAClB;wBACD,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,EAAE;4BACpB,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;yBAClB;qBACF;gBACH,CAAC,CAAC,CAAC;gBAEH,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;oBACtB,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;oBACxB,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;oBACxB,aAAa,CAAC,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;iBACvC;aACF;SACF;IACH,CAAC;IAED,sBAAsB,CAAC,IAAS;QAC9B,MAAM,UAAU,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;QACzC,MAAM,MAAM,GAAG,iBAAiB,CAAC,yBAAyB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACxE,MAAM,IAAI,GAAG,UAAU,CAAC,KAAK,CAAC;QAC9B,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC9B,MAAM,SAAS,GAAG,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,sBAAsB,EAAE;YAClE,IAAI;YACJ,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC;YACpB,MAAM,EAAE;gBACN,OAAO,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE;gBAClC,QAAQ,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE;gBACtB,QAAQ,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE;gBACtB,UAAU,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE;aACzB;SACF,CAAC,CAAC;IACL,CAAC;IAED,YAAY,CAAC,QAAgB;QAC3B,IAAI,QAAQ,KAAK,iBAAiB,CAAC,IAAI,EAAE;YACvC,MAAM,aAAa,GAAG,MAAM,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;YAC5D,aAAa,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC;SACtF;IACH,CAAC;IAED,cAAc,CAAC,QAAgB;QAC7B,IAAI,QAAQ,KAAK,iBAAiB,CAAC,IAAI,EAAE;YACvC,MAAM,aAAa,GAAG,MAAM,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;YAC5D,aAAa,CAAC,eAAe,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC;SAC5F;IACH,CAAC;IAED,eAAe,CAAC,QAAgB;QAC9B,IAAI,QAAQ,KAAK,iBAAiB,CAAC,IAAI,EAAE;YACvC,MAAM,aAAa,GAAG,MAAM,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;YAC5D,aAAa,CAAC,gBAAgB,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC;SAC7F;IACH,CAAC;IAED,kBAAkB;QAChB,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;QAC9B,MAAM,aAAa,GAAG,MAAM,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAC5D,IAAI,KAAK,IAAI,aAAa,EAAE;YAC1B,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;YACtC,IAAI,cAAc,IAAI,cAAc,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;gBACrD,aAAa,CAAC,eAAe,EAAE,CAAC;aACjC;iBAAM;gBACL,aAAa,CAAC,MAAM,EAAE,CAAC;aACxB;SACF;IACH,CAAC;IAED,kBAAkB,CAAC,IAAS;QAC1B,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,aAAa,EAAE;YACtC,IAAI,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE;gBACnD,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,kBAAkB,GAAG,QAAQ,CAAC;gBAC1D,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;gBAC5C,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;aAC9C;iBAAM;gBACL,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,kBAAkB,GAAG,KAAK,CAAC;gBACvD,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;gBAC5C,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;aAC9C;SACF;aAAM,IACL,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,eAAe;YACpC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,oBAAoB;YACzC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,kBAAkB;YACvC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,iBAAiB,EACtC;YACA,IAAI,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE;gBACnD,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,kBAAkB,GAAG,QAAQ,CAAC;aAC3D;iBAAM;gBACL,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,kBAAkB,GAAG,KAAK,CAAC;aACxD;SACF;IACH,CAAC;IAED,iBAAiB,CAAC,IAAS,EAAE,OAAe;QAC1C,IAAI,IAAI,CAAC,MAAM,EAAE,EAAE;YACjB,IAAI,IAAI,GAAG,OAAO,CAAC;YACnB,IAAI,MAAM,GAAG,CAAC,CAAC;YACf,MAAM,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;YACvB,sCAAsC;YACtC,KAAK,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC;gBAChC,IAAI,MAAM,KAAK,CAAC,CAAC,EAAE,EAAE;oBACnB,OAAO,KAAK,CAAC;iBACd;gBACD,MAAM,IAAI,CAAC,CAAC;gBACZ,OAAO,IAAI,CAAC;YACd,CAAC,CAAC,CAAC;YACH,IACE,KAAK,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI;gBAC9C,KAAK,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,EAC3D;gBACA,IAAI,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;aACpE;YACD,KAAK,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,+BAA+B,EAAE,IAAI,CAAC,CAAC;SACtE;IACH,CAAC;IAED,iBAAiB,CAAC,IAAS,EAAE,GAAQ;QACnC,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,oBAAoB,EAAE;YAC7C,OAAO;SACR;QAED,IACE,GAAG,CAAC,SAAS;YACb,CAAC,GAAG,CAAC,SAAS,KAAK,WAAW;gBAC5B,GAAG,CAAC,SAAS,KAAK,WAAW;gBAC7B,GAAG,CAAC,SAAS,KAAK,cAAc;gBAChC,GAAG,CAAC,SAAS,KAAK,aAAa,CAAC,EAClC;YACA,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC;YAC3C,MAAM,iBAAiB,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;YAC3E,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,iBAAiB,EAAE,MAAM,CAAC,CAAC;YAEzD,yBAAyB;YACzB,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE;gBAC1C,MAAM,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC;gBACtC,MAAM,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;gBACnD,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBAChB,IAAI,CAAC,GAAG,CAAC,EAAE;oBACT,MAAM,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC;oBACtD,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;oBAC/C,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC;oBAEtC,MAAM,IAAI,GAAG,SAAS,KAAK,EAAE,CAAC;oBAC9B,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC;oBAClC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,6BAA6B,GAAG,CAAC,CAAC;iBAC5D;qBAAM;oBACL,MAAM,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC;oBACtD,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;oBAC/C,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC;oBAEtC,MAAM,IAAI,GAAG,SAAS,KAAK,EAAE,CAAC;oBAC9B,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC;oBAClC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,6BAA6B,GAAG,CAAC,CAAC;iBAC5D;aACF;SACF;aAAM,IAAI,GAAG,CAAC,YAAY,IAAI,GAAG,CAAC,YAAY,KAAK,+BAA+B,EAAE;YACnF,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC;YAC3C,MAAM,UAAU,GAAG,GAAG,CAAC,aAAa,CAAC;YACrC,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;SACnD;IACH,CAAC;IAED,kBAAkB,CAAC,IAAS,EAAE,UAAkB,EAAE,MAAc;QAC9D,QAAQ,UAAU,EAAE;YAClB,KAAK,KAAK;gBACR,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,GAAG,CAAC,CAAC;gBAC3C,MAAM;YACR,KAAK,QAAQ;gBACX,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,GAAG,MAAM,GAAG,CAAC,CAAC;gBACpD,MAAM;YACR,KAAK,OAAO;gBACV,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,GAAG,MAAM,GAAG,CAAC,CAAC;gBACpD,MAAM;YACR;gBACE,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,GAAG,MAAM,GAAG,CAAC,CAAC;gBACpD,MAAM;SACT;IACH,CAAC;IAED,eAAe,CAAC,UAAU;QACxB,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,IAAI,UAAU,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;YAC7C,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;gBAC3B,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE;oBACX,OAAO,GAAG,IAAI,CAAC;oBACf,OAAO,KAAK,CAAC;iBACd;gBACD,OAAO,IAAI,CAAC;YACd,CAAC,CAAC,CAAC;SACJ;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,kBAAkB,CAAC,UAAU;QAC3B,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,UAAU,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;YAC7C,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;gBAC7B,IAAI,CAAC,CAAC,IAAI,EAAE;oBACV,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC;iBACjB;YACH,CAAC,CAAC,CAAC;SACJ;QACD,OAAO,KAAK,CAAC;IACf,CAAC;;;;YAptCF,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB","sourcesContent":["/* eslint-disable no-use-before-define */\r\n/* eslint-disable @typescript-eslint/no-use-before-define */\r\n/* eslint-disable no-param-reassign */\r\n/* eslint-disable @typescript-eslint/no-explicit-any */\r\n/* eslint-disable @typescript-eslint/no-shadow */\r\n/* eslint-disable @typescript-eslint/no-unused-vars */\r\n/* eslint-disable no-new */\r\nimport { Injectable } from '@angular/core';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport * as $ from 'jquery';\r\nimport * as _ from 'lodash';\r\nimport InspectorFunction from '../common/bpmn/inspector.function';\r\nimport ToolbarFunction from '../common/bpmn/toolbar.function';\r\nimport { FlowChartConst } from '../common/constants/ckeditorFlowchart.const';\r\nimport { FlowchartViewMode } from '../common/enums/flowchart-view-mode.enum';\r\nimport guidHelper from '../common/helper/guidHelper';\r\n\r\n/* Declare jointjs object */\r\ndeclare var joint: any;\r\nlet graph: any;\r\nlet paper: any;\r\nlet toolbarConfig: any;\r\nconst bpmn2 = joint.shapes.bpmn2;\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class BpmnService {\r\n  public isSaveAsTemplate = false;\r\n  public isDeleteTemplate = false;\r\n  public isDisableToolbar = false;\r\n  public isTemp = true;\r\n  public jsonTempContent = '';\r\n  public isReset = false;\r\n  public isSelectedTemplate = false;\r\n  public jsonOriginalContent = '';\r\n\r\n  buildDiagram(\r\n    diagramTemplates: any,\r\n    diagramTemplate: any,\r\n    bpmnTheme: string,\r\n    jsonContent: any,\r\n    editMode: any,\r\n    LANG: any\r\n  ) {\r\n    window[`IS_NOT_SHOW_AGAIN`] = false;\r\n    window[FlowChartConst.EDIT_MODE] = editMode;\r\n    joint.setTheme(bpmnTheme);\r\n\r\n    if (jsonContent) {\r\n      jsonContent = JSON.parse(jsonContent);\r\n    } else {\r\n      jsonContent = '';\r\n    }\r\n\r\n    const gdAuth = window[`gdAuth`];\r\n    const gdLoad = window[`gdLoad`];\r\n    const gdSave = window[`gdSave`];\r\n    const inputs = InspectorFunction.getInspectorConfiguration(bpmn2, LANG);\r\n\r\n    let freeTransform = null;\r\n\r\n    toolbarConfig = ToolbarFunction.getToolbarConfiguration(LANG);\r\n    /* QMS-1404: Customization: Add template list */\r\n    if (toolbarConfig.tools && diagramTemplates) {\r\n      const arrSelect = toolbarConfig.tools.filter((item) => {\r\n        return item.type === 'select-box';\r\n      });\r\n      if (arrSelect) {\r\n        diagramTemplates.forEach((item) => {\r\n          const option = {\r\n            index: item.index,\r\n            content: item.templateName,\r\n            flowChartId: item.id,\r\n            name: item.templateName,\r\n            jsonContent: item.jsonContent,\r\n            selected: false\r\n          };\r\n          const index = arrSelect[0].options.findIndex((x) => {\r\n            return x.index === option.index;\r\n          });\r\n          if (index < 0) {\r\n            arrSelect[0].options.push(option);\r\n          }\r\n        });\r\n      }\r\n    }\r\n\r\n    graph = new joint.dia.Graph({ type: 'bpmn' });\r\n    const commandManager = new joint.dia.CommandManager({ graph });\r\n    const keyboard = new joint.ui.Keyboard();\r\n    const clipboard = new joint.ui.Clipboard();\r\n\r\n    paper = new joint.dia.Paper({\r\n      width: 800,\r\n      height: 600,\r\n      model: graph,\r\n      gridSize: 10,\r\n      drawGrid: true,\r\n      async: true,\r\n      sorting: joint.dia.Paper.sorting.APPROX,\r\n      interactive: { linkMove: false },\r\n      snapLabels: true,\r\n      // Connections\r\n      defaultLink(elementView) {\r\n        return new bpmn2.Flow({\r\n          z: elementView.model.get('z') - 1,\r\n          attrs: {\r\n            line: {\r\n              flowType: 'sequence'\r\n            }\r\n          }\r\n        });\r\n      },\r\n      validateConnection(cellViewS, magnetS, cellViewT, magnetT, end) {\r\n        const source = cellViewS.model;\r\n        const target = cellViewT.model;\r\n        // don't allow loop links\r\n        if (source === target) {\r\n          return false;\r\n        }\r\n        // don't allow link to link connection\r\n        if (source.isLink()) {\r\n          return false;\r\n        }\r\n        if (target.isLink()) {\r\n          return false;\r\n        }\r\n        // don't allow group connections\r\n        const sourceType = source.get('type');\r\n        const targetType = target.get('type');\r\n        if (sourceType === 'bpmn2.Group' || targetType === 'bpmn2.Group') {\r\n          return false;\r\n        }\r\n        return true;\r\n      },\r\n      defaultAnchor: {\r\n        name: 'perpendicular'\r\n      },\r\n      defaultConnectionPoint: {\r\n        name: 'boundary',\r\n        args: { stroke: true }\r\n      },\r\n      // Embedding\r\n      embeddingMode: true,\r\n      frontParentOnly: false,\r\n      validateEmbedding(childView, parentView) {\r\n        const parentType = parentView.model.get('type');\r\n        const childType = childView.model.get('type');\r\n        if (parentType === 'bpmn2.HeaderedPool' && childType !== 'bpmn2.HeaderedPool') {\r\n          return true;\r\n        }\r\n        if (parentType === 'bpmn2.Activity' && childType === 'bpmn2.Event') {\r\n          return true;\r\n        }\r\n        return false;\r\n      },\r\n      // Highlighting\r\n      highlighting: {\r\n        default: {\r\n          name: 'mask',\r\n          options: {\r\n            attrs: {\r\n              stroke: '#3498db',\r\n              'stroke-width': 3,\r\n              'stroke-linejoin': 'round'\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }).on({\r\n      'blank:pointerdown': (evt, x, y) => {\r\n        closeTools();\r\n        // selection.startSelecting(evt, x, y);\r\n        if (keyboard.isActive('shift', evt)) {\r\n          selection.startSelecting(evt, x, y);\r\n        } else {\r\n          selection.cancelSelection();\r\n          paperScroller.startPanning(evt, x, y);\r\n        }\r\n      },\r\n\r\n      'blank:contextmenu': (evt, x, y) => {\r\n        paperScroller.startPanning(evt, x, y);\r\n      },\r\n\r\n      'cell:pointerup': (cellView) => {\r\n        openTools(cellView);\r\n      },\r\n\r\n      'link:mouseenter': (linkView) => {\r\n        // Open tool only if there is none yet\r\n        if (linkView.hasTools()) {\r\n          return;\r\n        }\r\n\r\n        const ns = joint.linkTools;\r\n        const toolsView = new joint.dia.ToolsView({\r\n          name: 'link-hover',\r\n          tools: [\r\n            new ns.Vertices({ vertexAdding: false }),\r\n            new ns.SourceArrowhead(),\r\n            new ns.TargetArrowhead()\r\n          ]\r\n        });\r\n\r\n        linkView.addTools(toolsView);\r\n      },\r\n\r\n      'link:mouseleave': (linkView) => {\r\n        // Remove only the hover tool, not the pointerdown tool\r\n        if (linkView.hasTools('link-hover')) {\r\n          linkView.removeTools();\r\n        }\r\n      },\r\n\r\n      'link:connect': (linkView) => {\r\n        // Change the link type based on the connected elements\r\n        const link = linkView.model;\r\n        const source = link.getSourceCell();\r\n        const target = link.getTargetCell();\r\n        if (!source || !target) {\r\n          return;\r\n        }\r\n        link.set('z', -1);\r\n        const types = [source.get('type'), target.get('type')];\r\n        const linkType = link.get('type');\r\n        if (types.indexOf('bpmn2.Annotation') > -1) {\r\n          if (linkType === 'bpmn2.AnnotationLink') {\r\n            return;\r\n          }\r\n          replaceLink(graph, link, bpmn2.AnnotationLink);\r\n          return;\r\n        }\r\n        if (types.indexOf('bpmn2.Conversation') > -1) {\r\n          if (linkType === 'bpmn2.ConversationLink') {\r\n            return;\r\n          }\r\n          replaceLink(graph, link, bpmn2.ConversationLink);\r\n          return;\r\n        }\r\n        if (types.indexOf('bpmn2.DataObject') > -1) {\r\n          if (linkType === 'bpmn2.DataAssociation') {\r\n            return;\r\n          }\r\n          replaceLink(graph, link, bpmn2.DataAssociation);\r\n          return;\r\n        }\r\n        if (types.indexOf('bpmn2.DataStore') > -1) {\r\n          if (linkType === 'bpmn2.DataAssociation') {\r\n            return;\r\n          }\r\n          replaceLink(graph, link, bpmn2.DataAssociation);\r\n          return;\r\n        }\r\n        if (linkType !== 'bpmn2.Flow') {\r\n          replaceLink(graph, link, bpmn2.Flow);\r\n        }\r\n      }\r\n    });\r\n\r\n    const snaplines = new joint.ui.Snaplines({ paper });\r\n\r\n    const paperScroller = new joint.ui.PaperScroller({\r\n      autoResizePaper: true,\r\n      padding: 20,\r\n      paper,\r\n      scrollWhileDragging: true\r\n    });\r\n\r\n    paperScroller.$el.appendTo('#paper-container');\r\n    paperScroller.setCursor('grab');\r\n    paperScroller.render().center();\r\n\r\n    paper.on('blank:mousewheel', _.partial(onMousewheel, null), this);\r\n    paper.on('cell:mousewheel', onMousewheel, this);\r\n    function onMousewheel(cellView, evt, x, y, delta) {\r\n      paperScroller.zoom(delta * 0.1, { min: 0.2, max: 5, grid: 0.1, ox: x, oy: y });\r\n    }\r\n\r\n    /* SELECTION */\r\n    const selection = new joint.ui.Selection({\r\n      paper,\r\n      graph,\r\n      useModelGeometry: true,\r\n      filter: ['bpmn2.HeaderedPool'] // don't allow to select a pool\r\n    });\r\n\r\n    /* STENCIL */\r\n\r\n    const stencil = new joint.ui.Stencil({\r\n      graph,\r\n      paper,\r\n      width: '100%',\r\n      height: '100%',\r\n      dragEndClone(cell) {\r\n        const clone = cell.clone();\r\n        const type = clone.get('type');\r\n\r\n        // some types of the elements need resizing after they are dropped\r\n        const sizeMultiplier = { 'bpmn2.HeaderedPool': 8, 'bpmn.Choreography': 2 }[type];\r\n        if (sizeMultiplier) {\r\n          const originalSize = clone.get('size');\r\n          clone.set('size', {\r\n            width: originalSize.width * sizeMultiplier,\r\n            height: originalSize.height * sizeMultiplier\r\n          });\r\n          if (type === 'bpmn2.HeaderedPool') {\r\n            clone.set('padding', { top: 0, left: 30, right: 0, bottom: 0 });\r\n          }\r\n        }\r\n        return clone;\r\n      }\r\n    });\r\n\r\n    stencil.render().$el.appendTo('#stencil-container');\r\n\r\n    stencil.load([\r\n      new bpmn2.Activity({\r\n        attrs: {\r\n          label: {\r\n            stroke: 'white',\r\n            strokeWidth: 2,\r\n            paintOrder: 'stroke'\r\n          }\r\n        }\r\n      }),\r\n      new bpmn2.Gateway({\r\n        attrs: {\r\n          label: {\r\n            stroke: 'white',\r\n            strokeWidth: 2,\r\n            paintOrder: 'stroke'\r\n          }\r\n        }\r\n      }),\r\n      new bpmn2.Event({\r\n        attrs: {\r\n          label: {\r\n            stroke: 'white',\r\n            strokeWidth: 2,\r\n            paintOrder: 'stroke'\r\n          }\r\n        }\r\n      }),\r\n      new bpmn2.Conversation({\r\n        attrs: {\r\n          label: {\r\n            stroke: 'white',\r\n            strokeWidth: 2,\r\n            paintOrder: 'stroke'\r\n          }\r\n        }\r\n      }),\r\n      new bpmn2.DataObject({\r\n        attrs: {\r\n          label: {\r\n            stroke: 'white',\r\n            strokeWidth: 2,\r\n            paintOrder: 'stroke'\r\n          }\r\n        }\r\n      }),\r\n      new bpmn2.DataStore({\r\n        attrs: {\r\n          label: {\r\n            stroke: 'white',\r\n            strokeWidth: 2,\r\n            paintOrder: 'stroke'\r\n          }\r\n        }\r\n      }),\r\n      new bpmn2.Annotation({\r\n        attrs: {\r\n          body: {\r\n            fill: '#ffffff'\r\n          },\r\n          label: {\r\n            stroke: 'white',\r\n            strokeWidth: 2,\r\n            paintOrder: 'stroke'\r\n          }\r\n        }\r\n      }),\r\n      new bpmn2.Group({\r\n        size: {\r\n          width: 80,\r\n          height: 80\r\n        },\r\n        attrs: {\r\n          label: {\r\n            text: 'Group',\r\n            stroke: 'white',\r\n            strokeWidth: 2,\r\n            paintOrder: 'stroke'\r\n          }\r\n        }\r\n      }),\r\n      // Legacy BPMN Shapes\r\n      new bpmn2.HeaderedPool({\r\n        padding: { top: 0, left: 15, right: 0, bottom: 0 },\r\n        size: { width: 80, height: 50 },\r\n        lanes: [{ label: 'Lane 1' }, { label: 'Lane 2' }],\r\n        attrs: {\r\n          body: { fill: '#FFFFFF' },\r\n          headerLabel: { text: 'Header' }\r\n        }\r\n      }),\r\n      new joint.shapes.bpmn.Choreography({\r\n        participants: ['Participant 1', 'Participant 2'],\r\n        attrs: {\r\n          label: {\r\n            stroke: 'white',\r\n            strokeWidth: 2,\r\n            paintOrder: 'stroke'\r\n          }\r\n        }\r\n      }),\r\n      new joint.shapes.bpmn.Message({\r\n        attrs: {\r\n          text: {\r\n            stroke: 'white',\r\n            strokeWidth: 2,\r\n            paintOrder: 'stroke'\r\n          }\r\n        }\r\n      })\r\n    ]);\r\n\r\n    joint.layout.GridLayout.layout(stencil.getGraph(), {\r\n      columns: 100,\r\n      columnWidth: 'compact',\r\n      marginX: 20,\r\n      marginY: 20,\r\n      columnGap: 40,\r\n      verticalGap: 20,\r\n      resizeToFit: false\r\n    });\r\n\r\n    // Create tooltips for all the shapes in stencil.\r\n    stencil.on('element:drop', (elementView) => {\r\n      // open inspector after a new element dropped from stencil\r\n      openTools(elementView);\r\n    });\r\n\r\n    /* KEYBOARD */\r\n    if (editMode === FlowchartViewMode.Edit) {\r\n      initializeKeyboardShortcuts();\r\n    }\r\n\r\n    function initializeKeyboardShortcuts() {\r\n      keyboard.on(\r\n        {\r\n          'ctrl+c': () => {\r\n            // Copy all selected elements and their associated links.\r\n            clipboard.copyElements(selection.collection, graph);\r\n          },\r\n\r\n          'ctrl+v': () => {\r\n            const pastedCells = clipboard.pasteCells(graph, {\r\n              translate: { dx: 20, dy: 20 },\r\n              useLocalStorage: true\r\n            });\r\n\r\n            const elements = _.filter(pastedCells, (cell) => {\r\n              return cell.isElement();\r\n            });\r\n\r\n            // Make sure pasted elements get selected immediately. This makes the UX better as\r\n            // the user can immediately manipulate the pasted elements.\r\n            selection.collection.reset(elements);\r\n          },\r\n\r\n          'ctrl+x shift+delete': () => {\r\n            clipboard.cutElements(selection.collection, graph);\r\n          },\r\n\r\n          'delete backspace': (evt) => {\r\n            evt.preventDefault();\r\n            graph.removeCells(selection.collection.toArray());\r\n          },\r\n\r\n          'ctrl+z': () => {\r\n            commandManager.undo();\r\n            selection.cancelSelection();\r\n          },\r\n\r\n          'ctrl+y': () => {\r\n            commandManager.redo();\r\n            selection.cancelSelection();\r\n          },\r\n\r\n          'ctrl+a': () => {\r\n            selection.collection.reset(graph.getElements());\r\n          },\r\n\r\n          'ctrl+plus': (evt) => {\r\n            evt.preventDefault();\r\n            paperScroller.zoom(0.2, { max: 5, grid: 0.2 });\r\n          },\r\n\r\n          'ctrl+minus': (evt) => {\r\n            evt.preventDefault();\r\n            paperScroller.zoom(-0.2, { min: 0.2, grid: 0.2 });\r\n          },\r\n\r\n          'keydown:shift': (evt) => {\r\n            paperScroller.setCursor('crosshair');\r\n          },\r\n\r\n          'keyup:shift': () => {\r\n            paperScroller.setCursor('grab');\r\n          }\r\n        },\r\n        this\r\n      );\r\n    }\r\n\r\n    function openTools(cellView) {\r\n      if (!cellView) {\r\n        return;\r\n      }\r\n      closeTools();\r\n      window[`my_cellView`] = cellView;\r\n      const cell = cellView.model;\r\n      const type = cell.get('type');\r\n      // const tablName = window[FlowChartConst.TAB_NAME];\r\n      // if (tablName === FlowChartConst.TAB_BPMN_CHOREOGRAPHY) {\r\n      //   const inspector = joint.ui.Inspector.create('#inspector-container', {\r\n      //     cell,\r\n      //     inputs: inputs[type],\r\n      //     groups: {\r\n      //       general: { label: type, index: 1 },\r\n      //       defaults: { index: 2 },\r\n      //       fontsize: { index: 3 },\r\n      //       appearance: { index: 4 }\r\n      //     }\r\n      //   });\r\n      // }\r\n\r\n      const inspector = joint.ui.Inspector.create('#inspector-container', {\r\n        cell,\r\n        inputs: inputs[type],\r\n        groups: {\r\n          general: { label: type, index: 1 },\r\n          defaults: { index: 2 },\r\n          fontsize: { index: 3 },\r\n          appearance: { index: 4 }\r\n        }\r\n      });\r\n\r\n      selection.collection.reset([]);\r\n      // Add the cell into the selection collection silently\r\n      // so no selection box is rendered above the cellView.\r\n      selection.collection.add(cell, { silent: true });\r\n\r\n      if (cell.isElement()) {\r\n        let minSize;\r\n\r\n        if (cell instanceof bpmn2.HeaderedPool) {\r\n          minSize = cell.getMinimalSize();\r\n        } else {\r\n          minSize = { width: 30, height: 30 };\r\n        }\r\n\r\n        freeTransform = new joint.ui.FreeTransform({\r\n          cellView,\r\n          allowOrthogonalResize: false,\r\n          allowRotation: false,\r\n          minWidth: minSize.width,\r\n          minHeight: minSize.height\r\n        }).render();\r\n\r\n        const halo = new joint.ui.Halo({\r\n          cellView,\r\n          theme: 'default',\r\n          type: 'toolbar',\r\n          useModelGeometry: true,\r\n          boxContent: (cellView) => {\r\n            return cellView.model.get('type');\r\n          }\r\n        });\r\n\r\n        if (type === 'bpmn2.HeaderedPool') {\r\n          halo.removeHandle('link');\r\n          halo.removeHandle('fork');\r\n          halo.removeHandle('unlink');\r\n        }\r\n        halo.render();\r\n      }\r\n\r\n      if (cell.isLink()) {\r\n        const ns = joint.linkTools;\r\n        const toolsView = new joint.dia.ToolsView({\r\n          name: 'link-pointerdown',\r\n          tools: [\r\n            new ns.Vertices(),\r\n            new ns.SourceAnchor(),\r\n            new ns.TargetAnchor(),\r\n            new ns.SourceArrowhead(),\r\n            new ns.TargetArrowhead(),\r\n            new ns.Segments(),\r\n            new ns.Boundary({ padding: 15 }),\r\n            new ns.Remove({ offset: -20, distance: 40 })\r\n          ]\r\n        });\r\n\r\n        cellView.addTools(toolsView);\r\n      }\r\n\r\n      /* QMS-2364: show link and poiter change to hand */\r\n      // if (window[`event`][`type`] === 'mouseover' && editMode === FlowchartViewMode.View) {\r\n      //   const list = document.getElementsByClassName(`joint-element`);\r\n      //   if (list && list.length > 0) {\r\n      //     const shapeId = cellView.model.attributes.id;\r\n      //     // tslint:disable-next-line:prefer-for-of\r\n      //     for (let i = 0; i < list.length; i++) {\r\n      //       if (list[i].attributes[0].nodeValue !== shapeId) {\r\n      //         list[i][`style`].cursor = 'move';\r\n      //         continue;\r\n      //       }\r\n      //       const shapeDetailModel = window[`SHAPE_DETAIL_MODEL`];\r\n      //       if (!shapeDetailModel) {\r\n      //         list[i][`style`].cursor = 'move';\r\n      //         continue;\r\n      //       }\r\n      //       const index = shapeDetailModel.findIndex((x) => {\r\n      //         return x.shapeId === shapeId;\r\n      //       });\r\n      //       if (index < 0) {\r\n      //         list[i][`style`].cursor = 'move';\r\n      //         continue;\r\n      //       }\r\n      //       const shapeDetail = shapeDetailModel[index];\r\n      //       let connectionName = '';\r\n      //       if (shapeDetail.connectionTypeId === ShapeFlowChartConnectionType.Activity) {\r\n      //         list[i][`style`].cursor = 'move';\r\n      //         connectionName = translate.instant('PROCESS.LINK_TO_ACTIVITY');\r\n      //       } else if (shapeDetail.connectionTypeId === ShapeFlowChartConnectionType.Link) {\r\n      //         connectionName = translate.instant('PROCESS.LINK');\r\n      //       } else if (shapeDetail.connectionTypeId === ShapeFlowChartConnectionType.DocumentOrProcess) {\r\n      //         // eslint-disable-next-line default-case\r\n      //         switch (shapeDetail.documentModel.relatedItems[0].itemType) {\r\n      //           case RelatedItemType.document:\r\n      //             connectionName = translate.instant('PROCESS.LINK_TO_DOCUMENT');\r\n      //             break;\r\n      //           case RelatedItemType.process:\r\n      //             connectionName = translate.instant('PROCESS.LINK_TO_PROCESS');\r\n      //             break;\r\n      //           case RelatedItemType.area:\r\n      //             connectionName = translate.instant('PROCESS.LINK_TO_AREA');\r\n      //             break;\r\n      //           case RelatedItemType.handbook:\r\n      //             connectionName = translate.instant('PROCESS.LINK_TO_FOLDER');\r\n      //             break;\r\n      //         }\r\n      //       }\r\n      //       if (shapeDetail.connectionTypeId !== ShapeFlowChartConnectionType.Activity) {\r\n      //         list[i][`style`].cursor = 'pointer';\r\n      //       }\r\n      //       const halo = new joint.ui.Halo({\r\n      //         cellView,\r\n      //         theme: 'default',\r\n      //         boxContent: connectionName\r\n      //       });\r\n      //       halo.render();\r\n      //       halo.removeHandle('remove');\r\n      //       halo.removeHandle('resize');\r\n      //       halo.removeHandle('clone');\r\n      //       halo.removeHandle('link');\r\n      //       halo.removeHandle('fork');\r\n      //       halo.removeHandle('unlink');\r\n      //       halo.removeHandle('rotate');\r\n      //     }\r\n      //   }\r\n\r\n      //   const shapeElement = document.getElementsByClassName('no-rotation');\r\n      //   if (shapeElement && shapeElement.length > 0) {\r\n      //     for (let i = 0; i < shapeElement.length; i++) {\r\n      //       if (!shapeElement[i].classList.contains('joint-free-transform')) {\r\n      //         shapeElement[i].classList.add('joint-free-transform');\r\n      //       }\r\n      //     }\r\n      //   }\r\n      // } else if (window[`event`][`type`] === 'mouseout' && editMode === FlowchartViewMode.View) {\r\n      //   const halo = new joint.ui.Halo({\r\n      //     cellView,\r\n      //     theme: 'default',\r\n      //     boxContent: ''\r\n      //   });\r\n      //   halo.render();\r\n      //   halo.removeHandle('remove');\r\n      //   halo.removeHandle('resize');\r\n      //   halo.removeHandle('clone');\r\n      //   halo.removeHandle('link');\r\n      //   halo.removeHandle('fork');\r\n      //   halo.removeHandle('unlink');\r\n      //   halo.removeHandle('rotate');\r\n      //   const shapeElement = document.getElementsByClassName('no-rotation');\r\n      //   if (shapeElement && shapeElement.length > 0) {\r\n      //     for (let i = 0; i < shapeElement.length; i++) {\r\n      //       shapeElement[i].classList.remove('joint-free-transform');\r\n      //     }\r\n      //   }\r\n      // } else {\r\n      //   /* QMS-2125: Show process connect type */\r\n      //   window[FlowChartConst.IS_SHOW_CONNECTYPE] = true;\r\n      //   window[FlowChartConst.SELECTED_SHAPE_ID] = cellView.model.attributes.id;\r\n      //   window[FlowChartConst.SHAPE_TYPE] = cellView.model.attributes.type;\r\n      //   window[FlowChartConst.SHAPE_FLOWCHART_LOADING] = true;\r\n      // }\r\n      /* QMS-2125: Show process connect type */\r\n      window[FlowChartConst.IS_SHOW_CONNECTYPE] = true;\r\n      window[FlowChartConst.SELECTED_SHAPE_ID] = cellView.model.attributes.id;\r\n      window[FlowChartConst.SHAPE_TYPE] = cellView.model.attributes.type;\r\n      window[FlowChartConst.SHAPE_FLOWCHART_LOADING] = true;\r\n      /* QMS-1404: Customization */\r\n      window[FlowChartConst.PAPER] = paper;\r\n    }\r\n\r\n    function closeTools() {\r\n      paper.removeTools();\r\n      joint.ui.Inspector.close();\r\n      joint.ui.FreeTransform.clear(paper);\r\n      freeTransform = null;\r\n      joint.ui.Halo.clear(paper);\r\n    }\r\n\r\n    function showStatus(message, type) {\r\n      $('.status').removeClass('info error success').addClass(type).html(message);\r\n      $('#statusbar-container')\r\n        .dequeue()\r\n        .addClass('active')\r\n        .delay(3000)\r\n        .queue(() => {\r\n          $(this).removeClass('active');\r\n        });\r\n    }\r\n\r\n    function replaceLink(graph, link, linkConstructor) {\r\n      // eslint-disable-next-line new-cap\r\n      const link2 = new linkConstructor({\r\n        source: link.source(),\r\n        target: link.target(),\r\n        vertices: link.vertices()\r\n      });\r\n      link.remove();\r\n      link2.set('z', -1);\r\n      link2.addTo(graph);\r\n    }\r\n\r\n    graph.on('change', (cell, opt) => {\r\n      this.onChangeTextInside(cell);\r\n      this.onChangeLinkLabel(cell, 12);\r\n      this.onChangeAlligment(cell, opt);\r\n      if (!opt.inspector || !freeTransform || cell.get('type') !== 'bpmn2.HeaderedPool') {\r\n        return;\r\n      }\r\n      const minSize = cell.getMinimalSize();\r\n      freeTransform.options.minWidth = minSize.width;\r\n      freeTransform.options.minHeight = minSize.height;\r\n    });\r\n\r\n    /* TOOLBAR */\r\n    const toolbar = new joint.ui.Toolbar({\r\n      tools: toolbarConfig.tools,\r\n      references: {\r\n        paperScroller,\r\n        commandManager\r\n      }\r\n    });\r\n\r\n    const toolbarCommands = {\r\n      toJSON: () => {\r\n        const windowFeatures = 'menubar=no,location=no,resizable=yes,scrollbars=yes,status=no';\r\n        const windowName = _.uniqueId('json_output');\r\n        const jsonWindow = window.open('', windowName, windowFeatures);\r\n\r\n        jsonWindow.document.write(JSON.stringify(graph.toJSON()));\r\n      },\r\n      loadGraph: () => {\r\n        gdAuth(() => {\r\n          showStatus('loading..', 'info');\r\n          gdLoad((name, content) => {\r\n            try {\r\n              const json = JSON.parse(content);\r\n              graph.fromJSON(json);\r\n              const elFileName = <HTMLButtonElement>document.getElementById('fileName');\r\n              elFileName.value = name.replace(/.json$/, '');\r\n              showStatus('loaded.', 'success');\r\n            } catch (e) {\r\n              showStatus('failed.', 'error');\r\n            }\r\n          });\r\n        }, true);\r\n      },\r\n\r\n      saveGraph: () => {\r\n        gdAuth(() => {\r\n          showStatus('saving..', 'info');\r\n          // let name = document.getElementById('fileName').value;\r\n          const name = <HTMLButtonElement>document.getElementById('fileName');\r\n          gdSave(name.value, JSON.stringify(graph.toJSON()), (file) => {\r\n            if (file) {\r\n              showStatus('saved.', 'success');\r\n            } else {\r\n              showStatus('failed.', 'error');\r\n            }\r\n          });\r\n        }, true);\r\n      },\r\n      onSelected: (event) => {\r\n        if (event.jsonContent) {\r\n          window[FlowChartConst.SELECTED_FLOWCHART_ID] = event.flowChartId;\r\n          window[FlowChartConst.SELECTED_JSON_CONTENT] = event.jsonContent;\r\n          window[FlowChartConst.IS_SELECTED_TEMPLATE] = true;\r\n          this.jsonOriginalContent = JSON.stringify(graph.toJSON());\r\n          window[FlowChartConst.ORG_JSONCONTENT] = this.jsonOriginalContent;\r\n          window.postMessage(FlowChartConst.CHANGING_TEMPLATE, this.getOriginForSelf());\r\n        }\r\n      },\r\n\r\n      onDeleteTemplate: () => {\r\n        this.isSelectedTemplate = window[FlowChartConst.IS_SELECTED_TEMPLATE];\r\n        if (this.isSelectedTemplate) {\r\n          window.postMessage(FlowChartConst.DELETE_TEMPLATE, this.getOriginForSelf());\r\n        } else {\r\n          window.postMessage(FlowChartConst.MUST_SELECT_TEMPLATE, this.getOriginForSelf());\r\n        }\r\n      },\r\n\r\n      onSaveAsTemplate: () => {\r\n        window.postMessage(FlowChartConst.SAVE_AS_TEMPLATE, this.getOriginForSelf());\r\n      },\r\n\r\n      onResetToTempTemplate: () => {\r\n        this.isSelectedTemplate = window[FlowChartConst.IS_SELECTED_TEMPLATE];\r\n        if (this.isSelectedTemplate) {\r\n          window.postMessage(FlowChartConst.RESET_TEMPLATE, this.getOriginForSelf());\r\n        }\r\n      },\r\n\r\n      changeSnapLines(checked) {\r\n        if (checked) {\r\n          snaplines.startListening();\r\n          stencil.options.snaplines = this.snaplines;\r\n        } else {\r\n          snaplines.stopListening();\r\n          stencil.options.snaplines = null;\r\n        }\r\n      },\r\n\r\n      applyOnSelection(method) {\r\n        graph.startBatch('selection');\r\n        selection.collection.models.forEach((model) => {\r\n          model[method]();\r\n        });\r\n        graph.stopBatch('selection');\r\n      }\r\n    };\r\n    toolbar.on({\r\n      'tojson:pointerclick': toolbarCommands.toJSON,\r\n      'load:pointerclick': toolbarCommands.loadGraph,\r\n      'save:pointerclick': toolbarCommands.saveGraph,\r\n      'clear:pointerclick': _.bind(graph.clear, graph),\r\n      'print:pointerclick': _.bind(paper.print, paper),\r\n      'saveAsTemplate:pointerclick': toolbarCommands.onSaveAsTemplate,\r\n      'selectTemplate:option:select': toolbarCommands.onSelected,\r\n      'deleteTemplate:pointerclick': toolbarCommands.onDeleteTemplate,\r\n      'resetToTempTemplate:pointerclick': toolbarCommands.onResetToTempTemplate,\r\n      'to-front:pointerclick': toolbarCommands.applyOnSelection.bind(this, 'toFront'),\r\n      'to-back:pointerclick': toolbarCommands.applyOnSelection.bind(this, 'toBack'),\r\n      'snapline:change': toolbarCommands.changeSnapLines.bind(this),\r\n      'grid-size:change': paper.setGridSize.bind(paper)\r\n    });\r\n\r\n    toolbar.render().$el.appendTo('#toolbar-container');\r\n\r\n    // const zoomTool = new joint.ui.Toolbar({\r\n    //   // initi alize tools with default settings\r\n    //   tools: ['zoomToFit', 'zoomIn', 'zoomOut'],\r\n    //   references: {\r\n    //     paperScroller,\r\n    //     commandManager\r\n    //   }\r\n    // });\r\n\r\n    // zoomTool.render().$el.appendTo('#zoomToolbar');\r\n\r\n    new joint.ui.Tooltip({\r\n      target: '[data-tooltip]',\r\n      content(el) {\r\n        return el.dataset.tooltip;\r\n      },\r\n      top: '.joint-toolbar',\r\n      padding: 10,\r\n      direction: 'top'\r\n    });\r\n\r\n    // Create tooltips for all the shapes in stencil.\r\n    stencil\r\n      .getGraph()\r\n      .get('cells')\r\n      .each((cell) => {\r\n        new joint.ui.Tooltip({\r\n          target: `.joint-stencil [model-id=\"${cell.id}\"]`,\r\n          content: cell.get('type').split('.')[1],\r\n          bottom: '.joint-stencil',\r\n          direction: 'bottom',\r\n          padding: 0\r\n        });\r\n      });\r\n\r\n    Object.assign(joint.shapes.bpmn.icons, this.buildNewIcons());\r\n    /* Load  process digram */\r\n    this.loadProcessDiagram(jsonContent);\r\n    this.jsonOriginalContent = JSON.stringify(graph.toJSON());\r\n    paperScroller.positionContent('top-left', { padding: 50, useModelGeometry: true });\r\n\r\n    /* Set g raph object */\r\n    window[FlowChartConst.GRAPH] = graph;\r\n    window[FlowChartConst.PAPER] = paper;\r\n    window[FlowChartConst.PAPER_SCROLLER] = paperScroller;\r\n    window[FlowChartConst.ORG_JSONCONTENT] = this.jsonOriginalContent;\r\n    window.postMessage(FlowChartConst.DIAGRAM_LOADED, this.getOriginForSelf());\r\n  }\r\n\r\n  buildNewIcons({ color = '#000' } = {}) {\r\n    const svgIcons = {\r\n      message1: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"12 12 16 16\"><path fill=\"none\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.2\" d=\"M12.5 15.313v9.374h15v-9.375zm0 0l7.5 5.624 7.5-5.625\"/></svg>`,\r\n      message2: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"12 12 16 16\"><path fill=\"${color}\" d=\"M12.5 14.344l7.5 5.625 7.5-5.625zm0 .937v9.375h15v-9.375L20 20.906z\"/></svg>`,\r\n      timer1: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><g fill=\"none\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\"><circle cx=\"20\" cy=\"20\" r=\"10\"/><path d=\"M20 10v3m5-2l-1.5 3m5.5 1l-3 1.5m4 3.5h-3m2 5l-3-1.5M25 29l-1.5-3M20 30v-3m-5 2l1.5-3M11 25l3-1.5M10 20h3m-2-5l3 1.5m1-5.5l1.5 3m5.5-1l-2 7h4\"/></g></svg>`,\r\n      conditional1: `<svg xmlns=\"http://www.w3.org/2000/svg\" ><path fill=\"none\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M11.563 11.563h16.874v16.874H11.563V11.563m2.813 2.813h11.25m-11.25 3.75h11.25m-11.25 3.75h11.25m-11.25 3.75h11.25z\"/></svg>`,\r\n      link1: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><path fill=\"none\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M14.406 18.125h8.438v-2.813L27.53 20l-4.687 4.688v-2.813h-9.375v-3.75\"/></svg>`,\r\n      link2: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><path fill=\"${color}\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M14.406 18.125h8.438v-2.813L27.53 20l-4.687 4.688v-2.813h-9.375v-3.75\"/></svg>`,\r\n      signal1: `<svg xmlns=\"http://www.w3.org/2000/svg\"  viewBox=\"8 8 24 24\"><path fill=\"none\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M13.17 24.851h13.706l-6.853-11.879-6.854 11.88z\"/></svg>`,\r\n      signal2: `<svg xmlns=\"http://www.w3.org/2000/svg\"  viewBox=\"8 8 24 24\"><path fill=\"${color}\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M13.17 24.851h13.706l-6.853-11.879-6.854 11.88z\"/></svg>`,\r\n      error1: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><path fill=\"none\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M26.4 15.455l-3.238 12.58L17.7 18.37 13.76 23.8l3.478-12.412 5.576 8.72 3.586-4.652z\"/></svg>`,\r\n      error2: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><path fill=\"${color}\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M26.4 15.455l-3.238 12.58L17.7 18.37 13.76 23.8l3.478-12.412 5.576 8.72 3.586-4.652z\"/></svg>`,\r\n      escalation1: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><path fill=\"none\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M20 13.219l5.625 14.062L20 20.953l-5.625 6.328z\"/></svg>`,\r\n      escalation2: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><path fill=\"${color}\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M20 13.219l5.625 14.062L20 20.953l-5.625 6.328z\"/></svg>`,\r\n      termination1: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><circle cx=\"20\" cy=\"20\" r=\"10.5\" fill=\"none\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\"/></svg>`,\r\n      termination2: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><circle cx=\"20\" cy=\"20\" r=\"10.5\" fill=\"${color}\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\"/></svg>`,\r\n      compensation1: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><path fill=\"none\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M19 13.438v13.124L12.437 20 19 13.437m6.563 0v13.126L19 20l6.563-6.563z\"/></svg>`,\r\n      compensation2: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><path fill=\"${color}\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M19 13.438v13.124L12.437 20 19 13.437m6.563 0v13.126L19 20l6.563-6.563z\"/></svg>`,\r\n      cancel1: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><path fill=\"none\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M11.284 14.274l2.867-2.868 5.735 5.735 5.735-5.735 2.868 2.868-5.735 5.735 5.735 5.735-2.868 2.867-5.735-5.735-5.735 5.735-2.867-2.867 5.735-5.735-5.735-5.735z\"/></svg>`,\r\n      cancel2: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><path fill=\"${color}\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M11.284 14.274l2.867-2.868 5.735 5.735 5.735-5.735 2.868 2.868-5.735 5.735 5.735 5.735-2.868 2.867-5.735-5.735-5.735 5.735-2.867-2.867 5.735-5.735-5.735-5.735z\"/></svg>`,\r\n      multiple1: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><path fill=\"none\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M24.52 26.39h-9.443l-2.918-8.982 7.64-5.55 7.64 5.551-2.919 8.98z\"/></svg>`,\r\n      multiple2: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><path fill=\"${color}\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M24.52 26.39h-9.443l-2.918-8.982 7.64-5.55 7.64 5.551-2.919 8.98z\"/></svg>`,\r\n      parallel1: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><path fill=\"none\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M11.344 17.203v5.625h5.86v6.328h5.624v-6.328h6.328v-5.625h-6.328v-5.86h-5.625v5.86z\"/></svg>`,\r\n      parallel2: `<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"8 8 24 24\"><path fill=\"${color}\" stroke=\"${color}\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"1.5\" d=\"M11.344 17.203v5.625h5.86v6.328h5.624v-6.328h6.328v-5.625h-6.328v-5.86h-5.625v5.86z\"/></svg>`\r\n    };\r\n\r\n    const icons = {};\r\n\r\n    Object.keys(svgIcons).forEach((iconName) => {\r\n      icons[iconName] = `data:image/svg+xml,${encodeURIComponent(svgIcons[iconName])}`;\r\n    });\r\n    return icons;\r\n  }\r\n\r\n  loadProcessDiagram(jsonContent?: string) {\r\n    if (!jsonContent) {\r\n      return;\r\n    }\r\n    graph.fromJSON(jsonContent);\r\n  }\r\n\r\n  addItemTemplate(flowChartId?: string, diagramTemplate?: any) {\r\n    if (toolbarConfig.tools) {\r\n      const arrSelect = toolbarConfig.tools.filter((item) => {\r\n        return item.type === 'select-box';\r\n      });\r\n      if (arrSelect) {\r\n        const option = {\r\n          index: 1,\r\n          content: diagramTemplate.templateName,\r\n          flowChartId,\r\n          name: diagramTemplate.name,\r\n          jsonContent: diagramTemplate.jsonContent,\r\n          selected: false\r\n        };\r\n        arrSelect[0].options.push(option);\r\n      }\r\n    }\r\n  }\r\n\r\n  removeSelectItem(flowChartId?: string) {\r\n    if (toolbarConfig.tools) {\r\n      const arrSelect = toolbarConfig.tools.filter((item) => {\r\n        return item.type === 'select-box';\r\n      });\r\n      if (arrSelect) {\r\n        arrSelect[0].options.splice(\r\n          arrSelect[0].options.findIndex((i) => {\r\n            return i.flowChartId === flowChartId;\r\n          }),\r\n          1\r\n        );\r\n      }\r\n    }\r\n  }\r\n\r\n  getTempGraph() {\r\n    if (this.jsonTempContent) {\r\n      this.loadProcessDiagram(JSON.parse(this.jsonTempContent));\r\n    }\r\n    this.isTemp = true;\r\n    this.isReset = false;\r\n    this.isDisableToolbar = false;\r\n  }\r\n\r\n  getOriginForSelf() {\r\n    return '*';\r\n  }\r\n\r\n  setDefaultSelectedValue() {\r\n    if (toolbarConfig.tools) {\r\n      const arrSelect = toolbarConfig.tools.filter((item) => {\r\n        return item.type === 'select-box';\r\n      });\r\n      if (arrSelect) {\r\n        arrSelect[0].options[0].selected = true;\r\n        const list = document.getElementsByClassName(`select-box-selection`)[0];\r\n        list.getElementsByClassName(`select-box-option-content`)[0].innerHTML = FlowChartConst.SELECT_TEMPLATE;\r\n      }\r\n    }\r\n  }\r\n\r\n\r\n  isShowConfirmMessage() {\r\n    const myGraph = window[FlowChartConst.GRAPH];\r\n    const json = myGraph.toJSON();\r\n    if (json.cells.length === 0) {\r\n      window[FlowChartConst.IS_NOT_SHOW_AGAIN] = true;\r\n      return false;\r\n    }\r\n    if (!window[FlowChartConst.IS_NOT_SHOW_AGAIN]) {\r\n      return true;\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n  setTransitionPoint(jsonContent: object, paperScroller: any) {\r\n    if (jsonContent) {\r\n      const cells = jsonContent[`cells`];\r\n      if (cells) {\r\n        let x = 0;\r\n        let y = 0;\r\n        cells.forEach((e) => {\r\n          if (e.position && e.position) {\r\n            if (x === 0 && y === 0) {\r\n              x = e.position.x;\r\n              y = e.position.y;\r\n            }\r\n            if (e.position.x < x) {\r\n              x = e.position.x;\r\n            }\r\n            if (e.position.y < y) {\r\n              y = e.position.y;\r\n            }\r\n          }\r\n        });\r\n\r\n        if (x !== 0 && y !== 0) {\r\n          x = x > 20 ? x - 20 : x;\r\n          y = y > 20 ? y - 20 : y;\r\n          paperScroller.transitionToPoint(x, y);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  openShapeFunctionality(LANG: any) {\r\n    const myCellView = window[`my_cellView`];\r\n    const inputs = InspectorFunction.getInspectorConfiguration(bpmn2, LANG);\r\n    const cell = myCellView.model;\r\n    const type = cell.get('type');\r\n    const inspector = joint.ui.Inspector.create('#inspector-container', {\r\n      cell,\r\n      inputs: inputs[type],\r\n      groups: {\r\n        general: { label: type, index: 1 },\r\n        defaults: { index: 2 },\r\n        fontsize: { index: 3 },\r\n        appearance: { index: 4 }\r\n      }\r\n    });\r\n  }\r\n\r\n  setZoomToFit(editMode: number) {\r\n    if (editMode === FlowchartViewMode.View) {\r\n      const paperScroller = window[FlowChartConst.PAPER_SCROLLER];\r\n      paperScroller.zoomToFit({ padding: 20, scaleGrid: 0.2, minScale: 0.2, maxScale: 5 });\r\n    }\r\n  }\r\n\r\n  setPaperCenter(editMode: number) {\r\n    if (editMode === FlowchartViewMode.View) {\r\n      const paperScroller = window[FlowChartConst.PAPER_SCROLLER];\r\n      paperScroller.contentToCenter({ padding: 20, scaleGrid: 0.2, minScale: 0.2, maxScale: 5 });\r\n    }\r\n  }\r\n\r\n  setPaperTopLeft(editMode: number) {\r\n    if (editMode === FlowchartViewMode.View) {\r\n      const paperScroller = window[FlowChartConst.PAPER_SCROLLER];\r\n      paperScroller.contentToTopLeft({ padding: 50, scaleGrid: 0.2, minScale: 0.2, maxScale: 5 });\r\n    }\r\n  }\r\n\r\n  setScrollToContent() {\r\n    const graph = window[`graph`];\r\n    const paperScroller = window[FlowChartConst.PAPER_SCROLLER];\r\n    if (graph && paperScroller) {\r\n      const jsonContentObj = graph.toJSON();\r\n      if (jsonContentObj && jsonContentObj.cells.length > 0) {\r\n        paperScroller.scrollToContent();\r\n      } else {\r\n        paperScroller.center();\r\n      }\r\n    }\r\n  }\r\n\r\n  onChangeTextInside(cell: any) {\r\n    if (cell.get('type') === 'bpmn2.Event') {\r\n      if (cell.attributes.attrs.text.style['text-inside']) {\r\n        cell.attributes.attrs.label.textVerticalAnchor = 'middle';\r\n        cell.attributes.attrs.icon.refWidth = '20%';\r\n        cell.attributes.attrs.icon.refHeight = '20%';\r\n      } else {\r\n        cell.attributes.attrs.label.textVerticalAnchor = 'top';\r\n        cell.attributes.attrs.icon.refWidth = '70%';\r\n        cell.attributes.attrs.icon.refHeight = '70%';\r\n      }\r\n    } else if (\r\n      cell.get('type') === 'bpmn2.Gateway' ||\r\n      cell.get('type') === 'bpmn2.Conversation' ||\r\n      cell.get('type') === 'bpmn2.DataObject' ||\r\n      cell.get('type') === 'bpmn2.DataStore'\r\n    ) {\r\n      if (cell.attributes.attrs.text.style['text-inside']) {\r\n        cell.attributes.attrs.label.textVerticalAnchor = 'middle';\r\n      } else {\r\n        cell.attributes.attrs.label.textVerticalAnchor = 'top';\r\n      }\r\n    }\r\n  }\r\n\r\n  onChangeLinkLabel(cell: any, defSize: number) {\r\n    if (cell.isLink()) {\r\n      let size = defSize;\r\n      let refPos = 0;\r\n      const linkId = cell.id;\r\n      // eslint-disable-next-line func-names\r\n      graph.getLinks().every(function (e) {\r\n        if (linkId === e.id) {\r\n          return false;\r\n        }\r\n        refPos += 1;\r\n        return true;\r\n      });\r\n      if (\r\n        graph.getLinks()[refPos].attributes.attrs.text &&\r\n        graph.getLinks()[refPos].attributes.attrs.text['font-size']\r\n      ) {\r\n        size = graph.getLinks()[refPos].attributes.attrs.text['font-size'];\r\n      }\r\n      graph.getLinks()[refPos].prop('labels/0/attrs/label/fontSize', size);\r\n    }\r\n  }\r\n\r\n  onChangeAlligment(cell: any, opt: any) {\r\n    if (cell.get('type') !== 'bpmn2.HeaderedPool') {\r\n      return;\r\n    }\r\n\r\n    if (\r\n      opt.direction &&\r\n      (opt.direction === 'top-right' ||\r\n        opt.direction === 'top-right' ||\r\n        opt.direction === 'bottom-right' ||\r\n        opt.direction === 'bottom-left')\r\n    ) {\r\n      const height = cell.attributes.size.height;\r\n      const headerLabelAnchor = cell.attributes.attrs.headerLabel['text-anchor'];\r\n      this.setHeaderAttribute(cell, headerLabelAnchor, height);\r\n\r\n      // update last lane value\r\n      if (!this.isUndefinedSize(cell.attributes)) {\r\n        const h = cell.attributes.size.height;\r\n        const t = this.getTotalLaneHeight(cell.attributes);\r\n        const b = h - t;\r\n        if (b > 0) {\r\n          const s = cell.attributes.lanes.slice(-1)[0].size + b;\r\n          const index = cell.attributes.lanes.length - 1;\r\n          cell.attributes.lanes[index].size = s;\r\n\r\n          const lane = `lanes_${index}`;\r\n          cell.metrics.lanes[lane].size = s;\r\n          cell.metrics.lanes[lane].takenUpSpaceByLaneAndSublanes = s;\r\n        } else {\r\n          const s = cell.attributes.lanes.slice(-1)[0].size + b;\r\n          const index = cell.attributes.lanes.length - 1;\r\n          cell.attributes.lanes[index].size = s;\r\n\r\n          const lane = `lanes_${index}`;\r\n          cell.metrics.lanes[lane].size = s;\r\n          cell.metrics.lanes[lane].takenUpSpaceByLaneAndSublanes = s;\r\n        }\r\n      }\r\n    } else if (opt.propertyPath && opt.propertyPath === 'attrs/headerLabel/text-anchor') {\r\n      const height = cell.attributes.size.height;\r\n      const textAnchor = opt.propertyValue;\r\n      this.setHeaderAttribute(cell, textAnchor, height);\r\n    }\r\n  }\r\n\r\n  setHeaderAttribute(cell: any, textAnchor: string, height: number) {\r\n    switch (textAnchor) {\r\n      case 'end':\r\n        cell.attributes.attrs.headerLabel.refY = 8;\r\n        break;\r\n      case 'middle':\r\n        cell.attributes.attrs.headerLabel.refY = height / 2;\r\n        break;\r\n      case 'start':\r\n        cell.attributes.attrs.headerLabel.refY = height - 8;\r\n        break;\r\n      default:\r\n        cell.attributes.attrs.headerLabel.refY = height / 2;\r\n        break;\r\n    }\r\n  }\r\n\r\n  isUndefinedSize(attributes) {\r\n    let bResult = false;\r\n    if (attributes && attributes.lanes.length > 0) {\r\n      attributes.lanes.every((e) => {\r\n        if (!e.size) {\r\n          bResult = true;\r\n          return false;\r\n        }\r\n        return true;\r\n      });\r\n    }\r\n    return bResult;\r\n  }\r\n\r\n  getTotalLaneHeight(attributes) {\r\n    let total = 0;\r\n    if (attributes && attributes.lanes.length > 0) {\r\n      attributes.lanes.forEach((e) => {\r\n        if (e.size) {\r\n          total += e.size;\r\n        }\r\n      });\r\n    }\r\n    return total;\r\n  }\r\n}\r\n"]}