@esfaenza/es-diagrams 11.0.2

package/bundles/esfaenza-es-diagrams.umd.js

@@ -0,0 +1,1748 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('cytoscape'), require('@angular/forms'), require('@angular/common')) :
+    typeof define === 'function' && define.amd ? define('@esfaenza/es-diagrams', ['exports', '@angular/core', 'cytoscape', '@angular/forms', '@angular/common'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.esfaenza = global.esfaenza || {}, global.esfaenza['es-diagrams'] = {}), global.ng.core, global.cy_, global.ng.forms, global.ng.common));
+}(this, (function (exports, i0, cy_, forms, common) { 'use strict';
+
+    function _interopNamespace(e) {
+        if (e && e.__esModule) return e;
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () {
+                            return e[k];
+                        }
+                    });
+                }
+            });
+        }
+        n['default'] = e;
+        return Object.freeze(n);
+    }
+
+    var i0__namespace = /*#__PURE__*/_interopNamespace(i0);
+    var cy___namespace = /*#__PURE__*/_interopNamespace(cy_);
+
+    /**
+     * Definizione di un comando del Context menù
+     */
+    var ContextMenuCommand = /** @class */ (function () {
+        function ContextMenuCommand() {
+        }
+        return ContextMenuCommand;
+    }());
+
+    /**
+     * Opzioni che gestiscono il context menu. Quando una di queste opzioni non viene assegnata viene mantenuto il default, assicurarsi quindi di modificare solo
+     * le proprietà che si vogliono effettivamente cambiare rispetto ai default
+     */
+    var ContextMenuOptions = /** @class */ (function () {
+        function ContextMenuOptions() {
+        }
+        return ContextMenuOptions;
+    }());
+
+    /**
+     *  Opzioni native per l'estensione expand-collapse di cytoscape
+     */
+    var ExpandCollapseOptions = /** @class */ (function () {
+        function ExpandCollapseOptions() {
+        }
+        return ExpandCollapseOptions;
+    }());
+
+    /**
+     * Classe che indica per una data query quali template applicare
+     */
+    var NodeHTMLTemplate = /** @class */ (function () {
+        function NodeHTMLTemplate() {
+        }
+        return NodeHTMLTemplate;
+    }());
+
+    /**
+     * Classe che rappresenta un template HTML applicabile ad un nodo
+     */
+    var NodeTemplate = /** @class */ (function () {
+        function NodeTemplate() {
+        }
+        return NodeTemplate;
+    }());
+
+    /**
+     * Classe che rappresenta il template HTML di un nodo da utilizzare per un certo livello di zoom
+     */
+    var ZoomLevelBasedTemplate = /** @class */ (function () {
+        function ZoomLevelBasedTemplate() {
+        }
+        return ZoomLevelBasedTemplate;
+    }());
+
+    /**
+     * Opzioni di layout di base che si collegano al **ready** e allo **stop** eventualmente per aggiungere del log addizionale
+     */
+    var BaseLayoutOptionsImpl = /** @class */ (function () {
+        function BaseLayoutOptionsImpl() {
+        }
+        /**
+         * Per ora ignoro lato documentale dato che sono placholder
+         * @ignore
+         */
+        BaseLayoutOptionsImpl.prototype.ready = function (e) {
+        };
+        /**
+         * Per ora ignoro lato documentale dato che sono placholder
+         * @ignore
+         */
+        BaseLayoutOptionsImpl.prototype.stop = function (e) {
+        };
+        return BaseLayoutOptionsImpl;
+    }());
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b)
+                if (Object.prototype.hasOwnProperty.call(b, p))
+                    d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+    var __assign = function () {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s)
+                    if (Object.prototype.hasOwnProperty.call(s, p))
+                        t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+                t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+            r = Reflect.decorate(decorators, target, key, desc);
+        else
+            for (var i = decorators.length - 1; i >= 0; i--)
+                if (d = decorators[i])
+                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); };
+    }
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+            return Reflect.metadata(metadataKey, metadataValue);
+    }
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try {
+                step(generator.next(value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function rejected(value) { try {
+                step(generator["throw"](value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function () { if (t[0] & 1)
+                throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f)
+                throw new TypeError("Generator is already executing.");
+            while (_)
+                try {
+                    if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                        return t;
+                    if (y = 0, t)
+                        op = [op[0] & 2, t.value];
+                    switch (op[0]) {
+                        case 0:
+                        case 1:
+                            t = op;
+                            break;
+                        case 4:
+                            _.label++;
+                            return { value: op[1], done: false };
+                        case 5:
+                            _.label++;
+                            y = op[1];
+                            op = [0];
+                            continue;
+                        case 7:
+                            op = _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                        default:
+                            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                                _ = 0;
+                                continue;
+                            }
+                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+                                _.label = op[1];
+                                break;
+                            }
+                            if (op[0] === 6 && _.label < t[1]) {
+                                _.label = t[1];
+                                t = op;
+                                break;
+                            }
+                            if (t && _.label < t[2]) {
+                                _.label = t[2];
+                                _.ops.push(op);
+                                break;
+                            }
+                            if (t[2])
+                                _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                    }
+                    op = body.call(thisArg, _);
+                }
+                catch (e) {
+                    op = [6, e];
+                    y = 0;
+                }
+                finally {
+                    f = t = 0;
+                }
+            if (op[0] & 5)
+                throw op[1];
+            return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+    var __createBinding = Object.create ? (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
+    }) : (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        o[k2] = m[k];
+    });
+    function __exportStar(m, o) {
+        for (var p in m)
+            if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
+                __createBinding(o, m, p);
+    }
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m)
+            return m.call(o);
+        if (o && typeof o.length === "number")
+            return {
+                next: function () {
+                    if (o && i >= o.length)
+                        o = void 0;
+                    return { value: o && o[i++], done: !o };
+                }
+            };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m)
+            return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+                ar.push(r.value);
+        }
+        catch (error) {
+            e = { error: error };
+        }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"]))
+                    m.call(i);
+            }
+            finally {
+                if (e)
+                    throw e.error;
+            }
+        }
+        return ar;
+    }
+    /** @deprecated */
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+    /** @deprecated */
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++)
+            s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    }
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2)
+            for (var i = 0, l = from.length, ar; i < l; i++) {
+                if (ar || !(i in from)) {
+                    if (!ar)
+                        ar = Array.prototype.slice.call(from, 0, i);
+                    ar[i] = from[i];
+                }
+            }
+        return to.concat(ar || Array.prototype.slice.call(from));
+    }
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n])
+            i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try {
+            step(g[n](v));
+        }
+        catch (e) {
+            settle(q[0][3], e);
+        } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length)
+            resume(q[0][0], q[0][1]); }
+    }
+    function __asyncDelegator(o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    }
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator)
+            throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
+    }
+    function __makeTemplateObject(cooked, raw) {
+        if (Object.defineProperty) {
+            Object.defineProperty(cooked, "raw", { value: raw });
+        }
+        else {
+            cooked.raw = raw;
+        }
+        return cooked;
+    }
+    ;
+    var __setModuleDefault = Object.create ? (function (o, v) {
+        Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function (o, v) {
+        o["default"] = v;
+    };
+    function __importStar(mod) {
+        if (mod && mod.__esModule)
+            return mod;
+        var result = {};
+        if (mod != null)
+            for (var k in mod)
+                if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+                    __createBinding(result, mod, k);
+        __setModuleDefault(result, mod);
+        return result;
+    }
+    function __importDefault(mod) {
+        return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+    function __classPrivateFieldGet(receiver, state, kind, f) {
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a getter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot read private member from an object whose class did not declare it");
+        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+    }
+    function __classPrivateFieldSet(receiver, state, value, kind, f) {
+        if (kind === "m")
+            throw new TypeError("Private method is not writable");
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a setter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot write private member to an object whose class did not declare it");
+        return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+    }
+
+    /**
+     * Classe base con le opzioni di layout valide per tutti i layout animati
+     */
+    var AnimateLayoutOptionsImpl = /** @class */ (function (_super) {
+        __extends(AnimateLayoutOptionsImpl, _super);
+        /** @ignore */
+        function AnimateLayoutOptionsImpl() {
+            var _this = _super.call(this) || this;
+            /**
+             * Livello di zoom da impostare (si consiglia fit = **false** se viene impostato)
+             */
+            _this.zoom = null;
+            /**
+             * Livello di pan da impostare (si consiglia fit = **false** se viene impostato)
+             */
+            _this.pan = null;
+            /**
+             * Indica se animare il cambio di posizione dei nodi
+             */
+            _this.animate = false;
+            /**
+             * Con **animate** a true indica la durata dell'animazione
+             */
+            _this.animationDuration = 500;
+            /**
+             * Abilita o no l'easing dell'animazione, può essere una stringa come ad esempio "ease-in-out-cubic" o altre funzioni scritte allo stesso modo prese da https://easings.net/
+             */
+            _this.animationEasing = undefined;
+            /**
+             * Funzione che indica se un nodo dev'essere animato o no.
+             * Tutti i nodi sono animati di default.
+             * Tutti i nodi che non vengono animati verranno posizionati appena inizia l'animazione
+             *
+             * @param {any} node Nodo per cui decidere se abilitare l'animazione o no
+             * @param {number} i Indice del nodo corrente
+             *
+             * @returns {boolean} **true** se il nodo dev'essere animato, **false** altrimenti
+             */
+            _this.animateFilter = function (node, i) { return true; };
+            return _this;
+        }
+        return AnimateLayoutOptionsImpl;
+    }(BaseLayoutOptionsImpl));
+
+    /**
+     * Classe base per gli algoritmi "Shaped"
+     */
+    var ShapedLayoutOptionsImpl = /** @class */ (function (_super) {
+        __extends(ShapedLayoutOptionsImpl, _super);
+        /** @ignore */
+        function ShapedLayoutOptionsImpl() {
+            var _this = _super.call(this) || this;
+            /**
+             * Indica se adattare al contenitore
+             */
+            _this.fit = true;
+            /**
+             * Padding rispetto al contenitore
+             */
+            _this.padding = 30;
+            /**
+             * Specifica le dimensioni esatte al cui interno effettuare il layouting, specificato come **{ x1, y1, x2, y2 }** o **{ x1, y1, w, h }**
+             */
+            _this.boundingBox = null;
+            /**
+             * Fa in modo che i nodi non si accavallino, ma se il contenitore non ha abbastanza spazio potrebbero andare in overflow
+             */
+            _this.avoidOverlap = true;
+            /**
+             * Include o esclude le dimensioni delle label dei nodi nel calcolo delle posizioni
+             */
+            _this.nodeDimensionsIncludeLabels = false;
+            /**
+             * Moltiplicatore delle dimensioni per espandere/restringere le dimensioni globali del diagramma
+             */
+            _this.spacingFactor = 1;
+            /**
+             * Funzione di ordinamento per ordinare i nodi
+             */
+            _this.sort = null;
+            /**
+             * Funzione per la trasformazione delle posizioni dei nodi
+             *
+             * @param {any} node Nodo
+             * @param {any} position Posizione iniziale
+             *
+             * @returns {any} Posizione finale
+             */
+            _this.transform = function (node, position) { return position; };
+            return _this;
+        }
+        return ShapedLayoutOptionsImpl;
+    }(AnimateLayoutOptionsImpl));
+
+    /**
+     * Default per l'implementazione dell'algoritmo Breadth First
+     */
+    var BreadthFirstLayoutOptionsImpl = /** @class */ (function (_super) {
+        __extends(BreadthFirstLayoutOptionsImpl, _super);
+        /** @ignore */
+        function BreadthFirstLayoutOptionsImpl() {
+            var _this = _super.call(this) || this;
+            /**
+             * Nome dell'algoritmo di layouting
+             */
+            _this.name = 'breadthfirst';
+            /**
+             * Indica se l'albero è diretto in basso. Se false i collegamenti fra i nodi possono andare in qualsiasi direzione
+             */
+            _this.directed = false;
+            /**
+             * Se **true** i livelli vengono ordinati in cerchi concentrici, se **false** vengono oridnati dall'alto al basso
+             */
+            _this.circle = false;
+            /**
+             * Indica che i nodi verranno shiftati in base al proprio livello in modo da evitare collegamenti inversi (solo per i DAG)
+             */
+            _this.maximal = false;
+            /**
+             * Indica se creare una griglia in cui ordinare i nodi del DAG (Solo quando la proprietà **circle** è a **false**)
+             */
+            _this.grid = false;
+            /**
+             * Indica se escludere le label dei nodi quando vengono calcolati i limiti del layout
+             */
+            _this.nodeDimensionsIncludeLabels = false;
+            return _this;
+        }
+        return BreadthFirstLayoutOptionsImpl;
+    }(ShapedLayoutOptionsImpl));
+
+    /**
+     * Default per l'implementazione dell'algoritmo Circle
+     */
+    var CircleLayoutOptionsImpl = /** @class */ (function (_super) {
+        __extends(CircleLayoutOptionsImpl, _super);
+        /** @ignore */
+        function CircleLayoutOptionsImpl() {
+            var _this = _super.call(this) || this;
+            /**
+             * Nome dell'algoritmo di layouting
+             */
+            _this.name = 'circle';
+            /**
+             * Angolo da cui i nodi partono, in radianti (Default: **3 / 2 * Math.PI**)
+             */
+            _this.startAngle = 3 / 2 * Math.PI;
+            /**
+             * Numero di radianti fra il primo e l'ultimo nodo. Di default viene utilizzata l'intera circonferenza
+             */
+            _this.sweep = null;
+            /**
+             * Indica se andare in senso orario (**true**) o antiorario (**false**)
+             */
+            _this.clockwise = true; // whether the layout should go clockwise (true) or counterclockwise/anticlockwise (false)
+            return _this;
+        }
+        return CircleLayoutOptionsImpl;
+    }(ShapedLayoutOptionsImpl));
+
+    /**
+     * Default per l'implementazione dell'algoritmo Concentric
+     */
+    var ConcentricLayoutOptionsImpl = /** @class */ (function () {
+        function ConcentricLayoutOptionsImpl() {
+            /**
+             * Nome dell'algoritmo di layouting
+             */
+            this.name = 'concentric';
+            /**
+             * Angolo da cui i nodi partono, in radianti (Default: **3 / 2 * Math.PI**)
+             */
+            this.startAngle = 3 / 2 * Math.PI;
+            /**
+             * Include o esclude le dimensioni delle label dei nodi nel calcolo delle posizioni
+             */
+            this.nodeDimensionsIncludeLabels = true;
+            /**
+             * Indica se i livelli devono essere o non essere equidistanti, potrebbe causare overflow dal contenitore
+             */
+            this.equidistant = false;
+            /**
+             * Distanza minima dall'esterno dei nodi, utilizzato per aggiustare il raggio
+             */
+            this.minNodeSpacingnumber = 10;
+            /**
+             * Specifica le dimensioni esatte al cui interno effettuare il layouting, specificato come **{ x1, y1, x2, y2 }** o **{ x1, y1, w, h }**
+             */
+            this.boundingBox = null;
+            /**
+             * Altezza dell'area di layout (sovrascrive quella del contenitore)
+             */
+            this.height = null;
+            /**
+             * Larghezza dell'area di layout (sovrascrive quella del contenitore)
+             */
+            this.width = null;
+            /**
+             * Moltiplicatore delle dimensioni per espandere/restringere le dimensioni globali del diagramma
+             */
+            this.spacingFactor = 1;
+        }
+        /**
+         * Funzione di cui si può fare override per assegnare un valore ad ogni nodo. I nodi con valore più alto saranno piazzati verso il centro
+         *
+         * @param {any} node Nodo
+         *
+         * @returns {number} Valore su cui ordinare i nodi verso il centro
+         */
+        ConcentricLayoutOptionsImpl.prototype.concentric = function (node) {
+            return node.degree();
+        };
+        /**
+         * Funzione di cui si può fare override per calcolare la variazione dei valori concentrici per ogni livello
+         *
+         * @param {any} nodes Gruppo di nodi del livello
+         *
+         * @returns {number} Variazione dei valori concentrici
+         */
+        ConcentricLayoutOptionsImpl.prototype.levelWidth = function (nodes) {
+            return nodes.maxDegree() / 4;
+        };
+        return ConcentricLayoutOptionsImpl;
+    }());
+
+    /**
+     * Default per l'implementazione dell'algoritmo Cose
+     */
+    var CoseLayoutOptionsImpl = /** @class */ (function (_super) {
+        __extends(CoseLayoutOptionsImpl, _super);
+        /** @ignore */
+        function CoseLayoutOptionsImpl() {
+            var _this = _super.call(this) || this;
+            /**
+             * Nome dell'algoritmo di layouting
+             */
+            _this.name = 'cose';
+            /**
+             * Se **animate** è **true**, l'animazione parte solo dopo questo numero di millisecondi (Evita flickering su animazioni veloci)
+             */
+            _this.animationThreshold = 250;
+            /**
+             * Numero di iterazioni fra aggiornamenti consecutivi della posizione a schermo
+             */
+            _this.refresh = 20;
+            /**
+             * Se **true** la posizione iniziale dei nodi è casuale, se **false** utilizza la posizione originale
+             */
+            _this.randomize = false;
+            /**
+             * Spazio extra fra i componenti di un grafo non-compound
+             */
+            _this.componentSpacing = 40;
+            /**
+             * Moltiplicatore della repulsione fra nodi in caso di overlap
+             */
+            _this.nodeOverlap = 4;
+            /**
+             * Moltiplicatore di nesting per il calcolo della lunghezza ideale dei collegamenti nested
+             */
+            _this.nestingFactor = 1.2;
+            /**
+             * Costante di gravità
+             */
+            _this.gravity = 1;
+            /**
+             * Numero massimo di iterazioni da eseguire
+             */
+            _this.numIter = 1000;
+            /**
+             * Temperatura iniziale (massima distanza fra i nodi)
+             */
+            _this.initialTemp = 1000;
+            /**
+             * Fattore di raffreddamento. Ad ogni iterazione verrà sottratto ad **initialTemp**
+             */
+            _this.coolingFactor = 0.99;
+            /**
+             * Soglia minima di temperatura. Una volta raggiunta il layout si considera terminato
+             */
+            _this.minTemp = 1.0;
+            /**
+             * Moltiplicatore della repulsione fra nodi in caso di assenza di overlap. Funzione overrideabile per ogni node
+             *
+             * @param {any} node Nodo
+             *
+             * @returns {number} Moltiplicazione di repulsione
+             */
+            _this.nodeRepulsion = function (node) { return 2048; };
+            /**
+             * Lunghezza ideale dei collegamenti non nested. Funzione overrideabile per ogni collegamento
+             *
+             * @param {any} edge Collegamento
+             *
+             * @returns {number} Lunghezza ideale
+             */
+            _this.idealEdgeLength = function (edge) { return 32; };
+            /**
+             * Divisore per calcolare le forze applicate ad un collegamento. Funzione overrideabile per ogni collegamento
+             *
+             * @param {any} edge Collegamento
+             *
+             * @returns {number} Indice di elasticità
+             */
+            _this.edgeElasticity = function (edge) { return 32; };
+            return _this;
+        }
+        return CoseLayoutOptionsImpl;
+    }(ShapedLayoutOptionsImpl));
+
+    /**
+     * Default per l'implementazione dell'algoritmo Dagre
+     */
+    var DagreLayoutOptionsImpl = /** @class */ (function (_super) {
+        __extends(DagreLayoutOptionsImpl, _super);
+        /** @ignore */
+        function DagreLayoutOptionsImpl() {
+            var _this = _super.call(this) || this;
+            /**
+             * Nome dell'algoritmo di layouting
+             */
+            _this.name = 'dagre';
+            /**
+             * Distanza fra nodi adiacenti dello stesso rango
+             */
+            _this.nodeSep = null;
+            /**
+             * Distanza fra collegamenti adiacenti nello stesso rango
+             */
+            _this.edgeSep = null;
+            /**
+             * Distanza fra ogni rango
+             */
+            _this.rankSep = null;
+            // TB for top to bottom flow, 'LR' for left to right
+            /**
+             * Direzione di disegno: LR = Sinistra a Destra, TB = Sopra a Sotto
+             */
+            _this.rankDir = 'TB';
+            /**
+             * Algoritmo che si occupa di assegnare un rango ad ogni nodo
+             */
+            _this.ranker = null;
+            /**
+             * Numero di ranghi fra la sorgente e la destinazione di un collegamento
+             *
+             * @param {any} edge Collegamento di cui calcolare la differenza di rango
+             *
+             * @returns {number} Differenza di rango
+             */
+            _this.minLen = function (edge) { return 1; };
+            /**
+             * Peso del collegamento, più è alto più generalmente risulterà corto
+             *
+             * @param {any} edge Collegamento di cui calcolare il peso
+             *
+             * @returns {number} Peso
+             */
+            _this.edgeWeight = function (edge) { return 1; };
+            return _this;
+        }
+        return DagreLayoutOptionsImpl;
+    }(ShapedLayoutOptionsImpl));
+
+    /**
+     * Default per l'implementazione dell'algoritmo Grid
+     */
+    var GridLayoutOptionsImpl = /** @class */ (function (_super) {
+        __extends(GridLayoutOptionsImpl, _super);
+        /** @ignore */
+        function GridLayoutOptionsImpl() {
+            var _this = _super.call(this) || this;
+            /**
+             * Nome dell'algoritmo di layouting
+             */
+            _this.name = 'grid';
+            /**
+             * Spazio extra attorno ai nodi quando **avoidOverlap** è **true**
+             */
+            _this.avoidOverlapPadding = 10;
+            /**
+             * Se **true** cerca di utilizzare il minor spazio possibile, se **false** usa tutto lo spazio che ha a disposizione
+             */
+            _this.condense = false;
+            /**
+             * Forzatura del numero di righe della griglia
+             */
+            _this.rows = null;
+            /**
+             * Forzatura del numero di colonne della griglia
+             */
+            _this.cols = null;
+            /**
+             * Dato un nodo restituisce un indice di riga e di colonna della griglia in cui metterlo
+             *
+             * @param {NodeSingular} node Nodo
+             * @returns {{ row: number, col: number }} Oggetto che identifica una posizione della griglia
+             */
+            _this.position = null;
+            return _this;
+        }
+        return GridLayoutOptionsImpl;
+    }(ShapedLayoutOptionsImpl));
+
+    /**
+     * Pseudo implementazione di un algoritmo vuoto che non fa nulla
+     */
+    var NullLayoutOptionsImpl = /** @class */ (function (_super) {
+        __extends(NullLayoutOptionsImpl, _super);
+        /** @ignore */
+        function NullLayoutOptionsImpl() {
+            var _this = _super.call(this) || this;
+            /**
+             * Nome dell'algoritmo di layouting
+             */
+            _this.name = 'null';
+            return _this;
+        }
+        return NullLayoutOptionsImpl;
+    }(BaseLayoutOptionsImpl));
+
+    /**
+     * Default per l'implementazione dell'algoritmo Preset (Posiziona i nodi in base alla loro proprietà **position**)
+     */
+    var PresetLayoutOptionsImpl = /** @class */ (function (_super) {
+        __extends(PresetLayoutOptionsImpl, _super);
+        /** @ignore */
+        function PresetLayoutOptionsImpl() {
+            var _this = _super.call(this) || this;
+            /**
+             * Nome dell'algoritmo di layouting
+             */
+            _this.name = 'preset';
+            /**
+             * Funzione per la trasformazione delle posizioni dei nodi
+             *
+             * @param {any} node Nodo
+             * @param {any} position Posizione iniziale
+             *
+             * @returns {any} Posizione finale
+             */
+            _this.transform = function (node, position) { return position; };
+            return _this;
+        }
+        return PresetLayoutOptionsImpl;
+    }(AnimateLayoutOptionsImpl));
+
+    /**
+     * Default per l'implementazione dell'algoritmo Random
+     */
+    var RandomLayoutOptionsImpl = /** @class */ (function (_super) {
+        __extends(RandomLayoutOptionsImpl, _super);
+        /** @ignore */
+        function RandomLayoutOptionsImpl() {
+            var _this = _super.call(this) || this;
+            /**
+             * Nome dell'algoritmo di layouting
+             */
+            _this.name = 'random';
+            /**
+             * Indica se adattare al contenitore
+             */
+            _this.fit = true;
+            /**
+             * Padding rispetto al contenitore
+             */
+            _this.padding = 20;
+            /**
+             * Specifica le dimensioni esatte al cui interno effettuare il layouting, specificato come **{ x1, y1, x2, y2 }** o **{ x1, y1, w, h }**
+             */
+            _this.boundingBox = null;
+            /**
+             * Funzione per la trasformazione delle posizioni dei nodi
+             *
+             * @param {any} node Nodo
+             * @param {any} position Posizione iniziale
+             *
+             * @returns {any} Posizione finale
+             */
+            _this.transform = function (node, position) { return position; };
+            return _this;
+        }
+        return RandomLayoutOptionsImpl;
+    }(AnimateLayoutOptionsImpl));
+
+    /**
+     * Classe di configurazione per il Modulo
+     */
+    var EsDiagramModuleConfig = /** @class */ (function () {
+        function EsDiagramModuleConfig() {
+        }
+        return EsDiagramModuleConfig;
+    }());
+
+    /**
+     * Token che indica la lingua da utilizzare, sono supportate "it-IT" ed "en-US"
+     */
+    var DIA_LOCALE = new i0.InjectionToken('DIA_LOCALE');
+    /**
+     * Token che indica se attivare la modalità di debug (messaggi a console)
+     */
+    var DIA_DEBUG_MODE = new i0.InjectionToken('DIA_DEBUG_MODE');
+
+    /**
+     * Oggetto statico di localizzazione per i messaggi
+     */
+    var Loc = {
+        "Module": { "en-US": "Module", "it-IT": "Il Modulo" },
+        "Received an undefined module. Make sure you are correctly loading it": { "en-US": "Received an undefined module. Make sure you are correctly loading it", "it-IT": "Ricevuto modulo non definito. Assicurati di caricarlo correttamente" },
+        "Module not available. Loading it now": { "en-US": "Module not available. Loading it now", "it-IT": "Modulo non disponibile. Lo carico ora" },
+        "Module already loaded": { "en-US": "Module already loaded", "it-IT": "Modulo già caricato" },
+        "Diagram container size has changed, redrawing": { "en-US": "Diagram container size has changed, redrawing", "it-IT": "La dimensione del contenitore del diagramma è cambiata, ridisegno" },
+        "Module cannot be loaded": { "en-US": "Module cannot be loaded", "it-IT": "Impossibile caricare il modulo" },
+        "Redraw based on dynamic Input change is supported only for 'Elements' and 'Layout' inputs, please destroy the component and recreate it with the new settings": { "en-US": "Redraw based on dynamic Input change is supported only for 'Elements' and 'Layout' inputs, please destroy the component and recreate it with the new settings", "it-IT": "Il cambio e aggiornamento dinamico degli Input è supportato solo per gli Input 'Elements' e 'Layout', distruggi il componente e ricrealo con le nuove impostazioni", },
+        "is loaded and managed directly by this library. You don't need to import it or use it directly, just be sure to set the relative options": { "en-US": "is loaded and managed directly by this library. You don't need to import it or use it directly, just be sure to set the relative options", "it-IT": "viene caricato e gestito nativamente dalla libreria. Non c'è bisogno di reimportarlo, né di configurarlo (usare le opzioni specifiche)" },
+        "If you don't specify a source and a target for an edge you have to write its id in the format {source}-{target}": { "en-US": "If you don't specify a source and a target for an edge you have to write its id in the format {source}-{target}", "it-IT": "Se non è specificata una sorgente e una destinazione per il collegamento è opportuno scriverne l'id nel formato {sorgente}-{destinazione}" },
+        "Elements have been changed after diagram initialization": { "en-US": "Elements have been changed after diagram initialization", "it-IT": "Rilevato un cambio di Elementi dopo l'inizializzazione del Diagramma" },
+        "Layout have been changed after diagram initialization": { "en-US": "Layout have been changed after diagram initialization", "it-IT": "Rilevato un cambio di Layout dopo l'inizializzazione del Diagramma" }
+    };
+
+    /** @ignore */ var cytoscape$1 = cy___namespace;
+    /**
+     * Loader dei moduli di Cytoscape. Utilizza una cache per tenerseli in memoria a livello di applicazione
+     * in modo da non dover ricaricare nulla dopo avere usato un modulo almeno una volta
+     */
+    var EsDiagramService = /** @class */ (function () {
+        /**
+         * Costruttore
+         *
+         * @ignore
+         */
+        function EsDiagramService(DIA_LOCALE, DIA_DEBUG_MODE) {
+            this.DIA_LOCALE = DIA_LOCALE;
+            this.DIA_DEBUG_MODE = DIA_DEBUG_MODE;
+            /**
+             * Cache dei moduli caricati
+             */
+            this.modulesCache = {};
+        }
+        /**
+         * Permette di importare, se serve un dato tema o localizzazione
+         *
+         * @param {'cytoscape-expand-collapse' | 'cytoscape-cxtmenu' | 'cytoscape-html-node' | 'cytoscape-dagre'} moduleId Nome del modulo di Cytoscape da importare (dev'essere il nome della cartella in node_modules)
+         *
+         * @returns {Promise<void | cytoscape.Ext>} Funzione di estensione per Cytoscape presa dal modulo richiesto
+         */
+        EsDiagramService.prototype.importIfNeeded = function (moduleId) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a;
+                var _this = this;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (!!this.modulesCache[moduleId]) return [3 /*break*/, 7];
+                            this.log("I", this.loc("Module not available. Loading it now") + ": " + moduleId, false);
+                            _a = moduleId;
+                            switch (_a) {
+                                case "cytoscape-cxtmenu": return [3 /*break*/, 1];
+                                case "cytoscape-expand-collapse": return [3 /*break*/, 2];
+                                case "cytoscape-html-node": return [3 /*break*/, 3];
+                                case "cytoscape-dagre": return [3 /*break*/, 4];
+                            }
+                            return [3 /*break*/, 6];
+                        case 1: return [2 /*return*/, import('cytoscape-cxtmenu').then(function (module) { return _this.modulesCache[moduleId] = module.default; }).catch(function (err) { return _this.handleError(moduleId, err); })];
+                        case 2: return [2 /*return*/, import('cytoscape-expand-collapse').then(function (module) { return _this.modulesCache[moduleId] = module.default; }).catch(function (err) { return _this.handleError(moduleId, err); })];
+                        case 3: return [2 /*return*/, import('@esfaenza/cytoscape-html-node').then(function (module) { return _this.modulesCache[moduleId] = module.register; }).catch(function (err) { return _this.handleError(moduleId, err); })];
+                        case 4: return [4 /*yield*/, import('dagre').catch(function (err) { return _this.handleError("dagre", err); })];
+                        case 5:
+                            _b.sent();
+                            return [2 /*return*/, import('cytoscape-dagre').then(function (module) { return _this.modulesCache[moduleId] = module.default; }).catch(function (err) { return _this.handleError(moduleId, err); })];
+                        case 6: return [3 /*break*/, 8];
+                        case 7:
+                            // I moduli non devono mai essere ricaricati nel globale, quindi invece che restituire la copia della cache restituisco vuoto
+                            this.log("I", this.loc("Module already loaded") + ": " + moduleId, false);
+                            return [2 /*return*/, new Promise(function (resolve) { resolve(null); })];
+                        case 8: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        /**
+         * Gestione degli errori di caricamento dei moduli qualora qualcuno utilizzasse un modulo non installato
+         *
+         * @param {string} moduleId Nome del modulo che si è cercato di caricare
+         * @param {any} err Errore restituito dalla promise di caricamento
+         */
+        EsDiagramService.prototype.handleError = function (moduleId, err) {
+            this.log("E", this.loc("Module cannot be loaded") + ": " + moduleId + " - " + err, false);
+        };
+        /**
+         * Scrittore di log a console. Attivo solo quando la libreria è in modalità di Debug
+         *
+         * @param {'E' | 'I' | 'W'} severity Tipo di messaggio (Errore, Info, Warning)
+         * @param {string} text Testo da tradurre
+         * @param {boolean} requiresTranslation Indica se **text** è una frase già tradotta o se è da tradurre
+         */
+        EsDiagramService.prototype.log = function (severity, text, requiresTranslation) {
+            if (requiresTranslation === void 0) { requiresTranslation = true; }
+            if (!this.DIA_DEBUG_MODE)
+                return;
+            var message = "@esfaenza/diagrams: " + (requiresTranslation ? this.loc(text) : text);
+            switch (severity) {
+                case 'E':
+                    console.error(message);
+                    break;
+                case 'I':
+                    console.info(message);
+                    break;
+                case 'W':
+                    console.warn(message);
+                    break;
+            }
+        };
+        /**
+         * Metodo di localizzazione dei messaggi
+         *
+         * @param {string} text Messaggio da tradurre
+         *
+         * @returns {string} Messaggio tradotto
+         */
+        EsDiagramService.prototype.loc = function (text) {
+            return Loc[text][this.DIA_LOCALE];
+        };
+        return EsDiagramService;
+    }());
+    EsDiagramService.decorators = [
+        { type: i0.Injectable }
+    ];
+    EsDiagramService.ctorParameters = function () { return [
+        { type: String, decorators: [{ type: i0.Optional }, { type: i0.Inject, args: [DIA_LOCALE,] }] },
+        { type: String, decorators: [{ type: i0.Optional }, { type: i0.Inject, args: [DIA_DEBUG_MODE,] }] }
+    ]; };
+
+    /**
+     * Classe che si occupa del dispatch delle operazioni di rendering degli oggetti utilizzando una coda
+     */
+    var EsDiagramDispatcher = /** @class */ (function () {
+        /**
+         * @ignore
+         */
+        function EsDiagramDispatcher(logs) {
+            this.logs = logs;
+            /**
+             * Coda di inizializzazioni ancora da eseguire. Quando questa è vuota significa che nessuno sta creando oggetti
+             */
+            this.Initializations = [];
+            /**
+             * Lista degli oggetti inizializzati e attivi in un dato momento (viene registrata la proprietà **name**). Non è possibile registrare due grafici con lo stesso identificativo
+             */
+            this.Initialized = [];
+        }
+        /**
+         * Registra un oggetto da visualizzare insieme alla propria funzione di creazione. Quest'ultima sarà differita fino a che tutti gli oggetti
+         * precedentemente registati non hanno finito la fase di inizializzazione
+         *
+         * @param {string} name Identificativo dell'oggetto da registrare
+         * @param {Function} creationFunction Funzione che fisicamente dovrà occuparsi della creazione dell'oggetto
+         */
+        EsDiagramDispatcher.prototype.register = function (name, creationFunction) {
+            if (this.Initialized.indexOf(name) != -1)
+                throw "Attempting to register a duplicate object '" + name + "'. Make sure the 'name' properties of your diagram are univoque";
+            this.log("DISPATCHER: Registering diagram creation function execution for " + name);
+            this.Initializations.push({ name: name, function: creationFunction });
+            if (this.Initializations.length == 1) {
+                this.log("DISPATCHER: Initial drain started");
+                this.drainInitQueues();
+            }
+        };
+        /**
+         * Deregistra un oggetto presente. Chiamata generalmente al dispose dell'oggetto in questione quando non dev'essere più mostrato nella pagina corrente
+         *
+         * @param {string} name Identificativo dell'oggetto da deregistrare
+         */
+        EsDiagramDispatcher.prototype.deregister = function (name) {
+            var index = this.Initialized.indexOf(name);
+            if (index == -1) {
+                //Questo succede quando si cerca di distruggere l'oggetto mentre sta venendo graficato
+                this.log("DISPATCHER: Registration missing for object " + name + " it was probably destroyed during load");
+                return;
+            }
+            this.log("DISPATCHER: Object deregistered " + name);
+            this.Initialized.splice(index, 1);
+        };
+        /**
+         * Metodo che esegue in maniera sequenziale le funzioni di inizializzazione degli oggetti finché presenti
+         * in modo che nessun oggetto possa essere inizializzato contemporaneamente ad un altro
+         */
+        EsDiagramDispatcher.prototype.drainInitQueues = function () {
+            var _this = this;
+            var toExecute = this.Initializations[0];
+            this.log("DISPATCHER: Executing initialization function for object " + toExecute.name);
+            toExecute.function().then(function () {
+                _this.log("DISPATCHER: initialization for object " + toExecute.name + " is done");
+                _this.Initialized.push(toExecute.name);
+                _this.Initializations.splice(0, 1);
+                if (_this.Initializations.length >= 1) {
+                    _this.log("DISPATCHER: Found queued initializations. Continuing");
+                    _this.drainInitQueues();
+                }
+                else
+                    _this.log("DISPATCHER: queue is over, nothing more to do");
+            });
+        };
+        /**
+         * @ignore
+         */
+        EsDiagramDispatcher.prototype.log = function (text) {
+            if (this.logs)
+                console.log("@esfaenza/es-diagrams: " + text);
+        };
+        return EsDiagramDispatcher;
+    }());
+    EsDiagramDispatcher.decorators = [
+        { type: i0.Injectable }
+    ];
+    EsDiagramDispatcher.ctorParameters = function () { return [
+        { type: Boolean, decorators: [{ type: i0.Inject, args: [DIA_DEBUG_MODE,] }] }
+    ]; };
+
+    // Grabbata felicemente da amcharts, rimuovendo helper interni, cose strane e instupidendola un po':
+    // https://github.com/amcharts/amcharts4/blob/7fbb61e90363a2373e6130800dee06b8a62f3aab/src/.internal/core/utils/ResizeSensor.ts
+    /**
+     * Classe di utilità che tiene d'occhio i cambiamenti di dimensione di un elemento. Un **ResizeSensor** può controllare al massimo un elemento
+     */
+    var ResizeSensor = /** @class */ (function () {
+        /**
+         * Costruttore
+         *
+         * @param {HTMLElement} element Elemento HTML da controllare
+         * @param {Function} callback Callback da chiamare quando le dimensioni di **element** cambiano
+         */
+        function ResizeSensor(element, callback) {
+            /**
+             * Riferimento all'observer nativo
+             */
+            this.observer = null;
+            /**
+             * Indica se questo oggetto è stato distrutto o no
+             */
+            this.Disposed = false;
+            /**
+             * Elemento da controllare e callback da chiamare quando le dimensioni dell'elemento cambiano
+             */
+            this.target = null;
+            this.makeSensor();
+            this.addTarget(element, callback);
+        }
+        /**
+         * Distruttore
+         */
+        ResizeSensor.prototype.dispose = function () {
+            if (!this.Disposed) {
+                this.Disposed = true;
+                this.removeTarget();
+            }
+        };
+        /**
+         * Creazione del sensore che sarà collegato all'elemento da osservare dal metodo **addTarget**
+         */
+        ResizeSensor.prototype.makeSensor = function () {
+            var _this = this;
+            if (typeof ResizeObserver == "undefined")
+                throw "Resize Observer non è definito. Si prega di utilizzare un browser vero";
+            this.observer = new ResizeObserver(function (entries) {
+                for (var i = 0; i < entries.length; ++i) {
+                    if (_this.target && _this.target.targetEl === entries[i].target)
+                        _this.target.callback();
+                }
+            });
+        };
+        /**
+         * Dice al sensore di osservare l'elemento **targetEl**, richiamando **callback** qualora le dimensioni cambino
+         *
+         * @param {HTMLElement} targetEl Elemento HTML da controllare
+         * @param {Function} callback Callback da chiamare quando le dimensioni di **element** cambiano
+         */
+        ResizeSensor.prototype.addTarget = function (targetEl, callback) {
+            this.observer.observe(targetEl, { box: "content-box" });
+            this.target = { targetEl: targetEl, callback: callback };
+        };
+        /**
+         * Rimuove l'elemento HTML attuale dall'osservazione del **ResizeObserver**
+         */
+        ResizeSensor.prototype.removeTarget = function () {
+            if (!this.target)
+                return;
+            this.observer.unobserve(this.target.targetEl);
+            this.target = null;
+        };
+        return ResizeSensor;
+    }());
+
+    /**
+     * Classe che fornisce metodi reattivi di estensione. Per ora implementato solo uno pseudo-throttle
+     */
+    var ReactiveExtensions = /** @class */ (function () {
+        function ReactiveExtensions() {
+            /**
+             * Cache di tutti i timer in esecuzione
+             */
+            this.executionTimers = {};
+        }
+        /**
+         * Esecuzione deleyata di una funzione. Se viene richiamata nuovamente prima di venire eseguita dopo il delay, il delay viene resettato
+         *
+         * @param {string} id Id per aiutare il servizio a distinguere funzioni con nome uguale chiamate da componenti diversi
+         * @param {Function} func Funzione da chiamare al termine del throttle
+         * @param {number} throttleTime Tempo di throttling in millisecondi
+         */
+        ReactiveExtensions.prototype.throttle = function (id, func, throttleTime) {
+            var _this = this;
+            if (throttleTime === void 0) { throttleTime = 0; }
+            var key = func.name + "_" + id;
+            //Se ho la funzione che vuole eseguire ripulisco quel timeout
+            if (this.executionTimers[key])
+                clearTimeout(this.executionTimers[key]);
+            //Ricreo il timeout per eseguire quella funzione dopo throttleTime millisecondi
+            var executionTimer = setTimeout(function () { func(); _this.executionTimers[key] = null; }, throttleTime);
+            this.executionTimers[key] = executionTimer;
+        };
+        return ReactiveExtensions;
+    }());
+    ReactiveExtensions.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function ReactiveExtensions_Factory() { return new ReactiveExtensions(); }, token: ReactiveExtensions, providedIn: "root" });
+    ReactiveExtensions.decorators = [
+        { type: i0.Injectable, args: [{ providedIn: "root" },] }
+    ];
+
+    /** @ignore */ var cytoscape = cy___namespace;
+    /**
+     * Componente che si occupa di graficare un diagramma e di gestirne il ciclo di vita
+     */
+    var EsDiagramComponent = /** @class */ (function () {
+        /**
+         * Costruttore
+         *
+         * @ignore
+         */
+        function EsDiagramComponent(service, dispatcher, exts) {
+            this.service = service;
+            this.dispatcher = dispatcher;
+            this.exts = exts;
+            /**
+             * Nome del diagramma, fondamentale assegnarlo per permettere alla libreria di schedularne la creazione
+             */
+            this.name = "";
+            /**
+             * Indica se utilizzare il menù contestuale a ruota attorno ad ogni nodo
+             */
+            this.UseContextMenu = false;
+            /**
+             * Dice al componente se il diagramma deve utilizzare il sistema di estensione per l'expand e collapse dei gruppi
+             */
+            this.UseExpandCollapse = false;
+            /**
+             * Blocco completo delle opzioni, alternativo all'assegnazione di **Elements**, **NodeStyles**, **EdgeStyles**, e **Layout**.
+             *
+             * Qualora entrambe venissero specificate verrà effettuata un'unione fra queste opzioni e quelle specificate, dando priorità alle specificate
+             */
+            this.NativeOptions = {};
+            /**
+             * Aggiorna automaticamente le dimensioni del diagramma quando cambiano le dimensioni della finestra
+             */
+            this.AutoupdateSize = true;
+            /**
+             * Indica di mantenere la posizione dei nodi qualora venissero cambiati dall'Input **Elements**.
+             *
+             * Se l'ID di un nodo è uguale all'ID di un nodo presente in precedenza, il nuovo nodo ne erediterà la posizione
+             */
+            this.PreserveElementsPosition = true;
+            /**
+             * Qualora venisse modificato l'Input **Elements**, piuttosto che mettere semplicemente il nuovo Elemento in base al Layout precedente, applica anche un'animazione
+             *
+             * Funziona solamente se il **Layout** corrente del diagramma supporta le animazioni
+             */
+            this.AnimateLayoutChanges = true;
+            /**
+             * Periodo di throttle da quando viene effettuato un resize a quando ricalcolare le dimensioni del diagramma.
+             *
+             * Può essere tenuto a 0 (redraw istantaneo) finché non ci sono problemi di prestazioni con eventualmente tanti resize a poca distanza l'uno dall'altro.
+             */
+            this.ResizeThrottleTime = 0;
+            /**
+             * Fornisce il global della libreria (namespace **cytoscape**) e si aspetta che dopo operazioni di importazione
+             * lasciate all'utente vengano aggiunti tutti i moduli desiderati.
+             *
+             * È **fondamentale** che il primo parametro (il nome del modulo) sia uguale a ciò di cui viene fatto il require in modo che la libreria
+             * possa controllare che il modulo importato non sia già stato importato in precedenza
+             *
+             * ## Esempio:
+             *
+             * ```typescript
+             * (global) => {
+             *    return import("cytoscape-extension-library").then(module => global.use("cytoscape-extension-library", module.default));
+             *
+             *    ...
+             * }
+             * ```
+             */
+            this.ExtensionModulesImporter = null;
+            /**
+             * Fornisce l'istanza attuale di Cytoscape da cui è possibile prendere le librerie di estensione caricate in **ExtensionModulesImporter**
+             * e configurarle in base ai comportamenti specifici
+             *
+             * ## Esempio:
+             *
+             * ```typescript
+             * (cytoscapeCore) => {
+             *    // Fare questo lavoro per ogni estensione caricata
+             *    let extensionConfiguration = { ... };
+             *    let extensionInstance = cytoscapeCore.extensionLibrary(extensionConfiguration);
+             *    extensionInstance.doSomethingSpecificToThisExtension();
+             *
+             *    ...
+             * }
+             * ```
+             */
+            this.ExtensionModulesApplyer = null;
+            /**
+             * Evento lanciato al click di un nodo, contiene l'oggetto **data** del nodo in questione
+             */
+            this.onNodeClick = new i0.EventEmitter();
+            /**
+             * Indica se il rendering del diagramma è terminato
+             */
+            this.Rendered = false;
+            /**
+             * Api dell'estensione expand-collapse per permettere di effettuare operazioni dall'esterno del diagramma. Vengono valorizzate se **UseExpandCollapse** è **true**
+             */
+            this.ExpandCollapseApi = null;
+        }
+        /**
+         * @ignore
+         *
+         * Angular Pipeline
+         */
+        EsDiagramComponent.prototype.ngAfterViewInit = function () {
+            if (!this.service || !this.dispatcher)
+                throw "Il modulo @esfaenza/diagrams non è stato importato con il forRoot();";
+            this.dispatchLoadChart();
+        };
+        /**
+         * All'onDestroy ripulisco la memoria dal diagramma
+         */
+        EsDiagramComponent.prototype.ngOnDestroy = function () {
+            this.resizeObserver.dispose();
+            this.resizeObserver = null;
+            if (this.cy) {
+                this.service.log("I", "Diagram" + " " + this.name + ": Unloading destroyed diagram", false);
+                this.cy.destroy();
+                this.dispatcher.deregister(this.name);
+            }
+            else
+                this.service.log("I", "Chart " + this.name + ": Unloading uncreated chart component. It probably was a duplicated", false);
+        };
+        /**
+         * Registra il diagramma attuale nel Dispatcher in modo che venga caricato appena possibile
+         */
+        EsDiagramComponent.prototype.dispatchLoadChart = function () {
+            var _this = this;
+            this.dispatcher.register(this.name, function () { return _this.render(); });
+        };
+        /**
+         * @ignore
+         *
+         * Angular Pipeline: Gestione ri-graficazione del diagramma, se possibile
+         */
+        EsDiagramComponent.prototype.ngOnChanges = function (changes) {
+            var toCheck = ["Templates", "UseContextMenu", "ContextMenuOptions", "UseExpandCollapse", "ExpandCollapseOptions", "NodeStyles", "EdgeStyles", "NativeOptions"];
+            if (this.Rendered && toCheck.some(function (t) { return changes[t]; }))
+                this.service.log("W", "Redraw based on dynamic Input change is supported only for 'Elements' and 'Layout' inputs, please destroy the component and recreate it with the new settings");
+            var elementChanges = changes["Elements"];
+            var layoutChanges = changes["Layout"];
+            if (elementChanges && !elementChanges.firstChange) {
+                this.service.log("I", "Elements have been changed after diagram initialization");
+                // Cambiamento agli Elementi: ripulisco gli elementi vecchi, prendo i nuovi, li sistemo e li riassegno. 
+                // Se il nuovo Input Elements è roba strana mi limito a ripulire il diagramma
+                // Se cytoscape aveva già degli elementi precedentemente ne prendo le posizioni in modo da ridisegnarli partendo dallo stesso punto (carino per le animazioni)
+                var elements = elementChanges === null || elementChanges === void 0 ? void 0 : elementChanges.currentValue;
+                var previous_elements = this.PreserveElementsPosition ? this.cy.nodes() : null;
+                this.cy.elements().remove();
+                if (elements && elements.length && elements.length > 0) {
+                    this.reviewCytoscapeElements(elements, previous_elements);
+                    this.cy.add(elements);
+                    // Se solo gli elementi cambiano, riapplico il Layout precedente
+                    if (!layoutChanges && this.LastLayout) {
+                        // Se devo animare le modifche al layout forzo il parametro relativo
+                        if (this.AnimateLayoutChanges)
+                            this.LastLayout.animate = true;
+                        this.cy.layout(this.LastLayout).run();
+                    }
+                }
+            }
+            // Se il layout cambia lo applico e me lo salvo come layout precedente per il futuro
+            if (layoutChanges && !layoutChanges.firstChange) {
+                this.service.log("I", "Layout have been changed after diagram initialization");
+                this.LastLayout = JSON.parse(JSON.stringify(layoutChanges.currentValue));
+                this.cy.layout(this.LastLayout).run();
+            }
+        };
+        /**
+         * Effettua il rendering del diagramma
+         */
+        EsDiagramComponent.prototype.render = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var cyOptions;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            cyOptions = this.getCompletedOptions();
+                            this.NodesHierarchy = cyOptions.elements && cyOptions.elements.some(function (t) { return t.data.parent; });
+                            // Carico eventuali classi di estensione che servono
+                            return [4 /*yield*/, this.performModulesLoading()];
+                        case 1:
+                            // Carico eventuali classi di estensione che servono
+                            _a.sent();
+                            // Genero il diagramma
+                            this.cy = cytoscape(cyOptions);
+                            // Collego gli eventi al componente
+                            this.bindCytoscapeEvents();
+                            // Utilizzo le classi di estensione caricate precedentemente per fare il resto delle mie operazioni
+                            this.performOperationsWithLoadedModules();
+                            // Imposto la variabile Rendered a true in modo che se da adesso vengono fatte modifiche che dovrebbero causare un redraw posso accorgermene
+                            // e mandare a cagare lo stronzo di turno
+                            this.Rendered = true;
+                            // Se devo aggiornare in automatico in base alla dimensione del contenitore collego il ResizeObserver
+                            if (this.AutoupdateSize)
+                                this.listenOnChanges();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        /**
+         * Registra l'ascolto al contenitore del grafico e in caso di modifiche alla dimensione, al massimo una volta ogni 500 millisecondi, lo ridisegna
+         */
+        EsDiagramComponent.prototype.listenOnChanges = function () {
+            var _this = this;
+            this.resizeObserver = new ResizeSensor(this.cyGraph.nativeElement, function () {
+                _this.exts.throttle(_this.name, _this.onContainerSizeChanged.bind(_this), _this.ResizeThrottleTime);
+            });
+        };
+        /**
+         * Funzione che si occupa di gestire il repaint del diagramma
+         */
+        EsDiagramComponent.prototype.onContainerSizeChanged = function () {
+            this.service.log("I", "Diagram container size has changed, redrawing");
+            this.cy.resize();
+            this.cy.fit();
+        };
+        /**
+         * Collega tutti gli eventi che mi possono servire e li espone in output
+         */
+        EsDiagramComponent.prototype.bindCytoscapeEvents = function () {
+            var _this = this;
+            this.cy.bind('click', 'node', function (event) {
+                _this.onNodeClick.emit({ data: event.target.data() });
+            });
+            // Altri eventi...
+        };
+        /**
+         * Metodo che serve per caricare tutte le estensioni della libreria in base a ciò che viene utilizzato
+         */
+        EsDiagramComponent.prototype.performModulesLoading = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var wrappedCytoscape;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!(this.Layout.name == 'dagre')) return [3 /*break*/, 2];
+                            return [4 /*yield*/, this.loadInternal("cytoscape-dagre")];
+                        case 1:
+                            _a.sent();
+                            _a.label = 2;
+                        case 2:
+                            if (!(this.NodeHTMLTemplates && this.NodeHTMLTemplates.length > 0)) return [3 /*break*/, 4];
+                            return [4 /*yield*/, this.loadInternal("cytoscape-html-node")];
+                        case 3:
+                            _a.sent();
+                            _a.label = 4;
+                        case 4:
+                            if (!this.UseContextMenu) return [3 /*break*/, 6];
+                            return [4 /*yield*/, this.loadInternal("cytoscape-cxtmenu")];
+                        case 5:
+                            _a.sent();
+                            _a.label = 6;
+                        case 6:
+                            if (!(this.NodesHierarchy && this.UseExpandCollapse)) return [3 /*break*/, 8];
+                            return [4 /*yield*/, this.loadInternal("cytoscape-expand-collapse")];
+                        case 7:
+                            _a.sent();
+                            _a.label = 8;
+                        case 8:
+                            if (!this.ExtensionModulesImporter) return [3 /*break*/, 10];
+                            wrappedCytoscape = {
+                                use: function (moduleName, module) {
+                                    if (!module)
+                                        _this.service.log("E", _this.service.loc("Received an undefined module. Make sure you are correctly loading it") + ": " + moduleName, false);
+                                    if (["cytoscape-dagre", "cytoscape-html-node", "cytoscape-cxtmenu", "cytoscape-expand-collapse"].includes(moduleName))
+                                        _this.service.log("W", _this.service.loc("Module") + " " + moduleName + " " + _this.service.loc("is loaded and managed directly by this library. You don't need to import it or use it directly, just be sure to set the relative options"), false);
+                                    else
+                                        cytoscape.use(module);
+                                }
+                            };
+                            return [4 /*yield*/, this.ExtensionModulesImporter(wrappedCytoscape)];
+                        case 9:
+                            _a.sent();
+                            _a.label = 10;
+                        case 10: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        /**
+         * Metodo che serve per caricare tutte le estensioni della libreria in base a ciò che viene utilizzato con le opzioni definite dagli Input
+         */
+        EsDiagramComponent.prototype.performOperationsWithLoadedModules = function () {
+            var anyCy = this.cy;
+            // Utilizzo del layout, lo salvo per poterlo riutilizzare in futuro
+            if (this.Layout) {
+                this.LastLayout = JSON.parse(JSON.stringify(this.Layout));
+                this.cy.layout(this.LastLayout).run();
+            }
+            // Utilizzo dell'HTML node
+            if (this.NodeHTMLTemplates && this.NodeHTMLTemplates.length > 0) {
+                var htmlnode = anyCy.htmlnode();
+                htmlnode.createHtmlNode(cytoscape, this.cy, this.NodeHTMLTemplates);
+            }
+            // Utilizzo del Context Menu
+            if (this.UseContextMenu)
+                anyCy.cxtmenu(this.ContextMenuOptions);
+            // Utilizzo dell'expand collapse solo quando c'è una gerarchia di nodi
+            if (this.NodesHierarchy && this.UseExpandCollapse)
+                this.ExpandCollapseApi = anyCy.expandCollapse(this.ExpandCollapseOptions);
+            // Utilizzo di estensioni extra, implementazione affidata al programmatore
+            if (this.ExtensionModulesApplyer)
+                this.ExtensionModulesApplyer(this.cy);
+        };
+        /**
+         * Metodo interno per il caricamento dei moduli di estensione
+         *
+         * @param {'cytoscape-expand-collapse' | 'cytoscape-cxtmenu' | 'cytoscape-html-node' | 'cytoscape-dagre'} moduleId Modulo da caricare
+         */
+        EsDiagramComponent.prototype.loadInternal = function (moduleId) {
+            return __awaiter(this, void 0, void 0, function () {
+                var toLoad;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.service.importIfNeeded(moduleId)];
+                        case 1:
+                            toLoad = _a.sent();
+                            if (toLoad)
+                                cytoscape.use(toLoad);
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        /**
+         * Metodo che basandosi sulle opzioni native eventualmente assegnate le completa con gli Input addizionali
+         *
+         * @returns {cy_.CytoscapeOptions} Opzioni finali unite da Input ed opzioni native
+         */
+        EsDiagramComponent.prototype.getCompletedOptions = function () {
+            var opts = this.NativeOptions || {};
+            opts.container = this.cyGraph.nativeElement;
+            opts.style = opts.style || [];
+            // Per tutte le cose per cui gli Input hanno priorità sovrascrivo gli originali delle opzioni
+            if (this.NodeStyles || this.EdgeStyles) {
+                opts.style = [];
+                if (this.NodeStyles)
+                    opts.style.push({ selector: 'node', css: this.NodeStyles });
+                if (this.EdgeStyles)
+                    opts.style.push({ selector: 'edge', css: this.EdgeStyles });
+            }
+            if (this.Elements)
+                opts.elements = this.Elements;
+            this.reviewCytoscapeElements(opts.elements);
+            if (this.Layout)
+                opts.layout = this.Layout;
+            if (this.Readonly) {
+                // Questo coso fa effetti strani....
+                //opts.autolock = true;
+                opts.autoungrabify = true;
+                opts.autounselectify = true;
+                opts.boxSelectionEnabled = false;
+                opts.userZoomingEnabled = false;
+                opts.userPanningEnabled = false;
+            }
+            return opts;
+        };
+        /**
+         * Aggiustamenti degli elementi di Cytoscape.
+         *
+         * I nodi non vengono toccati.
+         *
+         * Per ogni edge viene controllato se è specificata una sorgente ed una destinazione, in caso contrario si cerca di dedurli dall'ID
+         *
+         * @param {cytoscape.ElementDefinition[]} elements Elementi da sistemare
+         */
+        EsDiagramComponent.prototype.reviewCytoscapeElements = function (elements, prevPositions) {
+            var hasPreviousPositions = prevPositions && prevPositions.length > 0;
+            var positionCache = {};
+            if (hasPreviousPositions) {
+                for (var i = 0; i < prevPositions.length; i++) {
+                    var item = prevPositions[i];
+                    if (!positionCache[item.data().id])
+                        positionCache[item.data().id] = item.position();
+                }
+            }
+            for (var i = 0; i < elements.length; i++) {
+                var el = elements[i];
+                if (el.group == "edges" && (!el.data.source && !el.data.target)) {
+                    if (!el.data.id.includes("-"))
+                        this.service.log("E", "If you don't specify a source and a target for an edge you have to write its id in the format {source}-{target}");
+                    else {
+                        var sourceTarget = el.data.id.split('-');
+                        el.data.source = sourceTarget[0].trim();
+                        el.data.target = sourceTarget[1].trim();
+                    }
+                }
+                if (hasPreviousPositions && el.group == "nodes")
+                    el.position = positionCache[el.data.id];
+            }
+        };
+        return EsDiagramComponent;
+    }());
+    EsDiagramComponent.decorators = [
+        { type: i0.Component, args: [{
+                    selector: 'es-diagram',
+                    template: "<div #graph class=\"graph-wrapper {{name}}\"></div>",
+                    styles: [".graph-wrapper{height:100%;width:100%}.html-node-notransition{transition:none!important;transform:none!important}\n"]
+                },] }
+    ];
+    EsDiagramComponent.ctorParameters = function () { return [
+        { type: EsDiagramService, decorators: [{ type: i0.Optional }] },
+        { type: EsDiagramDispatcher, decorators: [{ type: i0.Optional }] },
+        { type: ReactiveExtensions }
+    ]; };
+    EsDiagramComponent.propDecorators = {
+        cyGraph: [{ type: i0.ViewChild, args: ['graph',] }],
+        name: [{ type: i0.Input }],
+        UseContextMenu: [{ type: i0.Input }],
+        ContextMenuOptions: [{ type: i0.Input }],
+        UseExpandCollapse: [{ type: i0.Input }],
+        ExpandCollapseOptions: [{ type: i0.Input }],
+        NativeOptions: [{ type: i0.Input }],
+        Elements: [{ type: i0.Input }],
+        NodeStyles: [{ type: i0.Input }],
+        EdgeStyles: [{ type: i0.Input }],
+        Readonly: [{ type: i0.Input }],
+        AutoupdateSize: [{ type: i0.Input }],
+        PreserveElementsPosition: [{ type: i0.Input }],
+        AnimateLayoutChanges: [{ type: i0.Input }],
+        ResizeThrottleTime: [{ type: i0.Input }],
+        Layout: [{ type: i0.Input }],
+        NodeHTMLTemplates: [{ type: i0.Input }],
+        ExtensionModulesImporter: [{ type: i0.Input }],
+        ExtensionModulesApplyer: [{ type: i0.Input }],
+        onNodeClick: [{ type: i0.Output }]
+    };
+
+    var EsDiagramModule = /** @class */ (function () {
+        function EsDiagramModule() {
+        }
+        EsDiagramModule.forRoot = function (config) {
+            return {
+                ngModule: EsDiagramModule,
+                providers: [
+                    EsDiagramService,
+                    EsDiagramDispatcher,
+                    { provide: DIA_LOCALE, useValue: (config === null || config === void 0 ? void 0 : config.locale) || 'it-IT' },
+                    { provide: DIA_DEBUG_MODE, useValue: (config === null || config === void 0 ? void 0 : config.debugMode) || false },
+                ]
+            };
+        };
+        return EsDiagramModule;
+    }());
+    EsDiagramModule.decorators = [
+        { type: i0.NgModule, args: [{
+                    declarations: [EsDiagramComponent],
+                    imports: [common.CommonModule, forms.FormsModule, forms.ReactiveFormsModule, common.CommonModule],
+                    exports: [EsDiagramComponent]
+                },] }
+    ];
+
+    /*
+     * Public API Surface of cytoscape-angular
+     */
+
+    /**
+     * Generated bundle index. Do not edit.
+     */
+
+    exports.BaseLayoutOptionsImpl = BaseLayoutOptionsImpl;
+    exports.BreadthFirstLayoutOptionsImpl = BreadthFirstLayoutOptionsImpl;
+    exports.CircleLayoutOptionsImpl = CircleLayoutOptionsImpl;
+    exports.ConcentricLayoutOptionsImpl = ConcentricLayoutOptionsImpl;
+    exports.ContextMenuCommand = ContextMenuCommand;
+    exports.ContextMenuOptions = ContextMenuOptions;
+    exports.CoseLayoutOptionsImpl = CoseLayoutOptionsImpl;
+    exports.DagreLayoutOptionsImpl = DagreLayoutOptionsImpl;
+    exports.EsDiagramComponent = EsDiagramComponent;
+    exports.EsDiagramModule = EsDiagramModule;
+    exports.EsDiagramModuleConfig = EsDiagramModuleConfig;
+    exports.ExpandCollapseOptions = ExpandCollapseOptions;
+    exports.GridLayoutOptionsImpl = GridLayoutOptionsImpl;
+    exports.NodeHTMLTemplate = NodeHTMLTemplate;
+    exports.NodeTemplate = NodeTemplate;
+    exports.NullLayoutOptionsImpl = NullLayoutOptionsImpl;
+    exports.PresetLayoutOptionsImpl = PresetLayoutOptionsImpl;
+    exports.RandomLayoutOptionsImpl = RandomLayoutOptionsImpl;
+    exports.ShapedLayoutOptionsImpl = ShapedLayoutOptionsImpl;
+    exports.ZoomLevelBasedTemplate = ZoomLevelBasedTemplate;
+    exports.ɵa = AnimateLayoutOptionsImpl;
+    exports.ɵb = EsDiagramService;
+    exports.ɵc = DIA_LOCALE;
+    exports.ɵd = DIA_DEBUG_MODE;
+    exports.ɵe = EsDiagramDispatcher;
+    exports.ɵf = ReactiveExtensions;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=esfaenza-es-diagrams.umd.js.map