@seniorsistemas/angular-components 16.13.2 → 17.1.0

package/bundles/seniorsistemas-angular-components.umd.js

@@ -8751,6 +8751,1710 @@
         return EditableOverlayModule;
     }());
 
+    var moment$7 = moment_;
+    var YEAR = "year";
+    var MONTH = "month";
+    var DAY = "day";
+    var HOUR = "hour";
+    var MINUTE = "minute";
+    var SECOND = "second";
+    var MILLISECOND = "millisecond";
+    var DateUtils = /** @class */ (function () {
+        function DateUtils() {
+        }
+        DateUtils.parse = function (date) {
+            return moment$7(date).toDate();
+        };
+        DateUtils.toString = function (date, with_time) {
+            if (with_time === void 0) { with_time = false; }
+            var result = with_time ? moment$7(date, "YYYY-MM-DD hh:mm:ss.SSS") : moment$7(date, "YYYY-MM-DD");
+            return result.toString();
+        };
+        DateUtils.format = function (date, formatString, lang) {
+            if (formatString === void 0) { formatString = "YYYY-MM-DD HH:mm:ss.SSS"; }
+            if (lang === void 0) { lang = "en"; }
+            var monthName = moment$7(date)
+                .locale(lang)
+                .startOf("month")
+                .format("MMMM");
+            var monthNameCapitalized = monthName.charAt(0).toUpperCase() + monthName.slice(1);
+            var dateToFormat = moment$7(date);
+            var format_map = {
+                YYYY: dateToFormat.format("YYYY"),
+                MM: dateToFormat.format("MM"),
+                DD: dateToFormat.format("DD"),
+                HH: dateToFormat.format("HH"),
+                mm: dateToFormat.format("mm"),
+                ss: dateToFormat.format("ss"),
+                SSS: dateToFormat.format("SSS"),
+                D: dateToFormat.format("D"),
+                MMMM: monthNameCapitalized,
+                MMM: monthNameCapitalized,
+            };
+            var str = formatString;
+            var formattedValues = [];
+            Object.keys(format_map)
+                .sort(function (a, b) { return b.length - a.length; })
+                .forEach(function (key) {
+                if (str.includes(key)) {
+                    str = str.replace(key, "$" + formattedValues.length);
+                    formattedValues.push(format_map[key]);
+                }
+            });
+            formattedValues.forEach(function (value, i) {
+                str = str.replace("$" + i, value);
+            });
+            return str;
+        };
+        DateUtils.diff = function (fistDate, secondDate, scale) {
+            var milliseconds = moment$7(fistDate).diff(secondDate, MILLISECOND);
+            var seconds = moment$7(fistDate).diff(secondDate, SECOND);
+            var minutes = moment$7(fistDate).diff(secondDate, MINUTE);
+            var hours = moment$7(fistDate).diff(secondDate, HOUR);
+            var days = moment$7(fistDate).diff(secondDate, DAY);
+            var months = moment$7(fistDate).diff(secondDate, MONTH);
+            var years = moment$7(fistDate).diff(secondDate, YEAR);
+            if (!scale.endsWith("s")) {
+                scale += "s";
+            }
+            return Math.floor({
+                milliseconds: milliseconds,
+                seconds: seconds,
+                minutes: minutes,
+                hours: hours,
+                days: days,
+                months: months,
+                years: years,
+            }[scale]);
+        };
+        DateUtils.today = function () {
+            var dateStr = moment$7().format("YYY-MM-DD");
+            return new Date(dateStr);
+        };
+        DateUtils.now = function () {
+            return moment$7().toDate();
+        };
+        DateUtils.add = function (date, quantity, scale) {
+            return moment$7(date).add(quantity, scale).toDate();
+        };
+        DateUtils.startOf = function (date, scale) {
+            var _a;
+            var scores = (_a = {},
+                _a[YEAR] = 6,
+                _a[MONTH] = 5,
+                _a[DAY] = 4,
+                _a[HOUR] = 3,
+                _a[MINUTE] = 2,
+                _a[SECOND] = 1,
+                _a[MILLISECOND] = 0,
+                _a);
+            function shouldReset(_scale) {
+                var max_score = scores[scale];
+                return scores[_scale] <= max_score;
+            }
+            var vals = [
+                date.getFullYear(),
+                shouldReset(YEAR) ? 0 : date.getMonth(),
+                shouldReset(MONTH) ? 1 : date.getDate(),
+                shouldReset(DAY) ? 0 : date.getHours(),
+                shouldReset(HOUR) ? 0 : date.getMinutes(),
+                shouldReset(MINUTE) ? 0 : date.getSeconds(),
+                shouldReset(SECOND) ? 0 : date.getMilliseconds(),
+            ];
+            return new Date(vals[0], vals[1], vals[2], vals[3], vals[4], vals[5], vals[6]);
+        };
+        DateUtils.clone = function (date) {
+            return moment$7(date).toDate();
+        };
+        DateUtils.getDateValues = function (date) {
+            return [
+                date.getFullYear(),
+                date.getMonth(),
+                date.getDate(),
+                date.getHours(),
+                date.getMinutes(),
+                date.getSeconds(),
+                date.getMilliseconds(),
+            ];
+        };
+        DateUtils.getDaysInMonth = function (date) {
+            return moment$7(date, "YYYY-MM").daysInMonth();
+        };
+        return DateUtils;
+    }());
+
+    var $ = function (expr, con) {
+        return typeof expr === 'string'
+            ? (con || document).querySelector(expr)
+            : expr || null;
+    };
+    var createSVG = function (tag, attrs) {
+        var elem = document.createElementNS("http://www.w3.org/2000/svg", tag);
+        for (var attr in attrs) {
+            if (attr === "append_to") {
+                var parent_1 = attrs.append_to;
+                parent_1.appendChild(elem);
+            }
+            else if (attr === "innerHTML") {
+                elem.innerHTML = attrs.innerHTML;
+            }
+            else {
+                elem.setAttribute(attr, attrs[attr]);
+            }
+        }
+        return elem;
+    };
+    var animateSVG = function (svgElement, attr, from, to) {
+        var animatedSvgElement = getAnimationElement(svgElement, attr, from, to);
+        if (animatedSvgElement === svgElement) {
+            // triggered 2nd time programmatically
+            // trigger artificial click event
+            var event_1 = document.createEvent("HTMLEvents");
+            event_1.initEvent("click", true, true);
+            // event.eventName = 'click'; TODO: Ver porque esta propriedade não existe
+            animatedSvgElement.dispatchEvent(event_1);
+        }
+    };
+    var getAnimationElement = function (svgElement, attr, from, to, dur, begin) {
+        if (dur === void 0) { dur = "0.4s"; }
+        if (begin === void 0) { begin = "0.1s"; }
+        var animEl = svgElement.querySelector("animate");
+        if (animEl) {
+            $.attr(animEl, {
+                attributeName: attr,
+                from: from,
+                to: to,
+                dur: dur,
+                begin: "click + " + begin,
+            }, null);
+            return svgElement;
+        }
+        var animateElement = createSVG("animate", {
+            attributeName: attr,
+            from: from,
+            to: to,
+            dur: dur,
+            begin: begin,
+            calcMode: "spline",
+            values: from + ";" + to,
+            keyTimes: "0; 1",
+            keySplines: cubic_bezier("ease-out"),
+        });
+        svgElement.appendChild(animateElement);
+        return svgElement;
+    };
+    var ɵ0 = getAnimationElement;
+    var cubic_bezier = function (name) {
+        return {
+            ease: ".25 .1 .25 1",
+            linear: "0 0 1 1",
+            "ease-in": ".42 0 1 1",
+            "ease-out": "0 0 .58 1",
+            "ease-in-out": ".42 0 .58 1",
+        }[name];
+    };
+    var ɵ1 = cubic_bezier;
+    $.on = function (element, event, selector, callback) {
+        if (!callback) {
+            callback = selector;
+            $.bind(element, event, callback);
+        }
+        else {
+            $.delegate(element, event, selector, callback);
+        }
+    };
+    $.off = function (element, event, handler) {
+        element.removeEventListener(event, handler);
+    };
+    $.bind = function (element, event, callback) {
+        event.split(/\s+/).forEach(function (event) {
+            element.addEventListener(event, callback);
+        });
+    };
+    $.delegate = function (element, event, selector, callback) {
+        element.addEventListener(event, function (e) {
+            var delegatedTarget = e.target.closest(selector);
+            if (delegatedTarget) {
+                e.delegatedTarget = delegatedTarget;
+                callback.call(this, e, delegatedTarget);
+            }
+        });
+    };
+    $.closest = function (selector, element) {
+        if (!element) {
+            return null;
+        }
+        if (element.matches(selector)) {
+            return element;
+        }
+        // TODO: Corrigir este problema
+        // return $.closest(selector, element.parentNode);
+    };
+    $.attr = function (element, attr, value) {
+        if (!value && typeof attr === "string") {
+            return element.getAttribute(attr);
+        }
+        if (typeof attr === "object") {
+            for (var key in attr) {
+                $.attr(element, key, attr[key]);
+            }
+            return;
+        }
+        element.setAttribute(attr, value);
+    };
+
+
+    (function (ViewMode) {
+        ViewMode["QuarterDay"] = "quarterDay";
+        ViewMode["HalfDay"] = "halfDay";
+        ViewMode["Day"] = "day";
+        ViewMode["Week"] = "week";
+        ViewMode["Month"] = "month";
+        ViewMode["Year"] = "year";
+        ViewMode["Hour"] = "hour";
+    })(exports.ViewMode || (exports.ViewMode = {}));
+
+    var Bar = /** @class */ (function () {
+        function Bar(gantt, task) {
+            this._setDefaults(gantt, task);
+            this._prepare();
+            this._draw();
+            this._bind();
+        }
+        Object.defineProperty(Bar.prototype, "arrows", {
+            get: function () {
+                return this._arrows;
+            },
+            set: function (arrows) {
+                this._arrows = arrows;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Bar.prototype, "task", {
+            get: function () {
+                return this._task;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Bar.prototype, "element", {
+            get: function () {
+                return this._element;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Bar.prototype, "group", {
+            get: function () {
+                return this._group;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Bar.prototype.updateBarPosition = function (_a) {
+            var _this = this;
+            var x = _a.x, width = _a.width;
+            var bar = this.element;
+            if (x) {
+                // get all x values of parent task
+                var xs = this.task.dependencies.map(function (dep) {
+                    return _this._gantt.get_bar(dep).element.getX();
+                });
+                // child task must not go before parent
+                var valid_x = xs.reduce(function (prev, curr) {
+                    return x >= curr;
+                }, x);
+                if (!valid_x) {
+                    width = null;
+                    return;
+                }
+                this._updateAttr(bar, "x", x);
+            }
+            if (width && width >= this._gantt.options.columnWidth) {
+                this._updateAttr(bar, "width", width);
+            }
+            this._updateLabelPosition();
+            this._updateArrowPosition();
+        };
+        Bar.prototype.dateChanged = function () {
+            var changed = false;
+            var _a = this._computeStartEndDate(), newStartDate = _a.newStartDate, newEndDate = _a.newEndDate;
+            if (this.task.start !== newStartDate) {
+                changed = true;
+                this.task.start = newStartDate;
+            }
+            if (this.task.end !== newEndDate) {
+                changed = true;
+                this.task.end = newEndDate;
+            }
+            if (changed) {
+                this._gantt.trigger_event("onDateChange", [
+                    this.task,
+                    newStartDate,
+                    DateUtils.add(newEndDate, -1, "second"),
+                ]);
+            }
+            ;
+        };
+        Bar.prototype.setActionCompleted = function () {
+            var _this = this;
+            this._actionCompleted = true;
+            setTimeout(function () {
+                _this._actionCompleted = false;
+            }, 1000);
+        };
+        Bar.prototype._setDefaults = function (gantt, task) {
+            this._actionCompleted = false;
+            this._gantt = gantt;
+            this._task = task;
+        };
+        Bar.prototype._prepare = function () {
+            this._prepareValues();
+            this._prepareHelpers();
+        };
+        Bar.prototype._prepareValues = function () {
+            this._invalid = this.task.invalid;
+            this._height = this._gantt.options.barHeight;
+            this._x = this._computeX();
+            this._y = this._computeY();
+            this._cornerRadius = this._gantt.options.barCornerRadius;
+            this._duration = DateUtils.diff(this.task.end, this.task.start, "minute") / this._gantt.options.step / 60.0;
+            this._width = this._gantt.options.columnWidth * this._duration;
+            this._group = createSVG("g", {
+                class: "bar-wrapper " + (this.task.custom_class || ""),
+                "data-id": this.task.id,
+            });
+            this._barGroup = createSVG("g", {
+                class: "bar-group",
+                append_to: this.group,
+            });
+        };
+        Bar.prototype._prepareHelpers = function () {
+            SVGElement.prototype.getX = function () {
+                return +this.getAttribute("x");
+            };
+            SVGElement.prototype.getY = function () {
+                return +this.getAttribute("y");
+            };
+            SVGElement.prototype.getWidth = function () {
+                return +this.getAttribute("width");
+            };
+            SVGElement.prototype.getHeight = function () {
+                return +this.getAttribute("height");
+            };
+            SVGElement.prototype.getEndX = function () {
+                return this.getX() + this.getWidth();
+            };
+        };
+        Bar.prototype._draw = function () {
+            this._drawBar();
+            this._drawLabel();
+        };
+        Bar.prototype._drawBar = function () {
+            this._element = createSVG("rect", {
+                x: this._x,
+                y: this._y,
+                width: this._width,
+                height: this._height,
+                rx: this._cornerRadius,
+                ry: this._cornerRadius,
+                class: "bar",
+                append_to: this._barGroup,
+                fill: this.task.color,
+            });
+            animateSVG(this.element, "width", 0, this._width);
+            if (this._invalid) {
+                this.element.classList.add("bar-invalid");
+            }
+        };
+        Bar.prototype._drawLabel = function () {
+            var _this = this;
+            createSVG("text", {
+                x: this._x + this._width / 2,
+                y: this._y + this._height / 2,
+                innerHTML: this.task.showTaskName ? this.task.name : "",
+                class: "bar-label",
+                append_to: this._barGroup,
+            });
+            // labels get BBox in the next tick
+            requestAnimationFrame(function () { return _this._updateLabelPosition(); });
+        };
+        Bar.prototype._bind = function () {
+            if (!this._invalid) {
+                this._setupClickEvent();
+            }
+        };
+        Bar.prototype._setupClickEvent = function () {
+            var _this = this;
+            $.on(this.group, "focus " + this._gantt.options.popupTrigger, function (e) {
+                // just finished a move action, wait for a few seconds
+                if (!_this._actionCompleted) {
+                    _this._showPopup();
+                    _this._gantt.unselect_all();
+                    _this.group.classList.add("active");
+                }
+            }, null);
+            $.on(this.group, "dblclick", function (e) {
+                // just finished a move action, wait for a few seconds
+                if (!_this._actionCompleted) {
+                    _this._gantt.trigger_event("onClick", [_this.task]);
+                }
+            }, null);
+        };
+        Bar.prototype._showPopup = function () {
+            if (this._gantt.bar_being_dragged) {
+                return;
+            }
+            var formatString = this._gantt.view_is(exports.ViewMode.Hour)
+                ? "HH:ss"
+                : "MMM D";
+            var start_date = DateUtils.format(this.task.start, formatString, this._gantt.options.language);
+            var end_date = DateUtils.format(DateUtils.add(this.task.end, -1, "second"), formatString, this._gantt.options.language);
+            var subtitle = start_date + " - " + end_date;
+            this._gantt.show_popup({
+                target_element: this.element,
+                title: this.task.name,
+                subtitle: subtitle,
+                task: this.task,
+            });
+        };
+        Bar.prototype._computeStartEndDate = function () {
+            var bar = this.element;
+            var xInUnits = bar.getX() / this._gantt.options.columnWidth;
+            var newStartDate = DateUtils.add(this._gantt.minDate, xInUnits * this._gantt.options.step, "hour");
+            var width_in_units = bar.getWidth() / this._gantt.options.columnWidth;
+            var newEndDate = DateUtils.add(newStartDate, width_in_units * this._gantt.options.step, "hour");
+            return { newStartDate: newStartDate, newEndDate: newEndDate };
+        };
+        Bar.prototype._computeX = function () {
+            var _a = this._gantt.options, step = _a.step, columnWidth = _a.columnWidth;
+            var diff = DateUtils.diff(this.task.start, this._gantt.minDate, "hour");
+            var x = (diff / step) * columnWidth;
+            if (this._gantt.view_is(exports.ViewMode.Month)) {
+                var diff_1 = DateUtils.diff(this.task.start, this._gantt.minDate, "day");
+                x = (diff_1 * columnWidth) / 30;
+            }
+            return x;
+        };
+        Bar.prototype._computeY = function () {
+            return (this._gantt.options.headerHeight +
+                this._gantt.options.padding +
+                this.task._index * (this._height + this._gantt.options.padding));
+        };
+        Bar.prototype._updateAttr = function (element, attr, value) {
+            value = +value;
+            if (!isNaN(value)) {
+                element.setAttribute(attr, value);
+            }
+            return element;
+        };
+        Bar.prototype._updateLabelPosition = function () {
+            var bar = this.element, label = this.group.querySelector(".bar-label");
+            if (label.getBBox().width > bar.getWidth()) {
+                label.classList.add("big");
+                label.setAttribute("x", bar.getX() + bar.getWidth() + 5);
+            }
+            else {
+                label.classList.remove("big");
+                label.setAttribute("x", bar.getX() + bar.getWidth() / 2);
+            }
+        };
+        Bar.prototype._updateArrowPosition = function () {
+            var e_1, _a;
+            this._arrows = this._arrows || [];
+            try {
+                for (var _b = __values(this._arrows), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var arrow = _c.value;
+                    arrow.update();
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        };
+        return Bar;
+    }());
+
+    var Popup = /** @class */ (function () {
+        function Popup(parent, customHtml) {
+            this.parent = parent;
+            this.customHtml = customHtml;
+            this.make();
+        }
+        Popup.prototype.show = function (options) {
+            if (!options.target_element) {
+                throw new Error("target_element is required to show popup");
+            }
+            if (!options.position) {
+                options.position = "left";
+            }
+            var target_element = options.target_element;
+            if (this.customHtml) {
+                var html = this.customHtml(options.task);
+                html += '<div class="pointer"></div>';
+                this.parent.innerHTML = html;
+                this.pointer = this.parent.querySelector(".pointer");
+            }
+            else {
+                // set data
+                this.title.innerHTML = options.title;
+                this.subtitle.innerHTML = options.subtitle;
+                this.parent.style.width = this.parent.clientWidth + "px";
+            }
+            // set position
+            var positionMeta;
+            if (target_element instanceof HTMLElement) {
+                positionMeta = target_element.getBoundingClientRect();
+            }
+            else if (target_element instanceof SVGElement) {
+                positionMeta = options.target_element.getBBox();
+            }
+            if (options.position === 'left') {
+                this.parent.style.left = positionMeta.x + (positionMeta.width + 10) + "px";
+                this.parent.style.top = positionMeta.y + "px";
+                this.pointer.style.transform = "rotateZ(90deg)";
+                this.pointer.style.left = "-7px";
+                this.pointer.style.top = "2px";
+            }
+            // show
+            this.parent.style.opacity = 1;
+        };
+        Popup.prototype.make = function () {
+            this.parent.innerHTML = "\n        <div class=\"popup\">\n            <div class=\"wrp-title\">\n                <span class=\"title\"></span>\n            </div>\n            <div class=\"wrp-subtitle\">\n                <span class=\"icon fas fa-calendar-alt\"></span>\n                <span class=\"subtitle\"></span>\n            </div>\n            <div class=\"pointer\"></div>\n        </div>\n        ";
+            this.hide();
+            this.title = this.parent.querySelector(".title");
+            this.subtitle = this.parent.querySelector(".subtitle");
+            this.pointer = this.parent.querySelector(".pointer");
+        };
+        Popup.prototype.hide = function () {
+            this.parent.style.opacity = 0;
+            this.parent.style.left = 0;
+        };
+        return Popup;
+    }());
+
+    var Arrow = /** @class */ (function () {
+        function Arrow(gantt, fromTask, toTask) {
+            this._gantt = gantt;
+            this._fromTask = fromTask;
+            this._toTask = toTask;
+            this.calculatePath();
+            this.draw();
+        }
+        Object.defineProperty(Arrow.prototype, "fromTask", {
+            get: function () {
+                return this._fromTask;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Arrow.prototype, "toTask", {
+            get: function () {
+                return this._toTask;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Arrow.prototype, "element", {
+            get: function () {
+                return this._element;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Arrow.prototype.update = function () {
+            this.calculatePath();
+            this._element.setAttribute("d", this._path);
+        };
+        Arrow.prototype.calculatePath = function () {
+            var _this = this;
+            var startX = this.fromTask.element.getX() + this.fromTask.element.getWidth() / 2;
+            var condition = function () {
+                return _this.toTask.element.getX() < startX + _this._gantt.options.padding &&
+                    startX > _this.fromTask.element.getX() + _this._gantt.options.padding;
+            };
+            while (condition()) {
+                startX -= 10;
+            }
+            var startY = this._gantt.options.headerHeight +
+                this._gantt.options.barHeight +
+                (this._gantt.options.padding + this._gantt.options.barHeight) *
+                    this.fromTask.task._index +
+                this._gantt.options.padding;
+            var endX = this.toTask.element.getX() - this._gantt.options.padding / 2;
+            var endY = this._gantt.options.headerHeight +
+                this._gantt.options.barHeight / 2 +
+                (this._gantt.options.padding + this._gantt.options.barHeight) *
+                    this.toTask.task._index +
+                this._gantt.options.padding;
+            var fromIsBelowTo = this.fromTask.task._index > this.toTask.task._index;
+            var curve = this._gantt.options.arrowCurve;
+            var clockwise = fromIsBelowTo ? 1 : 0;
+            var curveY = fromIsBelowTo ? -curve : curve;
+            var offset = fromIsBelowTo
+                ? endY + this._gantt.options.arrowCurve
+                : endY - this._gantt.options.arrowCurve;
+            this._path = "\n            M " + startX + " " + startY + "\n            V " + offset + "\n            a " + curve + " " + curve + " 0 0 " + clockwise + " " + curve + " " + curveY + "\n            L " + endX + " " + endY + "\n            m -5 -5\n            l 5 5\n            l -5 5";
+            if (this.toTask.element.getX() < this.fromTask.element.getX() + this._gantt.options.padding) {
+                var down1 = this._gantt.options.padding / 2 - curve;
+                var down2 = this.toTask.element.getY() + this.toTask.element.getHeight() / 2 - curveY;
+                var left = this.toTask.element.getX() - this._gantt.options.padding;
+                this._path = "\n                M " + startX + " " + startY + "\n                v " + down1 + "\n                a " + curve + " " + curve + " 0 0 1 -" + curve + " " + curve + "\n                H " + left + "\n                a " + curve + " " + curve + " 0 0 " + clockwise + " -" + curve + " " + curveY + "\n                V " + down2 + "\n                a " + curve + " " + curve + " 0 0 " + clockwise + " " + curve + " " + curveY + "\n                L " + endX + " " + endY + "\n                m -5 -5\n                l 5 5\n                l -5 5";
+            }
+        };
+        Arrow.prototype.draw = function () {
+            this._element = createSVG("path", {
+                d: this._path,
+                "data-from": this.fromTask.task.id,
+                "data-to": this.toTask.task.id,
+            });
+        };
+        return Arrow;
+    }());
+
+    var defaultOptions = {
+        headerHeight: 94,
+        columnWidth: 30,
+        step: 24,
+        barHeight: 20,
+        barCornerRadius: 0,
+        arrowCurve: 4,
+        padding: 24,
+        viewMode: exports.ViewMode.Day,
+        dateFormat: "YYYY-MM-DD",
+        popupTrigger: "click",
+        customPopupHtml: null,
+        language: "en",
+    };
+
+    var Gantt = /** @class */ (function () {
+        function Gantt(wrapper, tasks, options) {
+            this.setup_wrapper(wrapper);
+            this.setup_options(options);
+            this.setup_tasks(tasks);
+            // initialize with default view mode
+            this.change_view_mode();
+            this.bind_events();
+        }
+        Object.defineProperty(Gantt.prototype, "minDate", {
+            get: function () {
+                return this._minDate;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Object.defineProperty(Gantt.prototype, "maxDate", {
+            get: function () {
+                return this._maxDate;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        Gantt.prototype.setup_wrapper = function (element) {
+            var svg_element, wrapper_element;
+            // CSS Selector is passed
+            if (typeof element === "string") {
+                element = document.querySelector(element);
+            }
+            // get the SVGElement
+            if (element instanceof HTMLElement) {
+                wrapper_element = element;
+                svg_element = element.querySelector("svg");
+            }
+            else if (element instanceof SVGElement) {
+                svg_element = element;
+            }
+            else {
+                throw new TypeError("Frappé Gantt only supports usage of a string CSS selector, HTML DOM element or SVG DOM element for the \'element\' parameter");
+            }
+            // svg element
+            if (!svg_element) {
+                // create it
+                this.$svg = createSVG("svg", {
+                    append_to: wrapper_element,
+                    class: "gantt",
+                });
+            }
+            else {
+                this.$svg = svg_element;
+                this.$svg.classList.add("gantt");
+            }
+            // wrapper element
+            this.$container = document.createElement("div");
+            this.$container.classList.add("gantt-container");
+            var parent_element = this.$svg.parentElement;
+            parent_element.appendChild(this.$container);
+            this.$container.appendChild(this.$svg);
+            // popup wrapper
+            this.popup_wrapper = document.createElement("div");
+            this.popup_wrapper.classList.add("popup-wrapper");
+            this.$container.appendChild(this.popup_wrapper);
+        };
+        Gantt.prototype.setup_options = function (options) {
+            this.options = Object.assign({}, defaultOptions, options);
+        };
+        Gantt.prototype.setup_tasks = function (tasks) {
+            // prepare tasks
+            this.tasks = tasks.map(function (task, i) {
+                //standard colors if needed
+                task.color = task.color || '#7892A1';
+                // convert to Date objects
+                task._start = DateUtils.parse(task.start);
+                task._end = DateUtils.parse(task.end);
+                // make task invalid if duration too large
+                if (DateUtils.diff(task._end, task._start, "year") > 10) {
+                    task.end = null;
+                }
+                // cache index
+                task._index = i;
+                if (typeof task._row_id === "number") {
+                    task._index = task._row_id;
+                }
+                // invalid dates
+                if (!task.start && !task.end) {
+                    var today = DateUtils.today();
+                    task._start = today;
+                    task._end = DateUtils.add(today, 2, "day");
+                }
+                if (!task.start && task.end) {
+                    task._start = DateUtils.add(task._end, -2, 'day');
+                }
+                if (task.start && !task.end) {
+                    task._end = DateUtils.add(task._start, 2, "day");
+                }
+                // if hours is not set, assume the last day is full day
+                // e.g: 2018-09-09 becomes 2018-09-09 23:59:59
+                var task_end_values = DateUtils.getDateValues(task._end);
+                if (task_end_values.slice(3).every(function (d) { return d === 0; })) {
+                    task._end = DateUtils.add(task._end, 24, "hour");
+                }
+                // invalid flag
+                if (!task.start || !task.end) {
+                    task.invalid = true;
+                }
+                // dependencies
+                if (typeof task.dependencies === "string" || !task.dependencies) {
+                    var deps = [];
+                    if (task.dependencies) {
+                        deps = task.dependencies
+                            .split(',')
+                            .map(function (d) { return d.trim(); })
+                            .filter(function (d) { return d; });
+                    }
+                    task.dependencies = deps;
+                }
+                // uids
+                if (!task.id) {
+                    task.id = generate_id(task);
+                }
+                return task;
+            });
+            this.setup_dependencies();
+        };
+        Gantt.prototype.setup_dependencies = function () {
+            var e_1, _a, e_2, _b;
+            this.dependency_map = {};
+            try {
+                for (var _c = __values(this.tasks), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var t = _d.value;
+                    try {
+                        for (var _e = (e_2 = void 0, __values(t.dependencies)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var d = _f.value;
+                            this.dependency_map[d] = this.dependency_map[d] || [];
+                            this.dependency_map[d].push(t.id);
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        };
+        Gantt.prototype.refresh = function (tasks) {
+            this.setup_tasks(tasks);
+            this.change_view_mode();
+        };
+        Gantt.prototype.change_view_mode = function (mode) {
+            if (mode === void 0) { mode = this.options.viewMode; }
+            this.update_view_scale(mode);
+            this.setup_dates();
+            this.render();
+            // fire viewmode_change event
+            this.trigger_event("onViewChange", [mode]);
+        };
+        Gantt.prototype.update_view_scale = function (view_mode) {
+            this.options.viewMode = view_mode;
+            // this.isHourView = false;
+            if (view_mode === exports.ViewMode.Hour) {
+                this.options.step = 24 / 24;
+                this.options.columnWidth = 50;
+                // this.isHourView = true;
+            }
+            else if (view_mode === exports.ViewMode.Day) {
+                this.options.step = 24;
+                this.options.columnWidth = 50;
+            }
+            else if (view_mode === exports.ViewMode.HalfDay) {
+                this.options.step = 24 / 2;
+                this.options.columnWidth = 50;
+            }
+            else if (view_mode === exports.ViewMode.QuarterDay) {
+                this.options.step = 24 / 4;
+                this.options.columnWidth = 50;
+            }
+            else if (view_mode === exports.ViewMode.Week) {
+                this.options.step = 24 * 7;
+                this.options.columnWidth = 140;
+            }
+            else if (view_mode === exports.ViewMode.Month) {
+                this.options.step = 24 * 30;
+                this.options.columnWidth = 120;
+            }
+            else if (view_mode === exports.ViewMode.Year) {
+                this.options.step = 24 * 365;
+                this.options.columnWidth = 120;
+            }
+        };
+        Gantt.prototype.setup_dates = function () {
+            this.setup_gantt_dates();
+            this.setup_date_values();
+        };
+        Gantt.prototype.setup_gantt_dates = function () {
+            var e_3, _a;
+            var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+            this._minDate = null;
+            this._maxDate = null;
+            try {
+                for (var _r = __values(this.tasks), _s = _r.next(); !_s.done; _s = _r.next()) {
+                    var task = _s.value;
+                    // set global start and end date
+                    if (!this.minDate || task.start < this.minDate) {
+                        this._minDate = task.start;
+                    }
+                    if (!this.maxDate || task.end > this.maxDate) {
+                        this._maxDate = task.end;
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_s && !_s.done && (_a = _r.return)) _a.call(_r);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            this._realMinDate = this.minDate;
+            this._realMaxDate = this.maxDate;
+            switch (this.options.viewMode) {
+                case exports.ViewMode.Hour:
+                    this._minDate = DateUtils.add(this.minDate, -((_b = this.options.marginBeforeStart) !== null && _b !== void 0 ? _b : 1), "hour");
+                    this._maxDate = DateUtils.add(this.maxDate, (_c = this.options.marginAfterEnd) !== null && _c !== void 0 ? _c : 1, "hour");
+                    break;
+                case exports.ViewMode.QuarterDay:
+                    this._minDate = DateUtils.add(this.minDate, -((_d = this.options.marginBeforeStart) !== null && _d !== void 0 ? _d : 12), "hour");
+                    this._maxDate = DateUtils.add(this.maxDate, (_e = this.options.marginAfterEnd) !== null && _e !== void 0 ? _e : 12, "hour");
+                    break;
+                case exports.ViewMode.HalfDay:
+                    this._minDate = DateUtils.add(this.minDate, -((_f = this.options.marginBeforeStart) !== null && _f !== void 0 ? _f : 1), "day");
+                    this._maxDate = DateUtils.add(this.maxDate, (_g = this.options.marginAfterEnd) !== null && _g !== void 0 ? _g : 1, "day");
+                    break;
+                case exports.ViewMode.Day:
+                    this._minDate = DateUtils.add(this.minDate, -((_h = this.options.marginBeforeStart) !== null && _h !== void 0 ? _h : 3), "day");
+                    this._maxDate = DateUtils.add(this.maxDate, (_j = this.options.marginAfterEnd) !== null && _j !== void 0 ? _j : 3, "day");
+                    break;
+                case exports.ViewMode.Week:
+                    this._minDate = DateUtils.add(this.minDate, -((_k = this.options.marginBeforeStart) !== null && _k !== void 0 ? _k : 1), "month");
+                    this._maxDate = DateUtils.add(this.maxDate, (_l = this.options.marginAfterEnd) !== null && _l !== void 0 ? _l : 1, "month");
+                    break;
+                case exports.ViewMode.Month:
+                    this._minDate = DateUtils.add(this.minDate, -((_m = this.options.marginBeforeStart) !== null && _m !== void 0 ? _m : 1), "year");
+                    this._maxDate = DateUtils.add(this.maxDate, (_o = this.options.marginAfterEnd) !== null && _o !== void 0 ? _o : 1, "year");
+                    break;
+                case exports.ViewMode.Year:
+                    this._minDate = DateUtils.add(this.minDate, -((_p = this.options.marginBeforeStart) !== null && _p !== void 0 ? _p : 2), "year");
+                    this._maxDate = DateUtils.add(this.maxDate, (_q = this.options.marginAfterEnd) !== null && _q !== void 0 ? _q : 2, "year");
+                    break;
+            }
+        };
+        Gantt.prototype.setup_date_values = function () {
+            this.dates = [];
+            var cur_date = null;
+            while (cur_date === null || cur_date < this.maxDate) {
+                if (!cur_date) {
+                    cur_date = DateUtils.clone(this.minDate);
+                }
+                else {
+                    if (this.view_is(exports.ViewMode.Year)) {
+                        cur_date = DateUtils.add(cur_date, 1, "year");
+                    }
+                    else if (this.view_is(exports.ViewMode.Month)) {
+                        cur_date = DateUtils.add(cur_date, 1, "month");
+                    }
+                    else {
+                        cur_date = DateUtils.add(cur_date, this.options.step, 'hour');
+                    }
+                }
+                this.dates.push(cur_date);
+            }
+            console.log("cur_date", cur_date);
+            console.log("dates", this.dates);
+        };
+        Gantt.prototype.bind_events = function () {
+            this.bind_grid_click();
+            this.bind_bar_events();
+        };
+        Gantt.prototype.render = function () {
+            this.clear();
+            this.setup_layers();
+            this.make_grid();
+            this.make_dates();
+            this.make_bars();
+            this.make_arrows();
+            this.map_arrows_on_bars();
+            this.set_width();
+            this.set_scroll_position();
+        };
+        Gantt.prototype.setup_layers = function () {
+            var e_4, _a;
+            this.layers = {};
+            var layers = ["grid", "date", "arrow", "progress", "bar", "details"];
+            try {
+                // make group layers
+                for (var layers_1 = __values(layers), layers_1_1 = layers_1.next(); !layers_1_1.done; layers_1_1 = layers_1.next()) {
+                    var layer = layers_1_1.value;
+                    this.layers[layer] = createSVG('g', {
+                        class: layer,
+                        append_to: this.$svg,
+                    });
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (layers_1_1 && !layers_1_1.done && (_a = layers_1.return)) _a.call(layers_1);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        };
+        Gantt.prototype.make_grid = function () {
+            this.make_grid_background();
+            this.make_grid_rows();
+            this.make_grid_header();
+            this.make_grid_highlights();
+            this.make_grid_ticks();
+        };
+        Gantt.prototype.make_grid_background = function () {
+            var grid_width = this.dates.length * this.options.columnWidth;
+            var distinct_rows = __spread(new Set(this.tasks.map(function (x) { return x._row_id; })));
+            var grid_height = this.options.headerHeight +
+                this.options.padding / 2 +
+                (this.options.barHeight + this.options.padding) *
+                    distinct_rows.length;
+            createSVG("rect", {
+                x: 0,
+                y: 0,
+                width: grid_width,
+                height: grid_height,
+                class: "grid-background",
+                append_to: this.layers.grid,
+            });
+            $.attr(this.$svg, {
+                height: grid_height,
+                width: "100%",
+            }, null);
+        };
+        Gantt.prototype.make_grid_rows = function () {
+            var _this = this;
+            var rows_layer = createSVG("g", { append_to: this.layers.grid });
+            var lines_layer = createSVG("g", { append_to: this.layers.grid });
+            var row_width = this.dates.length * this.options.columnWidth;
+            var row_height = this.options.barHeight + this.options.padding;
+            //TODO:  ajustar o posicionamento das linhas
+            var row_y = this.options.headerHeight + this.options.padding / 2;
+            this.tasks.forEach(function (_) {
+                createSVG("rect", {
+                    x: 0,
+                    y: row_y,
+                    width: row_width,
+                    height: row_height,
+                    class: "grid-row",
+                    append_to: rows_layer,
+                });
+                createSVG("line", {
+                    x1: 0,
+                    y1: row_y + row_height,
+                    x2: row_width,
+                    y2: row_y + row_height,
+                    class: "row-line",
+                    append_to: lines_layer,
+                });
+                row_y += _this.options.barHeight + _this.options.padding;
+            });
+        };
+        Gantt.prototype.make_grid_header = function () {
+            // const addIsHourView = this.isHourView ? 25 : 10
+            var header_width = this.dates.length * this.options.columnWidth;
+            var header_height = this.options.headerHeight + 10;
+            createSVG("rect", {
+                x: 0,
+                y: 0,
+                width: header_width,
+                height: header_height,
+                class: "grid-header",
+                append_to: this.layers.grid,
+            });
+        };
+        Gantt.prototype.make_grid_ticks = function () {
+            var e_5, _a;
+            var tick_x = 0;
+            var tick_y = this.options.headerHeight + this.options.padding / 2;
+            var tick_height = (this.options.barHeight + this.options.padding) *
+                this.tasks.length;
+            try {
+                for (var _b = __values(this.dates), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var date = _c.value;
+                    var tick_class = "tick";
+                    // thick tick for monday
+                    if (this.view_is(exports.ViewMode.Day) && date.getDate() === 1) {
+                        tick_class += " thick";
+                    }
+                    // thick tick for first week
+                    if (this.view_is(exports.ViewMode.Week) &&
+                        date.getDate() >= 1 &&
+                        date.getDate() < 8) {
+                        tick_class += " thick";
+                    }
+                    // thick ticks for quarters
+                    if (this.view_is(exports.ViewMode.Month) && date.getMonth() % 3 === 0) {
+                        tick_class += " thick";
+                    }
+                    createSVG("path", {
+                        d: "M " + tick_x + " " + tick_y + " v " + tick_height,
+                        class: tick_class,
+                        append_to: this.layers.grid,
+                    });
+                    if (this.view_is(exports.ViewMode.Month)) {
+                        tick_x +=
+                            (DateUtils.getDaysInMonth(date) *
+                                this.options.columnWidth) /
+                                30;
+                    }
+                    else {
+                        tick_x += this.options.columnWidth;
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        };
+        Gantt.prototype.make_grid_highlights = function () {
+            var e_6, _a;
+            if (this.view_is(exports.ViewMode.Day)) {
+                var width = this.options.columnWidth;
+                var height = (this.options.barHeight + this.options.padding) *
+                    this.tasks.length +
+                    this.options.headerHeight +
+                    this.options.padding / 2;
+                var x = 0;
+                try {
+                    for (var _b = __values(this.dates), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var date = _c.value;
+                        var y = (this.options.headerHeight + this.options.padding) / 2;
+                        var isToday = date.toString() == DateUtils.today();
+                        var isWeekend = (date.getDay() == 0 || date.getDay() == 6);
+                        var className = void 0;
+                        if (isToday) {
+                            className = "today-highlight";
+                            y = (this.options.headerHeight + this.options.padding) / 2;
+                        }
+                        else if (isWeekend) {
+                            className = "weekend-highlight";
+                        }
+                        var rx = 3;
+                        var ry = 3;
+                        if (isToday || isWeekend) {
+                            createSVG("rect", {
+                                x: x,
+                                y: y,
+                                rx: rx,
+                                ry: ry,
+                                width: width,
+                                height: height,
+                                class: className,
+                                append_to: this.layers.grid
+                            });
+                        }
+                        x += this.options.columnWidth;
+                    }
+                }
+                catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_6) throw e_6.error; }
+                }
+            }
+        };
+        Gantt.prototype.make_dates = function () {
+            var dates = this.get_dates_to_draw();
+            var isHourView = this.view_is([exports.ViewMode.Hour, exports.ViewMode.QuarterDay, exports.ViewMode.HalfDay]);
+            var counter = 0;
+            for (var i = 0; i < dates.length; i++) {
+                var date = dates[i];
+                if (isHourView && date.date >= this._realMinDate && date.date <= this._realMaxDate) {
+                    createSVG("text", {
+                        x: date.lower_x,
+                        y: date.lower_y,
+                        innerHTML: "H" + counter++ * this.options.step,
+                        class: "title-1",
+                        append_to: this.layers.date,
+                    });
+                }
+                createSVG("text", {
+                    x: date.lower_x,
+                    y: date.lower_y + 20,
+                    innerHTML: date.lower_text,
+                    class: "title-2",
+                    append_to: this.layers.date,
+                });
+                if (date.upper_text) {
+                    var $upper_text = createSVG("text", {
+                        x: date.upper_x,
+                        y: date.upper_y,
+                        innerHTML: date.upper_text,
+                        class: "upper-text",
+                        append_to: this.layers.date,
+                    });
+                    // remove out-of-bound dates
+                    if ($upper_text.getBBox().x2 > this.layers.grid.getBBox().width) {
+                        $upper_text.remove();
+                    }
+                }
+            }
+        };
+        Gantt.prototype.get_dates_to_draw = function () {
+            var _this = this;
+            var last_date = null;
+            var dates = this.dates.map(function (date, i) {
+                var d = _this.get_date_info(date, last_date, i);
+                last_date = date;
+                return d;
+            });
+            return dates;
+        };
+        Gantt.prototype.get_date_info = function (date, last_date, i) {
+            if (!last_date) {
+                last_date = DateUtils.add(date, 1, "year");
+            }
+            var date_text = {
+                hourLower: DateUtils.format(date, "HH:mm", this.options.language),
+                quarterDayLower: DateUtils.format(date, "HH:mm", this.options.language),
+                halfDayLower: DateUtils.format(date, "HH:mm", this.options.language),
+                dayLower: date.getDate() !== last_date.getDate()
+                    ? DateUtils.format(date, "D", this.options.language)
+                    : "",
+                weekLower: date.getMonth() !== last_date.getMonth()
+                    ? DateUtils.format(date, "D MMM", this.options.language)
+                    : DateUtils.format(date, "D", this.options.language),
+                monthLower: DateUtils.format(date, "MMMM", this.options.language),
+                yearLower: DateUtils.format(date, "YYYY", this.options.language),
+                quarterDayUpper: date.getDate() !== last_date.getDate()
+                    ? DateUtils.format(date, "D MMM", this.options.language)
+                    : "",
+                halfDayUpper: date.getDate() !== last_date.getDate()
+                    ? date.getMonth() !== last_date.getMonth()
+                        ? DateUtils.format(date, "D MMM", this.options.language)
+                        : DateUtils.format(date, "D", this.options.language)
+                    : "",
+                dayUpper: date.getMonth() !== last_date.getMonth()
+                    ? DateUtils.format(date, "MMMM", this.options.language)
+                    : "",
+                weekUpper: date.getMonth() !== last_date.getMonth()
+                    ? DateUtils.format(date, "MMMM", this.options.language)
+                    : "",
+                monthUpper: date.getFullYear() !== last_date.getFullYear()
+                    ? DateUtils.format(date, "YYYY", this.options.language)
+                    : "",
+                yearUpper: date.getFullYear() !== last_date.getFullYear()
+                    ? DateUtils.format(date, "YYYY", this.options.language)
+                    : "",
+                hour: date.getHours() !== last_date.getHours()
+                    ? DateUtils.format(date, "HH:mm", this.options.language)
+                    : "",
+            };
+            // Descontando 20 para adcionar uma segunda linha de informação no cabeçalho
+            var base_pos = {
+                x: i * this.options.columnWidth,
+                lower_y: this.options.headerHeight - 20,
+                upper_y: this.options.headerHeight - 20 - 25,
+            };
+            var x_pos = {
+                hourLower: this.options.columnWidth / 2,
+                hourUpper: this.options.columnWidth * 24 / 2,
+                quarterDayLower: this.options.columnWidth / 2,
+                quarterDayUpper: this.options.columnWidth * 4 / 2,
+                halfDayLower: this.options.columnWidth / 2,
+                halfDayUpper: this.options.columnWidth * 2 / 2,
+                dayLower: this.options.columnWidth / 2,
+                dayUpper: (this.options.columnWidth * 30) / 2,
+                weekLower: 0,
+                weekUpper: (this.options.columnWidth * 4) / 2,
+                monthLower: this.options.columnWidth / 2,
+                monthUpper: (this.options.columnWidth * 12) / 2,
+                yearLower: this.options.columnWidth / 2,
+                yearUpper: (this.options.columnWidth * 30) / 2,
+            };
+            return {
+                upper_text: date_text[this.options.viewMode + "Upper"],
+                lower_text: date_text[this.options.viewMode + "Lower"],
+                upper_x: base_pos.x + x_pos[this.options.viewMode + "Upper"],
+                upper_y: base_pos.upper_y,
+                lower_x: base_pos.x + x_pos[this.options.viewMode + "Lower"],
+                lower_y: base_pos.lower_y,
+                date: date,
+            };
+        };
+        Gantt.prototype.make_bars = function () {
+            var _this = this;
+            this.bars = this.tasks.map(function (task) {
+                var bar = new Bar(_this, task);
+                _this.layers.bar.appendChild(bar.group);
+                return bar;
+            });
+        };
+        Gantt.prototype.make_arrows = function () {
+            var e_7, _a;
+            var _this = this;
+            this.arrows = [];
+            var _loop_1 = function (task) {
+                var arrows = [];
+                arrows = task.dependencies
+                    .map(function (task_id) {
+                    var dependency = _this.get_task(task_id);
+                    if (!dependency)
+                        return;
+                    var arrow = new Arrow(_this, _this.bars[dependency._index], // from_task
+                    _this.bars[task._index] // to_task
+                    );
+                    _this.layers.arrow.appendChild(arrow.element);
+                    return arrow;
+                })
+                    .filter(Boolean); // filter falsy values
+                this_1.arrows = this_1.arrows.concat(arrows);
+            };
+            var this_1 = this;
+            try {
+                for (var _b = __values(this.tasks), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var task = _c.value;
+                    _loop_1(task);
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+        };
+        Gantt.prototype.map_arrows_on_bars = function () {
+            var e_8, _a;
+            var _loop_2 = function (bar) {
+                bar.arrows = this_2.arrows.filter(function (arrow) {
+                    return (arrow.fromTask.task.id === bar.task.id ||
+                        arrow.toTask.task.id === bar.task.id);
+                });
+            };
+            var this_2 = this;
+            try {
+                for (var _b = __values(this.bars), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var bar = _c.value;
+                    _loop_2(bar);
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+        };
+        Gantt.prototype.set_width = function () {
+            var cur_width = this.$svg.getBoundingClientRect().width;
+            var actual_width = this.$svg
+                .querySelector(".grid .grid-row")
+                .getAttribute("width");
+            if (cur_width < actual_width) {
+                this.$svg.setAttribute("width", actual_width);
+            }
+        };
+        Gantt.prototype.set_scroll_position = function () {
+            var parent_element = this.$svg.parentElement;
+            if (!parent_element)
+                return;
+            var hours_before_first_task = DateUtils.diff(this.get_oldest_starting_date(), this.minDate, "hour");
+            var scroll_pos = (hours_before_first_task / this.options.step) *
+                this.options.columnWidth -
+                this.options.columnWidth;
+            parent_element.scrollLeft = scroll_pos;
+        };
+        Gantt.prototype.bind_grid_click = function () {
+            var _this = this;
+            $.on(this.$svg, this.options.popupTrigger, ".grid-row, .grid-header", function () {
+                _this.unselect_all();
+                _this.hide_popup();
+            });
+        };
+        Gantt.prototype.bind_bar_events = function () {
+            var _this = this;
+            var is_dragging = false;
+            var x_on_start = 0;
+            var is_resizing_left = false;
+            var is_resizing_right = false;
+            var parent_bar_id = null;
+            var bars = [];
+            this.bar_being_dragged = null;
+            function action_in_progress() {
+                return is_dragging || is_resizing_left || is_resizing_right;
+            }
+            $.on(this.$svg, "mousedown", ".bar-wrapper, .handle", function (e, element) {
+                var bar_wrapper = $.closest(".bar-wrapper", element);
+                if (element.classList.contains("left")) {
+                    is_resizing_left = true;
+                }
+                else if (element.classList.contains("right")) {
+                    is_resizing_right = true;
+                }
+                else if (element.classList.contains("bar-wrapper")) {
+                    is_dragging = true;
+                }
+                bar_wrapper.classList.add("active");
+                x_on_start = e.offsetX;
+                parent_bar_id = bar_wrapper.getAttribute("data-id");
+                var ids = __spread([
+                    parent_bar_id
+                ], _this.get_all_dependent_tasks(parent_bar_id));
+                bars = ids.map(function (id) { return _this.get_bar(id); });
+                _this.bar_being_dragged = parent_bar_id;
+                bars.forEach(function (bar) {
+                    var $bar = bar.element;
+                    $bar.ox = $bar.getX();
+                    $bar.oy = $bar.getY();
+                    $bar.owidth = $bar.getWidth();
+                    $bar.finaldx = 0;
+                });
+            });
+            $.on(this.$svg, "mousemove", function (e) {
+                if (!action_in_progress()) {
+                    return;
+                }
+                var dx = e.offsetX - x_on_start;
+                bars.forEach(function (bar) {
+                    var $bar = bar.element;
+                    $bar.finaldx = _this.get_snap_position(dx);
+                    _this.hide_popup();
+                    if (is_resizing_left) {
+                        if (parent_bar_id === bar.task.id) {
+                            bar.updateBarPosition({
+                                x: $bar.ox + $bar.finaldx,
+                                width: $bar.owidth - $bar.finaldx,
+                            });
+                        }
+                        else {
+                            bar.updateBarPosition({
+                                x: $bar.ox + $bar.finaldx,
+                            });
+                        }
+                    }
+                    else if (is_resizing_right) {
+                        if (parent_bar_id === bar.task.id) {
+                            bar.updateBarPosition({
+                                width: $bar.owidth + $bar.finaldx,
+                            });
+                        }
+                    }
+                    else if (is_dragging) {
+                        bar.updateBarPosition({ x: $bar.ox + $bar.finaldx });
+                    }
+                });
+            }, null);
+            document.addEventListener("mouseup", function (e) {
+                if (is_dragging || is_resizing_left || is_resizing_right) {
+                    bars.forEach(function (bar) { return bar.group.classList.remove("active"); });
+                }
+                is_dragging = false;
+                is_resizing_left = false;
+                is_resizing_right = false;
+            });
+            $.on(this.$svg, "mouseup", function (e) {
+                _this.bar_being_dragged = null;
+                bars.forEach(function (bar) {
+                    var $bar = bar.element;
+                    if (!$bar.finaldx)
+                        return;
+                    bar.dateChanged();
+                    bar.setActionCompleted();
+                });
+            }, null);
+        };
+        Gantt.prototype.get_all_dependent_tasks = function (task_id) {
+            var _this = this;
+            var out = [];
+            var to_process = [task_id];
+            while (to_process.length) {
+                var deps = to_process.reduce(function (acc, curr) {
+                    acc = acc.concat(_this.dependency_map[curr]);
+                    return acc;
+                }, []);
+                out = out.concat(deps);
+                to_process = deps.filter(function (d) { return !to_process.includes(d); });
+            }
+            return out.filter(Boolean);
+        };
+        Gantt.prototype.get_snap_position = function (dx) {
+            var odx = dx, rem, position;
+            if (this.view_is(exports.ViewMode.Hour)) {
+                rem = dx % (this.options.columnWidth / 6);
+                position = odx - rem + (rem < this.options.columnWidth / 12 ? 0 : this.options.columnWidth / 6);
+            }
+            else if (this.view_is(exports.ViewMode.Week)) {
+                rem = dx % (this.options.columnWidth / 7);
+                position = odx - rem + (rem < this.options.columnWidth / 14 ? 0 : this.options.columnWidth / 7);
+            }
+            else if (this.view_is(exports.ViewMode.Month)) {
+                rem = dx % (this.options.columnWidth / 30);
+                position = odx - rem + (rem < this.options.columnWidth / 60 ? 0 : this.options.columnWidth / 30);
+            }
+            else {
+                rem = dx % this.options.columnWidth;
+                position = odx - rem + (rem < this.options.columnWidth / 2 ? 0 : this.options.columnWidth);
+            }
+            return position;
+        };
+        Gantt.prototype.unselect_all = function () {
+            __spread(this.$svg.querySelectorAll(".bar-wrapper")).forEach(function (el) {
+                el.classList.remove("active");
+            });
+        };
+        Gantt.prototype.view_is = function (modes) {
+            var _this = this;
+            if (Array.isArray(modes)) {
+                return modes.some(function (mode) { return _this.options.viewMode === mode; });
+            }
+            return this.options.viewMode === modes;
+        };
+        Gantt.prototype.get_task = function (id) {
+            return this.tasks.find(function (task) {
+                return task.id === id;
+            });
+        };
+        Gantt.prototype.get_bar = function (id) {
+            return this.bars.find(function (bar) {
+                return bar.task.id === id;
+            });
+        };
+        Gantt.prototype.show_popup = function (options) {
+            if (!this.popup) {
+                this.popup = new Popup(this.popup_wrapper, this.options.customPopupHtml);
+            }
+            this.popup.show(options);
+        };
+        Gantt.prototype.hide_popup = function () {
+            this.popup && this.popup.hide();
+        };
+        Gantt.prototype.trigger_event = function (event, args) {
+            if (this.options[event]) {
+                this.options[event].apply(null, args);
+            }
+        };
+        Gantt.prototype.get_oldest_starting_date = function () {
+            return this.tasks
+                .map(function (task) { return task._start; })
+                .reduce(function (prev_date, cur_date) {
+                return cur_date <= prev_date ? cur_date : prev_date;
+            });
+        };
+        Gantt.prototype.clear = function () {
+            this.$svg.innerHTML = '';
+        };
+        return Gantt;
+    }());
+    function generate_id(task) {
+        return task.name + "_" + Math.random().toString(36).slice(2, 12);
+    }
+
+    var GanttComponent = /** @class */ (function () {
+        function GanttComponent() {
+            this.multipleTaskPerLine = false;
+            this.showSideTable = true;
+            this.viewMode = exports.ViewMode.Day;
+            this.taskClicked = new core.EventEmitter();
+            this.taskDateChanged = new core.EventEmitter();
+            this.viewChanged = new core.EventEmitter();
+        }
+        GanttComponent.prototype.ngOnInit = function () {
+            this._validateViewMode();
+        };
+        GanttComponent.prototype.ngAfterViewInit = function () {
+            var _this = this;
+            this._gantt = new Gantt("#gantt", this._filterTask(this.tasks), {
+                viewMode: this.viewMode,
+                marginBeforeStart: this.marginBeforeStart,
+                marginAfterEnd: this.marginAfterEnd,
+                language: "pt-BR",
+                onClick: function (task) { return _this.taskClicked.emit(task); },
+                onDateChange: function (task, start, end) { return _this.taskDateChanged.emit({ task: task, start: start, end: end }); },
+                onViewChange: function (viewMode) { return _this.viewChanged.emit(viewMode); },
+            });
+        };
+        GanttComponent.prototype.ngOnChanges = function (changes) {
+            if (!this._gantt) {
+                return;
+            }
+            if (changes.viewMode) {
+                this._gantt.options.viewMode = changes.viewMode.currentValue;
+                this._gantt.change_view_mode();
+            }
+            if (changes.tasks) {
+                this._gantt.refresh(this._filterTask(changes.tasks.currentValue));
+            }
+        };
+        GanttComponent.prototype._filterTask = function (tasksGroups) {
+            var tasks = [];
+            if (this.multipleTaskPerLine) {
+                tasksGroups.forEach(function (group, index) {
+                    tasks.push.apply(tasks, __spread(group.tasks.map(function (task) {
+                        return __assign(__assign({}, task), { _row_id: index });
+                    })));
+                }, []);
+            }
+            else {
+                var i_1 = 0;
+                tasksGroups.forEach(function (group) {
+                    tasks.push.apply(tasks, __spread(group.tasks.map(function (task) {
+                        return __assign(__assign({}, task), { _row_id: i_1++ });
+                    })));
+                }, []);
+            }
+            return tasks;
+        };
+        GanttComponent.prototype._validateViewMode = function () {
+            if (![
+                exports.ViewMode.Hour,
+                exports.ViewMode.QuarterDay,
+                exports.ViewMode.HalfDay,
+                exports.ViewMode.Day,
+                exports.ViewMode.Week,
+                exports.ViewMode.Month,
+                exports.ViewMode.Year,
+            ].includes(this.viewMode)) {
+                throw new Error("Invalid gantt view mode");
+            }
+        };
+        __decorate([
+            core.Input()
+        ], GanttComponent.prototype, "columnTitle", void 0);
+        __decorate([
+            core.Input()
+        ], GanttComponent.prototype, "multipleTaskPerLine", void 0);
+        __decorate([
+            core.Input()
+        ], GanttComponent.prototype, "showSideTable", void 0);
+        __decorate([
+            core.Input()
+        ], GanttComponent.prototype, "viewMode", void 0);
+        __decorate([
+            core.Input()
+        ], GanttComponent.prototype, "tasks", void 0);
+        __decorate([
+            core.Input()
+        ], GanttComponent.prototype, "marginBeforeStart", void 0);
+        __decorate([
+            core.Input()
+        ], GanttComponent.prototype, "marginAfterEnd", void 0);
+        __decorate([
+            core.Output()
+        ], GanttComponent.prototype, "taskClicked", void 0);
+        __decorate([
+            core.Output()
+        ], GanttComponent.prototype, "taskDateChanged", void 0);
+        __decorate([
+            core.Output()
+        ], GanttComponent.prototype, "viewChanged", void 0);
+        GanttComponent = __decorate([
+            core.Component({
+                selector: "s-gantt",
+                template: "<div class=\"outer\">\n    <gantt-side-table\n        *ngIf=\"showSideTable\"\n        [tasks]=\"tasks\"\n        [columnTitle]=\"columnTitle\"\n        [multipleTaskPerLine]=\"multipleTaskPerLine\">\n    </gantt-side-table>\n    <svg id=\"gantt\"></svg>\n</div>",
+                encapsulation: core.ViewEncapsulation.None,
+                styles: [".outer{display:-ms-flexbox;display:flex;-ms-flex-pack:center;justify-content:center;-ms-flex-align:start;align-items:flex-start;-ms-flex-line-pack:center;align-content:center;-ms-flex-wrap:nowrap;flex-wrap:nowrap;-ms-flex-direction:row;flex-direction:row}", ".gantt{border:1px solid #e0e0e0}.gantt .weekend-highlight{fill:#b8c2cc;opacity:.5;stroke:#ebeff2;stroke-width:1}.gantt .grid-background{fill:none}.gantt .grid-header,.gantt .grid-row{fill:#fff}.gantt .grid-row:nth-child(even){fill:#f5f5f5}.gantt .row-line{stroke:#ebeff2}.gantt .tick{stroke:#e0e0e0;stroke-width:.2}.gantt .tick.thick{stroke-width:.4}.gantt .today-highlight{fill:#ffe979;opacity:.5}.gantt .arrow{fill:none;stroke:#666;stroke-width:1.4}.gantt .bar{opacity:.8;stroke:#8d99a6;stroke-width:0;transition:stroke-width .3s;-webkit-user-select:none;-ms-user-select:none;user-select:none}.gantt .bar-invalid{fill:transparent;stroke:#8d99a6;stroke-dasharray:5;stroke-width:1}.gantt .bar-invalid~.bar-label{fill:#555}.gantt .bar-label{fill:#fff;text-anchor:middle;font-size:12px;font-weight:lighter}.gantt .bar-label.big{fill:#555;text-anchor:start}.gantt .bar-wrapper{cursor:pointer;outline:0}.gantt .bar-wrapper.active .bar,.gantt .bar-wrapper:hover .bar{opacity:1}.gantt .bar-wrapper.active .bar{stroke:#212533;stroke-width:2}.gantt .lower-text,.gantt .upper-text{font-size:12px;text-anchor:middle}.gantt .upper-text{fill:#555}.gantt .lower-text{fill:#333}.gantt .hide{display:none}.gantt-container{border-left:1px solid #e0e0e0;font-size:12px;overflow:auto;position:relative}.gantt-container .title-1{fill:#999;font-size:12px;font-weight:400;line-height:150%;text-anchor:middle}.gantt-container .title-2{fill:#333;font-size:14px;font-weight:400;line-height:150%;text-anchor:middle}.gantt-container .popup-wrapper{left:0;position:absolute;top:0}.gantt-container .popup-wrapper .popup{background:#0e1119;border-radius:2px;color:#fff;padding:8px;font-family:\"Open Sans\" sans-serif;line-height:150%;font-weight:400}.gantt-container .popup-wrapper .popup .wrp-title{border-bottom:1px solid #525966;padding-bottom:10px}.gantt-container .popup-wrapper .popup .wrp-title .title{font-size:14px}.gantt-container .popup-wrapper .popup .wrp-subtitle{color:#dfe2e5;padding-top:10px}.gantt-container .popup-wrapper .popup .wrp-subtitle .icon{margin-right:8px}.gantt-container .popup-wrapper .popup .wrp-subtitle .subtitle{font-size:12px}.gantt-container .popup-wrapper .popup .pointer{border:6px solid transparent;border-top-color:#0e1119;height:6px;margin-left:-4px;position:absolute}"]
+            })
+        ], GanttComponent);
+        return GanttComponent;
+    }());
+
+    var SideTableComponent = /** @class */ (function () {
+        function SideTableComponent() {
+            this.ROW_HEIGHT = 44;
+            this.multipleTaskPerLine = false;
+        }
+        __decorate([
+            core.Input()
+        ], SideTableComponent.prototype, "columnTitle", void 0);
+        __decorate([
+            core.Input()
+        ], SideTableComponent.prototype, "tasks", void 0);
+        __decorate([
+            core.Input()
+        ], SideTableComponent.prototype, "multipleTaskPerLine", void 0);
+        SideTableComponent = __decorate([
+            core.Component({
+                selector: 'gantt-side-table',
+                template: "<div class=\"side-table\">\n    <div class=\"column-title\">\n        <span>{{ columnTitle }}</span>\n    </div>\n    <div class=\"tasks\">\n        <div *ngFor=\"let task of tasks; let i = index\" class=\"task\" [ngStyle]=\"{'height.px': multipleTaskPerLine\n                ? ROW_HEIGHT\n                : ROW_HEIGHT * task.tasks.length}\">\n            <div class=\"title\">\n                {{ task.title }}\n            </div>\n            <div class=\"subtitle\">\n                {{ task.subtitle }}\n            </div>\n        </div>\n    </div>\n</div>",
+                styles: [".side-table{background:#fff;height:100%;min-width:175px}.side-table .column-title{height:106px;border:1px solid #e0e0e0;box-sizing:border-box;display:-ms-flexbox;display:flex;-ms-flex-align:end;align-items:flex-end;-ms-flex-pack:center;justify-content:center;padding:8px}.side-table .column-title span{font-family:\"Open Sans\" sans-serif;font-size:14px;font-weight:700;line-height:150%}.side-table .task{-ms-flex-align:center;align-items:center;background-color:#fff;border:1px solid #e0e0e0;display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;font-family:\"Open Sans\" sans-serif;font-weight:400;-ms-flex-pack:center;justify-content:center;line-height:150%;padding:5px}.side-table .task .title{color:#333;font-size:14px}.side-table .task .subtitle{color:#999;font-size:12px}"]
+            })
+        ], SideTableComponent);
+        return SideTableComponent;
+    }());
+
+    var GanttModule = /** @class */ (function () {
+        function GanttModule() {
+        }
+        GanttModule = __decorate([
+            core.NgModule({
+                imports: [common.CommonModule],
+                declarations: [
+                    GanttComponent,
+                    SideTableComponent,
+                ],
+                exports: [GanttComponent],
+            })
+        ], GanttModule);
+        return GanttModule;
+    }());
+
     var HeaderComponent = /** @class */ (function () {
         function HeaderComponent() {
         }
@@ -11728,7 +13432,7 @@
         startCompletionResultsSearch(context);
     }
     var cancelLastCompletionSearch = function () { };
-    var ɵ0 = cancelLastCompletionSearch;
+    var ɵ0$1 = cancelLastCompletionSearch;
     var codeMirrorViewElement;
     /*
      * Starts a new completionResults's async search.
@@ -12698,6 +14402,102 @@
         return SplitButtonModule;
     }());
 
+    var SwitchComponent = /** @class */ (function () {
+        function SwitchComponent() {
+            this.readonly = false;
+            this.disabled = false;
+            this.valueChanged = new core.EventEmitter();
+            this.value = false;
+        }
+        SwitchComponent_1 = SwitchComponent;
+        SwitchComponent.prototype.onFocusIn = function () {
+            var switchElement = this.switchRef.nativeElement;
+            switchElement.classList.add("switch--focus");
+        };
+        SwitchComponent.prototype.onFocusOut = function () {
+            var switchElement = this.switchRef.nativeElement;
+            switchElement.classList.remove("switch--focus");
+        };
+        SwitchComponent.prototype.writeValue = function (value) {
+            if (!this.disabled) {
+                this.value = value;
+            }
+        };
+        SwitchComponent.prototype.registerOnChange = function (onChange) {
+            this._onChange = onChange;
+        };
+        SwitchComponent.prototype.registerOnTouched = function (onTouched) {
+            this._onTouched = onTouched;
+        };
+        SwitchComponent.prototype.setDisabledState = function (disabled) {
+            this.disabled = disabled;
+        };
+        SwitchComponent.prototype.toggleCheck = function () {
+            this.value = !this.value;
+            this.valueChanged.emit(this.value);
+            if (this._onChange) {
+                this._onChange(this.value);
+            }
+        };
+        var SwitchComponent_1;
+        __decorate([
+            core.Input()
+        ], SwitchComponent.prototype, "readonly", void 0);
+        __decorate([
+            core.Input()
+        ], SwitchComponent.prototype, "trueLabel", void 0);
+        __decorate([
+            core.Input()
+        ], SwitchComponent.prototype, "falseLabel", void 0);
+        __decorate([
+            core.Input()
+        ], SwitchComponent.prototype, "inputId", void 0);
+        __decorate([
+            core.Input()
+        ], SwitchComponent.prototype, "disabled", void 0);
+        __decorate([
+            core.Output()
+        ], SwitchComponent.prototype, "valueChanged", void 0);
+        __decorate([
+            core.Input()
+        ], SwitchComponent.prototype, "value", void 0);
+        __decorate([
+            core.ViewChild("switch", { static: true })
+        ], SwitchComponent.prototype, "switchRef", void 0);
+        __decorate([
+            core.HostListener('focusin')
+        ], SwitchComponent.prototype, "onFocusIn", null);
+        __decorate([
+            core.HostListener('focusout')
+        ], SwitchComponent.prototype, "onFocusOut", null);
+        SwitchComponent = SwitchComponent_1 = __decorate([
+            core.Component({
+                selector: 's-switch',
+                template: "<div #switch class=\"switch\" [ngClass]=\"{ 'switch--disabled': disabled }\">\n    <label class=\"switch-toggle\">\n        <input\n            #input\n            [id]=\"inputId\"\n            type=\"checkbox\"\n            [checked]=\"value\"\n            [disabled]=\"readonly || disabled\"\n            (change)=\"toggleCheck()\">\n        <span class=\"slider\"></span>\n    </label>\n    <span class=\"label\">\n        {{ value ? trueLabel : falseLabel }}\n    </span>\n</div>",
+                providers: [{
+                        provide: forms.NG_VALUE_ACCESSOR,
+                        useExisting: core.forwardRef(function () { return SwitchComponent_1; }),
+                        multi: true,
+                    }],
+                styles: [".switch{display:-ms-inline-flexbox;display:inline-flex}.switch .switch-toggle{display:inline-block;height:24px;position:relative;width:40px}.switch .switch-toggle input{height:0;opacity:0;width:0}.switch .switch-toggle input:checked+.slider{background-color:#428bca;border-radius:15px}.switch .switch-toggle input:checked+.slider:before{transform:translateX(16px)}.switch .switch-toggle .slider{background-color:#a5a5b2;border-radius:15px;bottom:0;cursor:pointer;left:0;position:absolute;right:0;top:0;transition:.4s}.switch .switch-toggle .slider:before{background-color:#fff;border-radius:50%;bottom:4px;content:\"\";height:16px;left:4px;position:absolute;transition:.4s;width:16px}.switch .label{color:#212533;font-family:\"Open Sans\" sans-serif;font-size:.875rem;font-weight:400;line-height:150%;margin-left:12px}.switch--disabled{opacity:.5}.switch--focus .switch-toggle .slider{box-shadow:0 0 0 2px #428BCA80}"]
+            })
+        ], SwitchComponent);
+        return SwitchComponent;
+    }());
+
+    var SwitchModule = /** @class */ (function () {
+        function SwitchModule() {
+        }
+        SwitchModule = __decorate([
+            core.NgModule({
+                imports: [common.CommonModule],
+                declarations: [SwitchComponent],
+                exports: [SwitchComponent],
+            })
+        ], SwitchModule);
+        return SwitchModule;
+    }());
+
     var PanelComponent = /** @class */ (function () {
         function PanelComponent() {
             this.toggleable = true;
@@ -13043,6 +14843,8 @@
     exports.FileUploadComponent = FileUploadComponent;
     exports.FileUploadModule = FileUploadModule;
     exports.FormField = FormField;
+    exports.GanttComponent = GanttComponent;
+    exports.GanttModule = GanttModule;
     exports.GlobalSearchComponent = GlobalSearchComponent;
     exports.GlobalSearchDropdownItemComponent = GlobalSearchDropdownItemComponent;
     exports.GlobalSearchModule = GlobalSearchModule;
@@ -13114,6 +14916,8 @@
     exports.StepsComponent = StepsComponent;
     exports.StepsModule = StepsModule;
     exports.Structure = Structure;
+    exports.SwitchComponent = SwitchComponent;
+    exports.SwitchModule = SwitchModule;
     exports.TableFrozenPositionDirective = TableFrozenPositionDirective;
     exports.TableHeaderCheckboxComponent = TableHeaderCheckboxComponent;
     exports.TableHeaderCheckboxModule = TableHeaderCheckboxModule;
@@ -13144,30 +14948,31 @@
     exports.ɵbe = PasswordFieldComponent;
     exports.ɵbf = SliderFieldComponent;
     exports.ɵbh = DecimalField;
-    exports.ɵbi = StructureModule;
-    exports.ɵbj = HeaderComponent;
-    exports.ɵbk = FooterComponent;
-    exports.ɵbl = NumberLocaleOptions;
-    exports.ɵbm = ThumbnailService;
-    exports.ɵbn = BorderButtonModule;
-    exports.ɵbo = BorderButtonComponent;
-    exports.ɵbp = TimelineItemModule;
-    exports.ɵbq = TimelineIconItemComponent;
-    exports.ɵbr = HorizontalTimelineModule;
-    exports.ɵbs = HorizontalTimelineComponent;
-    exports.ɵbt = VerticalTimelineModule;
-    exports.ɵbu = VerticalTimelineComponent;
-    exports.ɵbv = RangeLineComponent;
-    exports.ɵbw = CollapseOptionComponent;
-    exports.ɵbx = CollapsedItemsComponent;
-    exports.ɵby = VerticalItemsComponent;
-    exports.ɵbz = InfiniteScrollModule;
+    exports.ɵbi = SideTableComponent;
+    exports.ɵbj = StructureModule;
+    exports.ɵbk = HeaderComponent;
+    exports.ɵbl = FooterComponent;
+    exports.ɵbm = NumberLocaleOptions;
+    exports.ɵbn = ThumbnailService;
+    exports.ɵbo = BorderButtonModule;
+    exports.ɵbp = BorderButtonComponent;
+    exports.ɵbq = TimelineItemModule;
+    exports.ɵbr = TimelineIconItemComponent;
+    exports.ɵbs = HorizontalTimelineModule;
+    exports.ɵbt = HorizontalTimelineComponent;
+    exports.ɵbu = VerticalTimelineModule;
+    exports.ɵbv = VerticalTimelineComponent;
+    exports.ɵbw = RangeLineComponent;
+    exports.ɵbx = CollapseOptionComponent;
+    exports.ɵby = CollapsedItemsComponent;
+    exports.ɵbz = VerticalItemsComponent;
     exports.ɵc = CountryPhonePickerService;
-    exports.ɵca = InfiniteScrollDirective;
-    exports.ɵcb = CustomTranslationsModule;
-    exports.ɵcc = CodeEditorComponent;
-    exports.ɵcd = CoreFacade;
-    exports.ɵce = CodeMirror6Core;
+    exports.ɵca = InfiniteScrollModule;
+    exports.ɵcb = InfiniteScrollDirective;
+    exports.ɵcc = CustomTranslationsModule;
+    exports.ɵcd = CodeEditorComponent;
+    exports.ɵce = CoreFacade;
+    exports.ɵcf = CodeMirror6Core;
     exports.ɵd = LocalizedCurrencyImpurePipe;
     exports.ɵe = LocalizedBignumberPipe;
     exports.ɵf = LocalizedBignumberImpurePipe;