@worktile/gantt 12.0.1 → 12.0.2

package/bundles/worktile-gantt.umd.js

@@ -0,0 +1,3303 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common'), require('rxjs/operators'), require('rxjs'), require('date-fns'), require('@angular/cdk/coercion'), require('@angular/cdk/drag-drop'), require('html2canvas')) :
+    typeof define === 'function' && define.amd ? define('@worktile/gantt', ['exports', '@angular/core', '@angular/common', 'rxjs/operators', 'rxjs', 'date-fns', '@angular/cdk/coercion', '@angular/cdk/drag-drop', 'html2canvas'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.worktile = global.worktile || {}, global.worktile.gantt = {}), global.ng.core, global.ng.common, global.rxjs.operators, global.rxjs, global.dateFns, global.ng.cdk.coercion, global.ng.cdk.dragDrop, global.html2canvas));
+}(this, (function (exports, i0, i2, operators, rxjs, dateFns, coercion, i1, html2canvas) { 'use strict';
+
+    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+    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 i2__namespace = /*#__PURE__*/_interopNamespace(i2);
+    var i1__namespace = /*#__PURE__*/_interopNamespace(i1);
+    var html2canvas__default = /*#__PURE__*/_interopDefaultLegacy(html2canvas);
+
+    /*! *****************************************************************************
+    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 || 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;
+    }
+
+    var GanttDatePoint = /** @class */ (function () {
+        function GanttDatePoint(start, text, x, y, additions) {
+            this.start = start;
+            this.text = text;
+            this.x = x;
+            this.y = y;
+            this.additions = additions;
+        }
+        return GanttDatePoint;
+    }());
+
+    var GanttDragEvent = /** @class */ (function () {
+        function GanttDragEvent() {
+        }
+        return GanttDragEvent;
+    }());
+    var GanttTableEvent = /** @class */ (function () {
+        function GanttTableEvent() {
+        }
+        return GanttTableEvent;
+    }());
+    var GanttLinkDragEvent = /** @class */ (function () {
+        function GanttLinkDragEvent() {
+        }
+        return GanttLinkDragEvent;
+    }());
+    var GanttLoadOnScrollEvent = /** @class */ (function () {
+        function GanttLoadOnScrollEvent() {
+        }
+        return GanttLoadOnScrollEvent;
+    }());
+    var GanttLineClickEvent = /** @class */ (function () {
+        function GanttLineClickEvent() {
+        }
+        return GanttLineClickEvent;
+    }());
+    var GanttBarClickEvent = /** @class */ (function () {
+        function GanttBarClickEvent() {
+        }
+        return GanttBarClickEvent;
+    }());
+
+    var GanttDate = /** @class */ (function () {
+        function GanttDate(date) {
+            if (date) {
+                if (date instanceof Date) {
+                    this.value = date;
+                }
+                else if (typeof date === 'string' || typeof date === 'number') {
+                    if (date.toString().length < 13) {
+                        this.value = dateFns.fromUnixTime(+date);
+                    }
+                    else {
+                        this.value = new Date(date);
+                    }
+                }
+                else {
+                    throw new Error("The input date type is not supported expect Date | string\n                     | number | { date: number; with_time: 0 | 1}, actual " + JSON.stringify(date));
+                }
+            }
+            else {
+                this.value = new Date();
+            }
+        }
+        GanttDate.prototype.getYear = function () {
+            return this.value.getFullYear();
+        };
+        GanttDate.prototype.getMonth = function () {
+            return this.value.getMonth();
+        };
+        GanttDate.prototype.getDay = function () {
+            return this.value.getDay();
+        };
+        GanttDate.prototype.getTime = function () {
+            return this.value.getTime();
+        };
+        GanttDate.prototype.getDate = function () {
+            return this.value.getDate();
+        };
+        GanttDate.prototype.getHours = function () {
+            return this.value.getHours();
+        };
+        GanttDate.prototype.getMinutes = function () {
+            return this.value.getMinutes();
+        };
+        GanttDate.prototype.getSeconds = function () {
+            return this.value.getSeconds();
+        };
+        GanttDate.prototype.getMilliseconds = function () {
+            return this.value.getMilliseconds();
+        };
+        GanttDate.prototype.getWeek = function (options) {
+            if (options === void 0) { options = { weekStartsOn: 1 }; }
+            return dateFns.getWeek(this.value, options);
+        };
+        GanttDate.prototype.getDaysInMonth = function () {
+            return dateFns.getDaysInMonth(this.value);
+        };
+        GanttDate.prototype.getDaysInQuarter = function () {
+            return dateFns.differenceInCalendarDays(this.endOfQuarter().addSeconds(1).value, this.startOfQuarter().value);
+        };
+        GanttDate.prototype.getDaysInYear = function () {
+            return dateFns.differenceInCalendarDays(this.endOfYear().addSeconds(1).value, this.startOfYear().value);
+        };
+        GanttDate.prototype.setDate = function (dayOfMonth) {
+            return new GanttDate(dateFns.setDate(this.value, dayOfMonth));
+        };
+        GanttDate.prototype.clone = function () {
+            return new GanttDate(new Date(this.value));
+        };
+        GanttDate.prototype.add = function (amount, unit) {
+            switch (unit) {
+                case 'second':
+                    return new GanttDate(this.value).addSeconds(amount);
+                case 'minute':
+                    return new GanttDate(this.value).addMinutes(amount);
+                case 'hour':
+                    return new GanttDate(this.value).addHours(amount);
+                case 'day':
+                    return new GanttDate(this.value).addDays(amount);
+                case 'week':
+                    return new GanttDate(this.value).addWeeks(amount);
+                case 'month':
+                    return new GanttDate(this.value).addMonths(amount);
+                case 'quarter':
+                    return new GanttDate(this.value).addQuarters(amount);
+                case 'year':
+                    return new GanttDate(this.value).addYears(amount);
+                default:
+                    return new GanttDate(this.value).addSeconds(amount);
+            }
+        };
+        GanttDate.prototype.addSeconds = function (amount) {
+            return new GanttDate(dateFns.addSeconds(this.value, amount));
+        };
+        GanttDate.prototype.addMinutes = function (amount) {
+            return new GanttDate(dateFns.addMinutes(this.value, amount));
+        };
+        GanttDate.prototype.addHours = function (amount) {
+            return new GanttDate(dateFns.addHours(this.value, amount));
+        };
+        GanttDate.prototype.addDays = function (amount) {
+            return new GanttDate(dateFns.addDays(this.value, amount));
+        };
+        GanttDate.prototype.addWeeks = function (amount) {
+            return new GanttDate(dateFns.addWeeks(this.value, amount));
+        };
+        GanttDate.prototype.addMonths = function (amount) {
+            return new GanttDate(dateFns.addMonths(this.value, amount));
+        };
+        GanttDate.prototype.addQuarters = function (amount) {
+            return new GanttDate(dateFns.addQuarters(this.value, amount));
+        };
+        GanttDate.prototype.addYears = function (amount) {
+            return new GanttDate(dateFns.addYears(this.value, amount));
+        };
+        GanttDate.prototype.startOfDay = function () {
+            return new GanttDate(dateFns.startOfDay(this.value));
+        };
+        GanttDate.prototype.startOfWeek = function (options) {
+            return new GanttDate(dateFns.startOfWeek(this.value, options));
+        };
+        GanttDate.prototype.startOfMonth = function () {
+            return new GanttDate(dateFns.startOfMonth(this.value));
+        };
+        GanttDate.prototype.startOfQuarter = function () {
+            return new GanttDate(dateFns.startOfQuarter(this.value));
+        };
+        GanttDate.prototype.startOfYear = function () {
+            return new GanttDate(dateFns.startOfYear(this.value));
+        };
+        GanttDate.prototype.endOfDay = function () {
+            return new GanttDate(dateFns.endOfDay(this.value));
+        };
+        GanttDate.prototype.endOfWeek = function (options) {
+            return new GanttDate(dateFns.endOfWeek(this.value, options));
+        };
+        GanttDate.prototype.endOfMonth = function () {
+            return new GanttDate(dateFns.endOfMonth(this.value));
+        };
+        GanttDate.prototype.endOfQuarter = function () {
+            return new GanttDate(dateFns.endOfQuarter(this.value));
+        };
+        GanttDate.prototype.endOfYear = function () {
+            return new GanttDate(dateFns.endOfYear(this.value));
+        };
+        GanttDate.prototype.getUnixTime = function () {
+            return dateFns.getUnixTime(this.value);
+        };
+        GanttDate.prototype.format = function (mat, options) {
+            return dateFns.format(this.value, mat, options);
+        };
+        GanttDate.prototype.isWeekend = function () {
+            return dateFns.isWeekend(this.value);
+        };
+        GanttDate.prototype.isToday = function () {
+            return dateFns.isToday(this.value);
+        };
+        return GanttDate;
+    }());
+
+    exports.GanttViewType = void 0;
+    (function (GanttViewType) {
+        GanttViewType["day"] = "day";
+        GanttViewType["quarter"] = "quarter";
+        GanttViewType["month"] = "month";
+        GanttViewType["year"] = "year";
+        GanttViewType["week"] = "week";
+    })(exports.GanttViewType || (exports.GanttViewType = {}));
+
+    exports.GanttItemType = void 0;
+    (function (GanttItemType) {
+        GanttItemType["bar"] = "bar";
+        GanttItemType["range"] = "range";
+        GanttItemType["custom"] = "custom";
+    })(exports.GanttItemType || (exports.GanttItemType = {}));
+    var GanttItemInternal = /** @class */ (function () {
+        function GanttItemInternal(item, options) {
+            var _this = this;
+            this.refs$ = new rxjs.BehaviorSubject(null);
+            this.origin = item;
+            this.id = this.origin.id;
+            this.links = this.origin.links || [];
+            this.color = this.origin.color;
+            this.barStyle = this.origin.barStyle;
+            this.linkable = this.origin.linkable === undefined ? true : this.origin.linkable;
+            this.draggable = this.origin.draggable === undefined ? true : this.origin.draggable;
+            this.expandable = this.origin.expandable || (this.origin.children || []).length > 0;
+            this.expanded = this.origin.expanded === undefined ? false : this.origin.expanded;
+            this.start = item.start ? new GanttDate(item.start) : null;
+            this.end = item.end ? new GanttDate(item.end) : null;
+            this.viewType = options && options.viewType ? options.viewType : exports.GanttViewType.month;
+            this.children = (item.children || []).map(function (subItem) {
+                return new GanttItemInternal(subItem, { viewType: _this.viewType });
+            });
+            this.type = this.origin.type || exports.GanttItemType.bar;
+            this.progress = this.origin.progress;
+            // fill one month when start or end is null
+            this.fillItemStartOrEnd(item);
+        }
+        Object.defineProperty(GanttItemInternal.prototype, "refs", {
+            get: function () {
+                return this.refs$.getValue();
+            },
+            enumerable: false,
+            configurable: true
+        });
+        GanttItemInternal.prototype.fillItemStartOrEnd = function (item) {
+            var addInterval;
+            switch (this.viewType) {
+                case exports.GanttViewType.day:
+                case exports.GanttViewType.week:
+                    addInterval = 0;
+                    break;
+                default:
+                    addInterval = 30;
+                    break;
+            }
+            if (item.start && !item.end) {
+                this.end = new GanttDate(item.start).addDays(addInterval).endOfDay();
+            }
+            if (!item.start && item.end) {
+                this.start = new GanttDate(item.end).addDays(-addInterval).startOfDay();
+            }
+        };
+        GanttItemInternal.prototype.updateRefs = function (refs) {
+            this.refs$.next(refs);
+        };
+        GanttItemInternal.prototype.updateDate = function (start, end) {
+            this.start = start.startOfDay();
+            this.end = end.endOfDay();
+            this.origin.start = this.start.getUnixTime();
+            this.origin.end = this.end.getUnixTime();
+        };
+        GanttItemInternal.prototype.addChildren = function (items) {
+            var _this = this;
+            this.origin.children = items;
+            this.children = (items || []).map(function (subItem) {
+                return new GanttItemInternal(subItem, { viewType: _this.viewType });
+            });
+        };
+        GanttItemInternal.prototype.setExpand = function (expanded) {
+            this.expanded = expanded;
+            this.origin.expanded = expanded;
+        };
+        GanttItemInternal.prototype.addLink = function (linkId) {
+            this.links = __spreadArray(__spreadArray([], __read(this.links)), [linkId]);
+            this.origin.links = this.links;
+        };
+        return GanttItemInternal;
+    }());
+
+    var GanttGroupInternal = /** @class */ (function () {
+        function GanttGroupInternal(group) {
+            this.refs = {};
+            this.id = group.id;
+            this.origin = group;
+            this.title = group.title;
+            this.expanded = group.expanded === undefined ? true : group.expanded;
+            this.items = [];
+            this.mergedItems = [[]];
+            this.class = group.class || '';
+        }
+        GanttGroupInternal.prototype.setExpand = function (expanded) {
+            this.expanded = expanded;
+            this.origin.expanded = expanded;
+        };
+        return GanttGroupInternal;
+    }());
+
+    var primaryDatePointTop = 18;
+    var secondaryDatePointTop = 36;
+    var viewOptions$5 = {
+        min: new GanttDate().addYears(-1).startOfYear(),
+        max: new GanttDate().addYears(1).endOfYear()
+    };
+    var GanttView = /** @class */ (function () {
+        function GanttView(start, end, options) {
+            this.showTimeline = true;
+            this.options = Object.assign({}, viewOptions$5, options);
+            var startDate = start.isCustom
+                ? this.startOf(start.date)
+                : this.startOf(start.date.value < this.options.start.value ? start.date : this.options.start);
+            var endDate = end.isCustom
+                ? this.endOf(end.date)
+                : this.endOf(end.date.value > this.options.end.value ? end.date : this.options.end);
+            this.start$ = new rxjs.BehaviorSubject(startDate);
+            this.end$ = new rxjs.BehaviorSubject(endDate);
+            this.initialize();
+        }
+        Object.defineProperty(GanttView.prototype, "start", {
+            get: function () {
+                return this.start$.getValue();
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(GanttView.prototype, "end", {
+            get: function () {
+                return this.end$.getValue();
+            },
+            enumerable: false,
+            configurable: true
+        });
+        GanttView.prototype.getDateIntervalWidth = function (start, end) {
+            var result = 0;
+            var days = dateFns.differenceInDays(end.value, start.value);
+            for (var i = 0; i < Math.abs(days); i++) {
+                result += this.getDayOccupancyWidth(start.addDays(i));
+            }
+            result = days >= 0 ? result : -result;
+            return Number(result.toFixed(3));
+        };
+        GanttView.prototype.initialize = function () {
+            this.primaryDatePoints = this.getPrimaryDatePoints();
+            this.secondaryDatePoints = this.getSecondaryDatePoints();
+            this.width = this.getWidth();
+            this.cellWidth = this.getCellWidth();
+            this.primaryWidth = this.getPrimaryWidth();
+        };
+        GanttView.prototype.addStartDate = function () {
+            var start = this.startOf(this.start.add(this.options.addAmount * -1, this.options.addUnit));
+            if (start.value >= this.options.min.value) {
+                var origin = this.start;
+                this.start$.next(start);
+                this.initialize();
+                return { start: this.start, end: origin };
+            }
+            return null;
+        };
+        GanttView.prototype.addEndDate = function () {
+            var end = this.endOf(this.end.add(this.options.addAmount, this.options.addUnit));
+            if (end.value <= this.options.max.value) {
+                var origin = this.end;
+                this.end$.next(end);
+                this.initialize();
+                return { start: origin, end: this.end };
+            }
+            return null;
+        };
+        GanttView.prototype.updateDate = function (start, end) {
+            start = this.startOf(start);
+            end = this.endOf(end);
+            if (start.value < this.start.value) {
+                this.start$.next(start);
+            }
+            if (end.value > this.end.value) {
+                this.end$.next(end);
+            }
+            this.initialize();
+        };
+        // 获取View的宽度
+        GanttView.prototype.getWidth = function () {
+            return this.getCellWidth() * this.secondaryDatePoints.length;
+        };
+        // 获取单个网格的宽度
+        GanttView.prototype.getCellWidth = function () {
+            return this.options.cellWidth;
+        };
+        // 获取当前时间的X坐标
+        GanttView.prototype.getTodayXPoint = function () {
+            var toady = new GanttDate().startOfDay();
+            if (toady.value > this.start.value && toady.value < this.end.value) {
+                var x = this.getXPointByDate(toady) + this.getDayOccupancyWidth(toady) / 2;
+                return x;
+            }
+            else {
+                return null;
+            }
+        };
+        // 获取指定时间的X坐标
+        GanttView.prototype.getXPointByDate = function (date) {
+            return this.getDateIntervalWidth(this.start, date);
+        };
+        // 根据X坐标获取对应时间
+        GanttView.prototype.getDateByXPoint = function (x) {
+            var indexOfSecondaryDate = Math.floor(x / this.getCellWidth());
+            var matchDate = this.secondaryDatePoints[indexOfSecondaryDate];
+            var dayWidth = this.getDayOccupancyWidth(matchDate === null || matchDate === void 0 ? void 0 : matchDate.start);
+            if (dayWidth === this.getCellWidth()) {
+                return matchDate === null || matchDate === void 0 ? void 0 : matchDate.start;
+            }
+            else {
+                var day = Math.floor((x % this.getCellWidth()) / dayWidth) + 1;
+                if (this.getCellWidth() / dayWidth === 7) {
+                    return matchDate === null || matchDate === void 0 ? void 0 : matchDate.start.addDays(day);
+                }
+                return matchDate === null || matchDate === void 0 ? void 0 : matchDate.start.setDate(day);
+            }
+        };
+        // 获取指定时间范围的宽度
+        GanttView.prototype.getDateRangeWidth = function (start, end) {
+            // addSeconds(1) 是因为计算相差天会以一个整天来计算 end时间一般是59分59秒不是一个整天，所以需要加1
+            return this.getDateIntervalWidth(start, end.addSeconds(1));
+        };
+        return GanttView;
+    }());
+
+    var viewOptions$4 = {
+        start: new GanttDate().startOfQuarter().addQuarters(-1),
+        end: new GanttDate().endOfQuarter().addQuarters(2),
+        cellWidth: 280,
+        addAmount: 1,
+        addUnit: 'quarter'
+    };
+    var GanttViewMonth = /** @class */ (function (_super) {
+        __extends(GanttViewMonth, _super);
+        function GanttViewMonth(start, end, options) {
+            return _super.call(this, start, end, Object.assign({}, viewOptions$4, options)) || this;
+        }
+        GanttViewMonth.prototype.startOf = function (date) {
+            return date.startOfQuarter();
+        };
+        GanttViewMonth.prototype.endOf = function (date) {
+            return date.endOfQuarter();
+        };
+        GanttViewMonth.prototype.getPrimaryWidth = function () {
+            return this.getCellWidth() * 3;
+        };
+        GanttViewMonth.prototype.getDayOccupancyWidth = function (date) {
+            return this.cellWidth / date.getDaysInMonth();
+        };
+        GanttViewMonth.prototype.getPrimaryDatePoints = function () {
+            var quarters = dateFns.differenceInCalendarQuarters(this.end.addSeconds(1).value, this.start.value);
+            var points = [];
+            for (var i = 0; i < quarters; i++) {
+                var start = this.start.addQuarters(i);
+                var point = new GanttDatePoint(start, start.format('yyyy年QQQ'), (this.getCellWidth() * 3) / 2 + i * (this.getCellWidth() * 3), primaryDatePointTop);
+                points.push(point);
+            }
+            return points;
+        };
+        GanttViewMonth.prototype.getSecondaryDatePoints = function () {
+            var months = dateFns.eachMonthOfInterval({ start: this.start.value, end: this.end.value });
+            var points = [];
+            for (var i = 0; i < months.length; i++) {
+                var start = new GanttDate(months[i]);
+                var point = new GanttDatePoint(start, start.getMonth() + 1 + "\u6708", i * this.getCellWidth() + this.getCellWidth() / 2, secondaryDatePointTop);
+                points.push(point);
+            }
+            return points;
+        };
+        return GanttViewMonth;
+    }(GanttView));
+
+    var viewOptions$3 = {
+        start: new GanttDate().addYears(-1).startOfYear(),
+        end: new GanttDate().addYears(1).endOfYear(),
+        min: new GanttDate().addYears(-2).startOfYear(),
+        max: new GanttDate().addYears(2).endOfYear(),
+        cellWidth: 500,
+        addAmount: 1,
+        addUnit: 'year'
+    };
+    var GanttViewQuarter = /** @class */ (function (_super) {
+        __extends(GanttViewQuarter, _super);
+        function GanttViewQuarter(start, end, options) {
+            return _super.call(this, start, end, Object.assign({}, viewOptions$3, options)) || this;
+        }
+        GanttViewQuarter.prototype.startOf = function (date) {
+            return date.startOfYear();
+        };
+        GanttViewQuarter.prototype.endOf = function (date) {
+            return date.endOfYear();
+        };
+        GanttViewQuarter.prototype.getPrimaryWidth = function () {
+            return this.getCellWidth() * 4;
+        };
+        GanttViewQuarter.prototype.getDayOccupancyWidth = function (date) {
+            return this.cellWidth / date.getDaysInQuarter();
+        };
+        GanttViewQuarter.prototype.getPrimaryDatePoints = function () {
+            var years = dateFns.eachYearOfInterval({ start: this.start.value, end: this.end.value });
+            var points = [];
+            for (var i = 0; i < years.length; i++) {
+                var start = new GanttDate(years[i]);
+                var point = new GanttDatePoint(start, start.format('yyyy') + "\u5E74", (this.getCellWidth() * 4) / 2 + i * (this.getCellWidth() * 4), primaryDatePointTop);
+                points.push(point);
+            }
+            return points;
+        };
+        GanttViewQuarter.prototype.getSecondaryDatePoints = function () {
+            var quarters = dateFns.differenceInCalendarQuarters(this.end.value, this.start.value);
+            var points = [];
+            for (var i = 0; i <= quarters; i++) {
+                var start = this.start.addQuarters(i);
+                var point = new GanttDatePoint(start, start.format('QQQ'), i * this.getCellWidth() + this.getCellWidth() / 2, secondaryDatePointTop);
+                points.push(point);
+            }
+            return points;
+        };
+        return GanttViewQuarter;
+    }(GanttView));
+
+    var viewOptions$2 = {
+        cellWidth: 35,
+        start: new GanttDate().startOfYear().startOfWeek({ weekStartsOn: 1 }),
+        end: new GanttDate().endOfYear().endOfWeek({ weekStartsOn: 1 }),
+        addAmount: 1,
+        addUnit: 'month'
+    };
+    var GanttViewDay = /** @class */ (function (_super) {
+        __extends(GanttViewDay, _super);
+        function GanttViewDay(start, end, options) {
+            var _this = _super.call(this, start, end, Object.assign({}, viewOptions$2, options)) || this;
+            _this.showWeekBackdrop = true;
+            _this.showTimeline = false;
+            return _this;
+        }
+        GanttViewDay.prototype.startOf = function (date) {
+            return date.startOfWeek({ weekStartsOn: 1 });
+        };
+        GanttViewDay.prototype.endOf = function (date) {
+            return date.endOfWeek({ weekStartsOn: 1 });
+        };
+        GanttViewDay.prototype.getPrimaryWidth = function () {
+            return this.getCellWidth() * 7;
+        };
+        GanttViewDay.prototype.getDayOccupancyWidth = function () {
+            return this.cellWidth;
+        };
+        GanttViewDay.prototype.getPrimaryDatePoints = function () {
+            var weeks = dateFns.eachWeekOfInterval({ start: this.start.value, end: this.end.addSeconds(1).value }, { weekStartsOn: 1 });
+            var points = [];
+            for (var i = 0; i < weeks.length; i++) {
+                var weekStart = new GanttDate(weeks[i]);
+                var increaseWeek = weekStart.getDaysInMonth() - weekStart.getDate() >= 3 ? 0 : 1;
+                var point = new GanttDatePoint(weekStart, weekStart.addWeeks(increaseWeek).format('yyyy年MM月'), (this.getCellWidth() * 7) / 2 + i * (this.getCellWidth() * 7), primaryDatePointTop);
+                points.push(point);
+            }
+            return points;
+        };
+        GanttViewDay.prototype.getSecondaryDatePoints = function () {
+            var days = dateFns.eachDayOfInterval({ start: this.start.value, end: this.end.value });
+            var points = [];
+            for (var i = 0; i < days.length; i++) {
+                var start = new GanttDate(days[i]);
+                var point = new GanttDatePoint(start, start.getDate().toString(), i * this.getCellWidth() + this.getCellWidth() / 2, secondaryDatePointTop, {
+                    isWeekend: start.isWeekend(),
+                    isToday: start.isToday()
+                });
+                points.push(point);
+            }
+            return points;
+        };
+        return GanttViewDay;
+    }(GanttView));
+
+    var viewOptions$1 = {
+        cellWidth: 280,
+        start: new GanttDate().startOfYear().startOfWeek({ weekStartsOn: 1 }),
+        end: new GanttDate().endOfYear().endOfWeek({ weekStartsOn: 1 }),
+        addAmount: 1,
+        addUnit: 'month'
+    };
+    var GanttViewWeek = /** @class */ (function (_super) {
+        __extends(GanttViewWeek, _super);
+        function GanttViewWeek(start, end, options) {
+            return _super.call(this, start, end, Object.assign({}, viewOptions$1, options)) || this;
+        }
+        GanttViewWeek.prototype.startOf = function (date) {
+            return date.startOfWeek({ weekStartsOn: 1 });
+        };
+        GanttViewWeek.prototype.endOf = function (date) {
+            return date.endOfWeek({ weekStartsOn: 1 });
+        };
+        GanttViewWeek.prototype.getPrimaryWidth = function () {
+            return this.getCellWidth();
+        };
+        GanttViewWeek.prototype.getDayOccupancyWidth = function () {
+            return this.cellWidth / 7;
+        };
+        GanttViewWeek.prototype.getPrimaryDatePoints = function () {
+            var weeks = dateFns.eachWeekOfInterval({ start: this.start.value, end: this.end.addSeconds(1).value }, { weekStartsOn: 1 });
+            var points = [];
+            for (var i = 0; i < weeks.length; i++) {
+                var weekStart = new GanttDate(weeks[i]);
+                var increaseWeek = weekStart.getDaysInMonth() - weekStart.getDate() >= 3 ? 0 : 1;
+                var point = new GanttDatePoint(weekStart, weekStart.addWeeks(increaseWeek).format('yyyy年'), this.getCellWidth() / 2 + i * this.getCellWidth(), primaryDatePointTop);
+                points.push(point);
+            }
+            return points;
+        };
+        GanttViewWeek.prototype.getSecondaryDatePoints = function () {
+            var weeks = dateFns.eachWeekOfInterval({ start: this.start.value, end: this.end.value });
+            var points = [];
+            for (var i = 0; i < weeks.length; i++) {
+                var start = new GanttDate(weeks[i]);
+                var point = new GanttDatePoint(start, "\u7B2C" + start.format('w') + "\u5468", i * this.getCellWidth() + this.getCellWidth() / 2, secondaryDatePointTop);
+                points.push(point);
+            }
+            return points;
+        };
+        return GanttViewWeek;
+    }(GanttView));
+
+    var viewOptions = {
+        cellWidth: 480,
+        start: new GanttDate().addYears(-2).startOfYear(),
+        end: new GanttDate().addYears(2).endOfYear(),
+        addAmount: 1,
+        addUnit: 'year'
+    };
+    var GanttViewYear = /** @class */ (function (_super) {
+        __extends(GanttViewYear, _super);
+        function GanttViewYear(start, end, options) {
+            return _super.call(this, start, end, Object.assign({}, viewOptions, options)) || this;
+        }
+        GanttViewYear.prototype.startOf = function (date) {
+            return date.startOfYear();
+        };
+        GanttViewYear.prototype.endOf = function (date) {
+            return date.endOfYear();
+        };
+        GanttViewYear.prototype.getPrimaryWidth = function () {
+            return this.getCellWidth();
+        };
+        GanttViewYear.prototype.getDayOccupancyWidth = function (date) {
+            return this.cellWidth / date.getDaysInYear();
+        };
+        GanttViewYear.prototype.getPrimaryDatePoints = function () {
+            var years = dateFns.eachYearOfInterval({ start: this.start.value, end: this.end.value });
+            var points = [];
+            for (var i = 0; i < years.length; i++) {
+                var start = new GanttDate(years[i]);
+                var point = new GanttDatePoint(start, "", this.getCellWidth() / 2 + i * this.getCellWidth(), primaryDatePointTop);
+                points.push(point);
+            }
+            return points;
+        };
+        GanttViewYear.prototype.getSecondaryDatePoints = function () {
+            var years = dateFns.differenceInCalendarYears(this.end.value, this.start.value);
+            var points = [];
+            var pointTop = 27;
+            for (var i = 0; i <= years; i++) {
+                var start = this.start.addYears(i);
+                var point = new GanttDatePoint(start, start.format('yyyy') + "\u5E74", i * this.getCellWidth() + this.getCellWidth() / 2, pointTop);
+                points.push(point);
+            }
+            return points;
+        };
+        return GanttViewYear;
+    }(GanttView));
+
+    function createViewFactory(type, start, end, options) {
+        switch (type) {
+            case exports.GanttViewType.month:
+                return new GanttViewMonth(start, end, options);
+            case exports.GanttViewType.week:
+                return new GanttViewWeek(start, end, options);
+            case exports.GanttViewType.quarter:
+                return new GanttViewQuarter(start, end, options);
+            case exports.GanttViewType.day:
+                return new GanttViewDay(start, end, options);
+            case exports.GanttViewType.year:
+                return new GanttViewYear(start, end, options);
+            default:
+                throw new Error('gantt view type invalid');
+        }
+    }
+
+    var defaultStyles = {
+        lineHeight: 44,
+        barHeight: 22
+    };
+    var headerHeight = 44;
+    var sideWidth = 400;
+    var sideMiddleWidth = 500;
+    var sideMaxWidth = 600;
+    var sideMinWidth = 400;
+    var barBackground = '#348fe4';
+    var rangeHeight = 17;
+    var todayHeight = 24;
+    var todayWidth = 35;
+    var todayBorderRadius = 4;
+
+    function isNumber(value) {
+        return typeof value === 'number';
+    }
+    function isString(value) {
+        return typeof value === 'string';
+    }
+    function isUndefined(value) {
+        return value === undefined;
+    }
+    function hexToRgb(color, opacity) {
+        if (opacity === void 0) { opacity = 1; }
+        if (/^#/g.test(color)) {
+            return "rgba(" + parseInt(color.slice(1, 3), 16) + "," + parseInt(color.slice(3, 5), 16) + "," + parseInt(color.slice(5, 7), 16) + "," + opacity + ")";
+        }
+        else {
+            return color;
+        }
+    }
+    function uniqBy(array, key) {
+        var valuesMap = {};
+        var result = [];
+        (array || []).forEach(function (value) {
+            var _key = value[key];
+            if (!valuesMap[_key]) {
+                valuesMap[_key] = value;
+                result.push(value);
+            }
+        });
+        return result;
+    }
+    function flatten(array) {
+        return array.reduce(function (pre, cur) {
+            return pre.concat(Array.isArray(cur) ? flatten(cur) : cur);
+        }, []);
+    }
+    function recursiveItems(items) {
+        var result = [];
+        (items || []).forEach(function (item) {
+            result.push(item);
+            if (item.expanded && item.children) {
+                result.push.apply(result, __spreadArray([], __read(recursiveItems(item.children))));
+            }
+        });
+        return result;
+    }
+    function getFlatItems(items) {
+        var result = [];
+        (items || []).forEach(function (item) {
+            result.push(item);
+            if (item.children) {
+                result.push.apply(result, __spreadArray([], __read(getFlatItems(item.children))));
+            }
+        });
+        return result;
+    }
+
+    var GanttUpper = /** @class */ (function () {
+        function GanttUpper(elementRef, cdr, ngZone) {
+            this.elementRef = elementRef;
+            this.cdr = cdr;
+            this.ngZone = ngZone;
+            this.originItems = [];
+            this.originGroups = [];
+            this.viewType = exports.GanttViewType.month;
+            this.showTodayLine = true;
+            this.loadOnScroll = new i0.EventEmitter();
+            this.dragStarted = new i0.EventEmitter();
+            this.dragEnded = new i0.EventEmitter();
+            this.barClick = new i0.EventEmitter();
+            this.linkDragEnded = new i0.EventEmitter();
+            this.items = [];
+            this.groups = [];
+            this.viewChange = new i0.EventEmitter();
+            this.expandChange = new i0.EventEmitter();
+            this.firstChange = true;
+            this.unsubscribe$ = new rxjs.Subject();
+            this.ganttClass = true;
+        }
+        Object.defineProperty(GanttUpper.prototype, "element", {
+            get: function () {
+                return this.elementRef.nativeElement;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        GanttUpper.prototype.createView = function () {
+            var viewDate = this.getViewDate();
+            this.view = createViewFactory(this.viewType, viewDate.start, viewDate.end, this.viewOptions);
+        };
+        GanttUpper.prototype.setupGroups = function () {
+            var _this = this;
+            var collapsedIds = this.groups.filter(function (group) { return group.expanded === false; }).map(function (group) { return group.id; });
+            this.groupsMap = {};
+            this.groups = [];
+            this.originGroups.forEach(function (origin) {
+                var group = new GanttGroupInternal(origin);
+                group.expanded = !collapsedIds.includes(group.id);
+                _this.groupsMap[group.id] = group;
+                _this.groups.push(group);
+            });
+        };
+        GanttUpper.prototype.setupItems = function () {
+            var _this = this;
+            this.originItems = uniqBy(this.originItems, 'id');
+            this.items = [];
+            if (this.groups.length > 0) {
+                this.originItems.forEach(function (origin) {
+                    var group = _this.groupsMap[origin.group_id];
+                    if (group) {
+                        var item = new GanttItemInternal(origin, { viewType: _this.viewType });
+                        group.items.push(item);
+                    }
+                });
+            }
+            else {
+                this.originItems.forEach(function (origin) {
+                    var item = new GanttItemInternal(origin, { viewType: _this.viewType });
+                    _this.items.push(item);
+                });
+            }
+        };
+        GanttUpper.prototype.setupExpandedState = function () {
+            this.originItems = uniqBy(this.originItems, 'id');
+            var items = [];
+            var flatOriginItems = getFlatItems(this.originItems);
+            if (this.items.length > 0) {
+                items = recursiveItems(this.items);
+            }
+            else {
+                items = flatten(this.groups.map(function (group) { return recursiveItems(group.items); }));
+            }
+            items.forEach(function (item) {
+                if (item.origin.expanded) {
+                    var newItem = flatOriginItems.find(function (originItem) { return originItem.id === item.id; });
+                    if (newItem) {
+                        if (newItem.expanded === undefined) {
+                            newItem.expanded = true;
+                        }
+                    }
+                }
+            });
+        };
+        GanttUpper.prototype.getViewDate = function () {
+            var _this = this;
+            var start = this.start;
+            var end = this.end;
+            if (!this.start || !this.end) {
+                this.originItems.forEach(function (item) {
+                    if (item.start && !_this.start) {
+                        start = start ? Math.min(start, item.start) : item.start;
+                    }
+                    if (item.end && !_this.end) {
+                        end = end ? Math.max(end, item.end) : item.end;
+                    }
+                });
+            }
+            return {
+                start: {
+                    date: new GanttDate(start),
+                    isCustom: this.start ? true : false
+                },
+                end: {
+                    date: new GanttDate(end),
+                    isCustom: this.end ? true : false
+                }
+            };
+        };
+        GanttUpper.prototype.computeRefs = function () {
+            var _this = this;
+            this.groups.forEach(function (group) {
+                var groupItems = recursiveItems(group.items);
+                _this.computeItemsRefs.apply(_this, __spreadArray([], __read(groupItems)));
+            });
+            var items = recursiveItems(this.items);
+            this.computeItemsRefs.apply(this, __spreadArray([], __read(items)));
+        };
+        GanttUpper.prototype.expandGroups = function (expanded) {
+            this.groups.forEach(function (group) {
+                group.setExpand(expanded);
+            });
+            this.expandChange.next();
+            this.cdr.detectChanges();
+        };
+        GanttUpper.prototype.onInit = function () {
+            var _this = this;
+            this.styles = Object.assign({}, defaultStyles, this.styles);
+            this.createView();
+            this.setupGroups();
+            this.setupItems();
+            this.computeRefs();
+            this.firstChange = false;
+            this.ngZone.onStable.pipe(operators.take(1)).subscribe(function () {
+                _this.element.style.opacity = '1';
+                _this.dragContainer.dragStarted.subscribe(function (event) {
+                    _this.dragStarted.emit(event);
+                });
+                _this.dragContainer.dragEnded.subscribe(function (event) {
+                    _this.dragEnded.emit(event);
+                    _this.computeRefs();
+                    _this.detectChanges();
+                });
+            });
+            this.view.start$.pipe(operators.skip(1), operators.takeUntil(this.unsubscribe$)).subscribe(function () {
+                _this.computeRefs();
+            });
+        };
+        GanttUpper.prototype.onChanges = function (changes) {
+            if (!this.firstChange) {
+                if (changes.viewType && changes.viewType.currentValue) {
+                    this.createView();
+                    this.setupGroups();
+                    this.setupItems();
+                    this.computeRefs();
+                    this.viewChange.emit(this.view);
+                }
+                if (changes.originItems || changes.originGroups) {
+                    this.setupExpandedState();
+                    this.setupGroups();
+                    this.setupItems();
+                    this.computeRefs();
+                }
+            }
+        };
+        GanttUpper.prototype.onDestroy = function () {
+            this.unsubscribe$.next();
+            this.unsubscribe$.complete();
+        };
+        GanttUpper.prototype.computeItemsRefs = function () {
+            var _this = this;
+            var items = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                items[_i] = arguments[_i];
+            }
+            items.forEach(function (item) {
+                item.updateRefs({
+                    width: item.start && item.end ? _this.view.getDateRangeWidth(item.start.startOfDay(), item.end.endOfDay()) : 0,
+                    x: item.start ? _this.view.getXPointByDate(item.start) : 0,
+                    y: (_this.styles.lineHeight - _this.styles.barHeight) / 2 - 1
+                });
+            });
+        };
+        GanttUpper.prototype.trackBy = function (item, index) {
+            return item.id || index;
+        };
+        GanttUpper.prototype.detectChanges = function () {
+            this.cdr.detectChanges();
+        };
+        GanttUpper.prototype.expandGroup = function (group) {
+            group.setExpand(!group.expanded);
+            this.expandChange.emit();
+            this.cdr.detectChanges();
+        };
+        // public functions
+        GanttUpper.prototype.expandAll = function () {
+            this.expandGroups(true);
+        };
+        GanttUpper.prototype.collapseAll = function () {
+            this.expandGroups(false);
+        };
+        return GanttUpper;
+    }());
+    GanttUpper.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttUpper, deps: [{ token: i0__namespace.ElementRef }, { token: i0__namespace.ChangeDetectorRef }, { token: i0__namespace.NgZone }], target: i0__namespace.ɵɵFactoryTarget.Directive });
+    GanttUpper.ɵdir = i0__namespace.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.1.2", type: GanttUpper, inputs: { originItems: ["items", "originItems"], originGroups: ["groups", "originGroups"], viewType: "viewType", start: "start", end: "end", showTodayLine: "showTodayLine", draggable: "draggable", styles: "styles", viewOptions: "viewOptions", disabledLoadOnScroll: "disabledLoadOnScroll" }, outputs: { loadOnScroll: "loadOnScroll", dragStarted: "dragStarted", dragEnded: "dragEnded", barClick: "barClick" }, host: { properties: { "class.gantt": "this.ganttClass" } }, queries: [{ propertyName: "barTemplate", first: true, predicate: ["bar"], descendants: true, static: true }, { propertyName: "rangeTemplate", first: true, predicate: ["range"], descendants: true, static: true }, { propertyName: "itemTemplate", first: true, predicate: ["item"], descendants: true, static: true }, { propertyName: "groupTemplate", first: true, predicate: ["group"], descendants: true, static: true }, { propertyName: "groupHeaderTemplate", first: true, predicate: ["groupHeader"], descendants: true, static: true }], ngImport: i0__namespace });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttUpper, decorators: [{
+                type: i0.Directive
+            }], ctorParameters: function () { return [{ type: i0__namespace.ElementRef }, { type: i0__namespace.ChangeDetectorRef }, { type: i0__namespace.NgZone }]; }, propDecorators: { originItems: [{
+                    type: i0.Input,
+                    args: ['items']
+                }], originGroups: [{
+                    type: i0.Input,
+                    args: ['groups']
+                }], viewType: [{
+                    type: i0.Input
+                }], start: [{
+                    type: i0.Input
+                }], end: [{
+                    type: i0.Input
+                }], showTodayLine: [{
+                    type: i0.Input
+                }], draggable: [{
+                    type: i0.Input
+                }], styles: [{
+                    type: i0.Input
+                }], viewOptions: [{
+                    type: i0.Input
+                }], disabledLoadOnScroll: [{
+                    type: i0.Input
+                }], loadOnScroll: [{
+                    type: i0.Output
+                }], dragStarted: [{
+                    type: i0.Output
+                }], dragEnded: [{
+                    type: i0.Output
+                }], barClick: [{
+                    type: i0.Output
+                }], barTemplate: [{
+                    type: i0.ContentChild,
+                    args: ['bar', { static: true }]
+                }], rangeTemplate: [{
+                    type: i0.ContentChild,
+                    args: ['range', { static: true }]
+                }], itemTemplate: [{
+                    type: i0.ContentChild,
+                    args: ['item', { static: true }]
+                }], groupTemplate: [{
+                    type: i0.ContentChild,
+                    args: ['group', { static: true }]
+                }], groupHeaderTemplate: [{
+                    type: i0.ContentChild,
+                    args: ['groupHeader', { static: true }]
+                }], ganttClass: [{
+                    type: i0.HostBinding,
+                    args: ['class.gantt']
+                }] } });
+    var GANTT_UPPER_TOKEN = new i0.InjectionToken('GANTT_UPPER_TOKEN');
+
+    var NgxGanttTableColumnComponent = /** @class */ (function () {
+        function NgxGanttTableColumnComponent(ganttUpper) {
+            this.ganttUpper = ganttUpper;
+        }
+        Object.defineProperty(NgxGanttTableColumnComponent.prototype, "width", {
+            set: function (width) {
+                this.columnWidth = coercion.coerceCssPixelValue(width);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        NgxGanttTableColumnComponent.prototype.ngOnInit = function () { };
+        return NgxGanttTableColumnComponent;
+    }());
+    NgxGanttTableColumnComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttTableColumnComponent, deps: [{ token: GANTT_UPPER_TOKEN }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    NgxGanttTableColumnComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.1.2", type: NgxGanttTableColumnComponent, selector: "ngx-gantt-column", inputs: { width: "width", name: "name" }, queries: [{ propertyName: "templateRef", first: true, predicate: ["cell"], descendants: true, static: true }, { propertyName: "headerTemplateRef", first: true, predicate: ["header"], descendants: true, static: true }], ngImport: i0__namespace, template: '', isInline: true });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttTableColumnComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: 'ngx-gantt-column',
+                        template: ''
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: GanttUpper, decorators: [{
+                            type: i0.Inject,
+                            args: [GANTT_UPPER_TOKEN]
+                        }] }];
+        }, propDecorators: { width: [{
+                    type: i0.Input
+                }], name: [{
+                    type: i0.Input
+                }], templateRef: [{
+                    type: i0.ContentChild,
+                    args: ['cell', { static: true }]
+                }], headerTemplateRef: [{
+                    type: i0.ContentChild,
+                    args: ['header', { static: true }]
+                }] } });
+
+    var NgxGanttTableComponent = /** @class */ (function () {
+        function NgxGanttTableComponent() {
+            this.columnChanges = new i0.EventEmitter();
+        }
+        NgxGanttTableComponent.prototype.ngOnInit = function () { };
+        return NgxGanttTableComponent;
+    }());
+    NgxGanttTableComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttTableComponent, deps: [], target: i0__namespace.ɵɵFactoryTarget.Component });
+    NgxGanttTableComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.1.2", type: NgxGanttTableComponent, selector: "ngx-gantt-table", outputs: { columnChanges: "columnChanges" }, ngImport: i0__namespace, template: '', isInline: true });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttTableComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: 'ngx-gantt-table',
+                        template: ''
+                    }]
+            }], ctorParameters: function () { return []; }, propDecorators: { columnChanges: [{
+                    type: i0.Output
+                }] } });
+
+    var GANTT_ABSTRACT_TOKEN = new i0.InjectionToken('gantt-abstract-token');
+
+    var angleRight = "<svg xmlns=\"http://www.w3.org/2000/svg\" fit=\"\"  preserveAspectRatio=\"xMidYMid meet\" focusable=\"false\"><g id=\"amnavigation/angle-right\" stroke-width=\"1\" fill-rule=\"evenodd\"><path d=\"M7.978 11.498l-.005.005L2.3 5.831 3.13 5l4.848 4.848L12.826 5l.83.831-5.673 5.672-.005-.005z\"   transform=\"rotate(-90 7.978 8.252)\"></path></g></svg>";
+    var angleDown = "<svg xmlns=\"http://www.w3.org/2000/svg\" fit=\"\"  preserveAspectRatio=\"xMidYMid meet\" focusable=\"false\"><g id=\"aknavigation/angle-down\" stroke-width=\"1\" fill-rule=\"evenodd\"><path d=\"M7.978 11.997l-.005.006L2.3 6.33l.83-.831 4.848 4.848L12.826 5.5l.83.83-5.673 5.673-.005-.006z\" ></path></g></svg>";
+    var plusSquare = "<svg viewBox=\"0 0 16 16\" xmlns=\"http://www.w3.org/2000/svg\" fit=\"\"   preserveAspectRatio=\"xMidYMid meet\" focusable=\"false\"><g id=\"kxaction/plus-square\" stroke-width=\"1\" fill-rule=\"evenodd\"><path d=\"M2 0h12a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2H2a2 2 0 0 1-2-2V2a2 2 0 0 1 2-2zm0 1.2a.8.8 0 0 0-.8.8v12a.8.8 0 0 0 .8.8h12a.8.8 0 0 0 .8-.8V2a.8.8 0 0 0-.8-.8H2zm5.45 6.2V4.75h1.2V7.4h2.65v1.2H8.65v2.65h-1.2V8.6H4.8V7.4h2.65z\"></path></g></svg>";
+    var minusSquare = "<svg viewBox=\"0 0 16 16\" xmlns=\"http://www.w3.org/2000/svg\" fit=\"\" preserveAspectRatio=\"xMidYMid meet\" focusable=\"false\"><g id=\"jnaction/minus-square\" stroke-width=\"1\" fill-rule=\"evenodd\"><path d=\"M2 0h12a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2H2a2 2 0 0 1-2-2V2a2 2 0 0 1 2-2zm0 1.2a.8.8 0 0 0-.8.8v12a.8.8 0 0 0 .8.8h12a.8.8 0 0 0 .8-.8V2a.8.8 0 0 0-.8-.8H2zm2.8 6.2h6.5v1.2H4.8V7.4z\"></path></g></svg>";
+    var loadingIcon = "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"  viewBox=\"0 0 50 50\" style=\"enable-background:new 0 0 50 50\" xml:space=\"preserve\">\n<path fill=\"#aaa\" d=\"M25.251,6.461c-10.318,0-18.683,8.365-18.683,18.683h4.068c0-8.071,6.543-14.615,14.615-14.615V6.461z\" transform=\"rotate(275.098 25 25)\">\n    <animateTransform attributeType=\"xml\" attributeName=\"transform\" type=\"rotate\" from=\"0 25 25\" to=\"360 25 25\" dur=\"0.6s\" repeatCount=\"indefinite\"></animateTransform>\n</path>\n</svg>";
+    var emptyIcon = "<svg\nwidth=\"148px\"\nheight=\"134px\"\nviewBox=\"0 0 148 134\"\nversion=\"1.1\"\nxmlns=\"http://www.w3.org/2000/svg\"\nxmlns:xlink=\"http://www.w3.org/1999/xlink\"\n>\n<defs>\n  <filter x=\"0.0%\" y=\"0.0%\" width=\"100.0%\" height=\"100.0%\" filterUnits=\"objectBoundingBox\" id=\"filter-1\">\n    <feGaussianBlur stdDeviation=\"0\" in=\"SourceGraphic\"></feGaussianBlur>\n  </filter>\n</defs>\n<g id=\"148x134\" stroke=\"none\" stroke-width=\"1\" fill=\"none\" fill-rule=\"evenodd\">\n  <g id=\"\u7F16\u7EC4-6\" transform=\"translate(1.000000, 1.000000)\">\n    <ellipse\n      id=\"\u692D\u5706\u5F62\"\n      fill=\"#EDEEF2\"\n      opacity=\"0.3\"\n      filter=\"url(#filter-1)\"\n      cx=\"73.0800017\"\n      cy=\"115.920003\"\n      rx=\"73.0800017\"\n      ry=\"16.8000004\"\n    ></ellipse>\n    <g id=\"\u7F16\u7EC4-5\" transform=\"translate(15.120000, 0.000000)\">\n      <polygon\n        id=\"\u77E9\u5F62\"\n        fill=\"#E2E4E9\"\n        points=\"19.2789848 49.5600011 99.1200023 48.7200011 117.600003 75.9297673 117.600003 92.313049 0 92.313049 0 75.0356267\"\n      ></polygon>\n      <path\n        d=\"M23.5200005,0 L94.0800002,0 C97.7913538,2.06413823e-16 100.8,3.00864655 100.8,6.72000015 L100.8,99.1200023 L100.8,99.1200023 L16.8000004,99.1200023 L16.8000004,6.72000015 C16.8000004,3.00864655 19.8086469,1.56994302e-15 23.5200005,0 Z\"\n        id=\"\u77E9\u5F62\"\n        fill=\"#F9FAFB\"\n      ></path>\n      <path\n        d=\"M30.9200007,12.4400003 L86.6800019,12.4400003 C88.5356787,12.4400003 90.040002,13.9443236 90.040002,15.8000004 L90.040002,42.000001 C90.040002,43.8556778 88.5356787,45.360001 86.6800019,45.360001 L30.9200007,45.360001 C29.0643239,45.360001 27.5600006,43.8556778 27.5600006,42.000001 L27.5600006,15.8000004 C27.5600006,13.9443236 29.0643239,12.4400003 30.9200007,12.4400003 Z\"\n        id=\"\u77E9\u5F62\"\n        fill=\"#E8EAEE\"\n      ></path>\n      <text\n        id=\"&lt;/null&gt;\"\n        font-family=\"PingFangSC-Medium, PingFang SC\"\n        font-size=\"15.1200003\"\n        font-weight=\"400\"\n        fill=\"#BCBECD\"\n      >\n        <tspan x=\"33.6000008\" y=\"32.8000004\">&lt;/null&gt;</tspan>\n      </text>\n      <rect id=\"\u77E9\u5F62\" fill=\"#E8EAEE\" x=\"27.5600006\" y=\"52.0800012\" width=\"61.4800014\" height=\"5.04000011\" rx=\"2.52000006\"></rect>\n      <rect\n        id=\"\u77E9\u5F62\u5907\u4EFD\"\n        fill=\"#E8EAEE\"\n        x=\"27.5600006\"\n        y=\"63.8400014\"\n        width=\"61.4800014\"\n        height=\"5.04000011\"\n        rx=\"2.52000006\"\n      ></rect>\n      <path\n        d=\"M0,75.6000017 L29.280235,75.6000017 C32.0637502,75.6000017 34.3202352,77.8564866 34.3202352,80.6400018 L34.3202352,86.2591426 C34.3202352,89.0426578 36.5767201,91.2991427 39.3602353,91.2991427 L78.4136737,91.2991427 C81.1971889,91.2991427 83.4536738,89.0426578 83.4536738,86.2591426 L83.4536738,80.6400018 C83.4536738,77.8564866 85.7101587,75.6000017 88.4936739,75.6000017 L117.600003,75.6000017 L117.600003,75.6000017 L117.600003,110.880003 C117.600003,115.519195 113.839194,119.280003 109.200002,119.280003 L8.40000019,119.280003 C3.76080819,119.280003 -6.53729019e-15,115.519195 0,110.880003 L0,75.6000017 L0,75.6000017 Z\"\n        id=\"\u77E9\u5F62\"\n        fill=\"#EDEFF2\"\n      ></path>\n    </g>\n  </g>\n</g>\n</svg>";
+    var icons = {
+        'angle-right': angleRight,
+        'angle-down': angleDown,
+        'plus-square': plusSquare,
+        'minus-square': minusSquare,
+        loading: loadingIcon,
+        empty: emptyIcon
+    };
+
+    var GanttIconComponent = /** @class */ (function () {
+        function GanttIconComponent(elementRef) {
+            this.elementRef = elementRef;
+            this.isIcon = true;
+        }
+        Object.defineProperty(GanttIconComponent.prototype, "iconName", {
+            set: function (name) {
+                this.setSvg(name);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        GanttIconComponent.prototype.ngOnInit = function () { };
+        GanttIconComponent.prototype.ngAfterViewInit = function () { };
+        GanttIconComponent.prototype.setSvg = function (name) {
+            var iconSvg = icons[name];
+            if (iconSvg) {
+                this.elementRef.nativeElement.innerHTML = iconSvg;
+            }
+            else {
+                this.elementRef.nativeElement.innerHTML = '';
+            }
+        };
+        return GanttIconComponent;
+    }());
+    GanttIconComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttIconComponent, deps: [{ token: i0__namespace.ElementRef }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    GanttIconComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.1.2", type: GanttIconComponent, selector: "gantt-icon", inputs: { iconName: "iconName" }, host: { properties: { "class.gantt-icon": "this.isIcon" } }, ngImport: i0__namespace, template: '', isInline: true });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttIconComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: 'gantt-icon',
+                        template: ''
+                    }]
+            }], ctorParameters: function () { return [{ type: i0__namespace.ElementRef }]; }, propDecorators: { isIcon: [{
+                    type: i0.HostBinding,
+                    args: ['class.gantt-icon']
+                }], iconName: [{
+                    type: i0.Input
+                }] } });
+
+    var IsGanttRangeItemPipe = /** @class */ (function () {
+        function IsGanttRangeItemPipe() {
+        }
+        IsGanttRangeItemPipe.prototype.transform = function (value) {
+            return value === exports.GanttItemType.range;
+        };
+        return IsGanttRangeItemPipe;
+    }());
+    IsGanttRangeItemPipe.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: IsGanttRangeItemPipe, deps: [], target: i0__namespace.ɵɵFactoryTarget.Pipe });
+    IsGanttRangeItemPipe.ɵpipe = i0__namespace.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: IsGanttRangeItemPipe, name: "isGanttRangeItem" });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: IsGanttRangeItemPipe, decorators: [{
+                type: i0.Pipe,
+                args: [{
+                        name: 'isGanttRangeItem'
+                    }]
+            }] });
+    var IsGanttBarItemPipe = /** @class */ (function () {
+        function IsGanttBarItemPipe() {
+        }
+        IsGanttBarItemPipe.prototype.transform = function (value) {
+            return value === exports.GanttItemType.bar;
+        };
+        return IsGanttBarItemPipe;
+    }());
+    IsGanttBarItemPipe.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: IsGanttBarItemPipe, deps: [], target: i0__namespace.ɵɵFactoryTarget.Pipe });
+    IsGanttBarItemPipe.ɵpipe = i0__namespace.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: IsGanttBarItemPipe, name: "isGanttBarItem" });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: IsGanttBarItemPipe, decorators: [{
+                type: i0.Pipe,
+                args: [{
+                        name: 'isGanttBarItem'
+                    }]
+            }] });
+    var IsGanttCustomItemPipe = /** @class */ (function () {
+        function IsGanttCustomItemPipe() {
+        }
+        IsGanttCustomItemPipe.prototype.transform = function (value) {
+            return value === exports.GanttItemType.custom;
+        };
+        return IsGanttCustomItemPipe;
+    }());
+    IsGanttCustomItemPipe.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: IsGanttCustomItemPipe, deps: [], target: i0__namespace.ɵɵFactoryTarget.Pipe });
+    IsGanttCustomItemPipe.ɵpipe = i0__namespace.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: IsGanttCustomItemPipe, name: "isGanttCustomItem" });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: IsGanttCustomItemPipe, decorators: [{
+                type: i0.Pipe,
+                args: [{
+                        name: 'isGanttCustomItem'
+                    }]
+            }] });
+
+    var defaultColumnWidth = 100;
+    var minColumnWidth = 80;
+    var GanttTableComponent = /** @class */ (function () {
+        function GanttTableComponent(gantt, elementRef) {
+            this.gantt = gantt;
+            this.elementRef = elementRef;
+            this.ganttTableClass = true;
+            this.ganttTableEmptyClass = false;
+        }
+        Object.defineProperty(GanttTableComponent.prototype, "columns", {
+            set: function (columns) {
+                columns.forEach(function (column) {
+                    if (!column.columnWidth) {
+                        column.columnWidth = coercion.coerceCssPixelValue(defaultColumnWidth);
+                    }
+                });
+                this.columnList = columns;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        GanttTableComponent.prototype.ngOnInit = function () { };
+        GanttTableComponent.prototype.ngOnChanges = function (changes) {
+            var _a, _b;
+            if (!((_a = changes.groups.currentValue) === null || _a === void 0 ? void 0 : _a.length) && !((_b = changes.items.currentValue) === null || _b === void 0 ? void 0 : _b.length)) {
+                this.ganttTableEmptyClass = true;
+            }
+            else {
+                this.ganttTableEmptyClass = false;
+            }
+        };
+        GanttTableComponent.prototype.dragFixed = function (config) {
+            if (config.movedWidth < config.minWidth) {
+                config.target.style.transform = "translate3d(" + (config.minWidth - config.originWidth) + "px, 0, 0)";
+            }
+        };
+        GanttTableComponent.prototype.expandGroup = function (group) {
+            this.gantt.expandGroup(group);
+        };
+        GanttTableComponent.prototype.expandChildren = function (item) {
+            this.gantt.expandChildren(item);
+        };
+        GanttTableComponent.prototype.dragStarted = function (event) {
+            var target = event.source.element.nativeElement;
+            this.dragStartLeft = target.getBoundingClientRect().left;
+        };
+        GanttTableComponent.prototype.dragMoved = function (event, column) {
+            var target = event.source.element.nativeElement;
+            var left = target.getBoundingClientRect().left;
+            var originWidth;
+            var movedWidth;
+            var minWidth;
+            if (column) {
+                originWidth = parseInt(column.columnWidth, 10);
+                movedWidth = originWidth + (left - this.dragStartLeft);
+                minWidth = minColumnWidth;
+            }
+            else {
+                originWidth = this.elementRef.nativeElement.getBoundingClientRect().width;
+                movedWidth = originWidth + (left - this.dragStartLeft);
+                minWidth = minColumnWidth * this.columnList.length;
+            }
+            this.dragFixed({
+                target: target,
+                originWidth: originWidth,
+                movedWidth: movedWidth,
+                minWidth: minWidth
+            });
+            this.showAuxiliaryLine(event);
+        };
+        GanttTableComponent.prototype.columnDragEnded = function (event, column) {
+            var target = event.source.element.nativeElement;
+            var left = target.getBoundingClientRect().left;
+            var width = parseInt(column.columnWidth, 10) + (left - this.dragStartLeft);
+            var columnWidth = Math.max(width || 0, minColumnWidth);
+            column.columnWidth = coercion.coerceCssPixelValue(columnWidth);
+            if (this.gantt.table) {
+                this.gantt.table.columnChanges.emit({ columns: this.columnList });
+            }
+            this.hideAuxiliaryLine();
+            event.source.reset();
+        };
+        GanttTableComponent.prototype.tableDragEnded = function (event) {
+            var target = event.source.element.nativeElement;
+            var left = target.getBoundingClientRect().left;
+            var tableWidth = this.elementRef.nativeElement.getBoundingClientRect().width;
+            var dragWidth = left - this.dragStartLeft;
+            this.columnList.forEach(function (column) {
+                var lastColumnWidth = parseInt(column.columnWidth, 10);
+                var distributeWidth = parseInt(String(dragWidth * (lastColumnWidth / tableWidth)), 10);
+                var columnWidth = Math.max(lastColumnWidth + distributeWidth || 0, minColumnWidth);
+                column.columnWidth = coercion.coerceCssPixelValue(columnWidth);
+            });
+            if (this.gantt.table) {
+                this.gantt.table.columnChanges.emit({ columns: this.columnList });
+            }
+            this.hideAuxiliaryLine();
+            event.source.reset();
+        };
+        GanttTableComponent.prototype.showAuxiliaryLine = function (event) {
+            var tableRect = this.elementRef.nativeElement.getBoundingClientRect();
+            var targetRect = event.source.element.nativeElement.getBoundingClientRect();
+            var distance = { x: targetRect.left - tableRect.left, y: targetRect.top - tableRect.top };
+            this.draglineElementRef.nativeElement.style.left = distance.x + "px";
+            this.draglineElementRef.nativeElement.style.display = 'block';
+        };
+        GanttTableComponent.prototype.hideAuxiliaryLine = function () {
+            this.draglineElementRef.nativeElement.style.display = 'none';
+        };
+        return GanttTableComponent;
+    }());
+    GanttTableComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttTableComponent, deps: [{ token: GANTT_ABSTRACT_TOKEN }, { token: i0__namespace.ElementRef }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    GanttTableComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.1.2", type: GanttTableComponent, selector: "gantt-table", inputs: { groups: "groups", items: "items", columns: "columns", groupTemplate: "groupTemplate", emptyTemplate: "emptyTemplate" }, host: { properties: { "class.gantt-table": "this.ganttTableClass", "class.gantt-table-empty": "this.ganttTableEmptyClass" } }, viewQueries: [{ propertyName: "draglineElementRef", first: true, predicate: ["dragLine"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0__namespace, template: "<div class=\"gantt-table-header gantt-table-row\">\n  <div class=\"gantt-table-column\" *ngFor=\"let column of columnList; let i = index\" [style.width]=\"column.columnWidth\">\n    <ng-container *ngIf=\"column.headerTemplateRef; else default\" [ngTemplateOutlet]=\"column.headerTemplateRef\"></ng-container>\n    <ng-template #default>\n      {{ column.name }}\n    </ng-template>\n    <div\n      class=\"gantt-table-drag-trigger\"\n      cdkDrag\n      cdkDragLockAxis=\"x\"\n      cdkDragBoundary=\".gantt\"\n      (cdkDragMoved)=\"dragMoved($event, column)\"\n      (cdkDragStarted)=\"dragStarted($event)\"\n      (cdkDragEnded)=\"columnDragEnded($event, column)\"\n    ></div>\n  </div>\n</div>\n<div class=\"gantt-table-body\">\n  <ng-container *ngIf=\"!groups.length && !items.length\">\n    <ng-container *ngIf=\"!emptyTemplate\">\n      <gantt-icon class=\"empty-icon\" iconName=\"empty\"></gantt-icon>\n      <div class=\"empty-text\">\u6CA1\u6709\u6570\u636E</div>\n    </ng-container>\n    <ng-template [ngTemplateOutlet]=\"emptyTemplate\"></ng-template>\n  </ng-container>\n\n  <ng-container *ngIf=\"groups && groups.length > 0; else itemsTemplate\">\n    <ng-container *ngFor=\"let group of groups\">\n      <div class=\"gantt-table-group\" [ngClass]=\"group.class\">\n        <div class=\"gantt-table-group-title\" [class.expanded]=\"group.expanded\" (click)=\"expandGroup(group)\">\n          <gantt-icon class=\"expand-icon\" [iconName]=\"group.expanded ? 'angle-down' : 'angle-right'\"></gantt-icon>\n          <ng-container *ngIf=\"groupTemplate; else default\">\n            <ng-template\n              [ngTemplateOutlet]=\"groupTemplate\"\n              [ngTemplateOutletContext]=\"{ $implicit: group.origin, group: group.origin }\"\n            ></ng-template>\n          </ng-container>\n          <ng-template #default>\n            <span class=\"group-title\">{{ group.title }}</span>\n          </ng-template>\n        </div>\n      </div>\n\n      <ng-container *ngIf=\"group.expanded\">\n        <ng-template\n          [ngTemplateOutlet]=\"ganttItems\"\n          [ngTemplateOutletContext]=\"{ group: group, items: group.items, level: 0 }\"\n        ></ng-template>\n      </ng-container>\n    </ng-container>\n  </ng-container>\n</div>\n\n<div\n  class=\"gantt-table-drag-trigger\"\n  cdkDrag\n  cdkDragLockAxis=\"x\"\n  cdkDragBoundary=\".gantt\"\n  (cdkDragMoved)=\"dragMoved($event)\"\n  (cdkDragStarted)=\"dragStarted($event)\"\n  (cdkDragEnded)=\"tableDragEnded($event)\"\n></div>\n\n<div #dragLine class=\"gantt-table-drag-auxiliary-line\"></div>\n\n<ng-template #itemsTemplate>\n  <ng-template [ngTemplateOutlet]=\"ganttItems\" [ngTemplateOutletContext]=\"{ items: items, level: 0 }\"></ng-template>\n</ng-template>\n\n<ng-template #ganttItems let-group=\"group\" let-items=\"items\" let-level=\"level\">\n  <ng-container *ngFor=\"let item of items\">\n    <div\n      class=\"gantt-table-item gantt-table-row\"\n      [class.gantt-table-item-first-level-group]=\"level === 0 && (item.type | isGanttRangeItem)\"\n      [class.gantt-table-item-with-group]=\"group\"\n      [style.height.px]=\"gantt.styles.lineHeight\"\n      [style.lineHeight.px]=\"gantt.styles.lineHeight\"\n    >\n      <div class=\"gantt-table-column\" *ngFor=\"let column of columnList; let first = first\" [style.width]=\"column.columnWidth\">\n        <div *ngIf=\"first\" class=\"gantt-expand-icon\" [style.marginLeft.px]=\"level * 20\">\n          <ng-container *ngIf=\"level < gantt.maxLevel - 1 && item.expandable\">\n            <gantt-icon\n              *ngIf=\"!item.loading\"\n              class=\"expand-icon\"\n              [iconName]=\"item.expanded ? 'angle-down' : 'angle-right'\"\n              (click)=\"expandChildren(item)\"\n            ></gantt-icon>\n            <gantt-icon *ngIf=\"item.loading\" [iconName]=\"'loading'\"></gantt-icon>\n          </ng-container>\n        </div>\n        <div class=\"gantt-table-column-content\">\n          <ng-template\n            [ngTemplateOutlet]=\"column.templateRef\"\n            [ngTemplateOutletContext]=\"{ $implicit: item.origin, item: item.origin }\"\n          ></ng-template>\n        </div>\n      </div>\n    </div>\n    <ng-template\n      *ngIf=\"item.children && item.expanded\"\n      [ngTemplateOutlet]=\"ganttItems\"\n      [ngTemplateOutletContext]=\"{ items: item.children, level: level + 1, group: group }\"\n    ></ng-template>\n  </ng-container>\n</ng-template>\n", components: [{ type: GanttIconComponent, selector: "gantt-icon", inputs: ["iconName"] }], directives: [{ type: i2__namespace.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2__namespace.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2__namespace.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i1__namespace.CdkDrag, selector: "[cdkDrag]", inputs: ["cdkDragDisabled", "cdkDragStartDelay", "cdkDragLockAxis", "cdkDragConstrainPosition", "cdkDragPreviewClass", "cdkDragBoundary", "cdkDragRootElement", "cdkDragData", "cdkDragFreeDragPosition"], outputs: ["cdkDragStarted", "cdkDragReleased", "cdkDragEnded", "cdkDragEntered", "cdkDragExited", "cdkDragDropped", "cdkDragMoved"], exportAs: ["cdkDrag"] }, { type: i2__namespace.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], pipes: { "isGanttRangeItem": IsGanttRangeItemPipe } });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttTableComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: 'gantt-table',
+                        templateUrl: './gantt-table.component.html'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: [GANTT_ABSTRACT_TOKEN]
+                        }] }, { type: i0__namespace.ElementRef }];
+        }, propDecorators: { groups: [{
+                    type: i0.Input
+                }], items: [{
+                    type: i0.Input
+                }], columns: [{
+                    type: i0.Input
+                }], groupTemplate: [{
+                    type: i0.Input
+                }], emptyTemplate: [{
+                    type: i0.Input
+                }], draglineElementRef: [{
+                    type: i0.ViewChild,
+                    args: ['dragLine', { static: true }]
+                }], ganttTableClass: [{
+                    type: i0.HostBinding,
+                    args: ['class.gantt-table']
+                }], ganttTableEmptyClass: [{
+                    type: i0.HostBinding,
+                    args: ['class.gantt-table-empty']
+                }] } });
+
+    var scrollThreshold = 50;
+    var ScrollDirection;
+    (function (ScrollDirection) {
+        ScrollDirection[ScrollDirection["NONE"] = 0] = "NONE";
+        ScrollDirection[ScrollDirection["LEFT"] = 1] = "LEFT";
+        ScrollDirection[ScrollDirection["RIGHT"] = 2] = "RIGHT";
+    })(ScrollDirection || (ScrollDirection = {}));
+    var GanttDomService = /** @class */ (function () {
+        function GanttDomService() {
+            this.unsubscribe$ = new rxjs.Subject();
+        }
+        GanttDomService.prototype.monitorScrollChange = function () {
+            var _this = this;
+            rxjs.merge(rxjs.fromEvent(this.mainContainer, 'scroll'), rxjs.fromEvent(this.sideContainer, 'scroll'))
+                .pipe(operators.takeUntil(this.unsubscribe$))
+                .subscribe(function (event) {
+                _this.syncScroll(event);
+            });
+            rxjs.fromEvent(this.mainContainer, 'scroll')
+                .pipe(operators.startWith(), operators.takeUntil(this.unsubscribe$))
+                .subscribe(function (event) {
+                // if (this.mainContainer.scrollLeft > 0) {
+                //     this.side.classList.add('gantt-side-has-shadow');
+                // } else {
+                //     this.side.classList.remove('gantt-side-has-shadow');
+                // }
+            });
+        };
+        GanttDomService.prototype.syncScroll = function (event) {
+            var target = event.currentTarget;
+            this.calendarOverlay.scrollLeft = this.mainContainer.scrollLeft;
+            this.sideContainer.scrollTop = target.scrollTop;
+            this.mainContainer.scrollTop = target.scrollTop;
+        };
+        GanttDomService.prototype.disableBrowserWheelEvent = function () {
+            var container = this.mainContainer;
+            rxjs.fromEvent(container, 'wheel')
+                .pipe(operators.takeUntil(this.unsubscribe$))
+                .subscribe(function (event) {
+                var delta = event.deltaX;
+                if (!delta) {
+                    return;
+                }
+                if ((container.scrollLeft + container.offsetWidth === container.scrollWidth && delta > 0) ||
+                    (container.scrollLeft === 0 && delta < 0)) {
+                    event.preventDefault();
+                }
+            });
+        };
+        GanttDomService.prototype.initialize = function (root) {
+            this.root = root.nativeElement;
+            this.side = this.root.getElementsByClassName('gantt-side')[0];
+            this.container = this.root.getElementsByClassName('gantt-container')[0];
+            this.sideContainer = this.root.getElementsByClassName('gantt-side-container')[0];
+            this.mainContainer = this.root.getElementsByClassName('gantt-main-container')[0];
+            this.calendarOverlay = this.root.getElementsByClassName('gantt-calendar-overlay')[0];
+            this.monitorScrollChange();
+            this.disableBrowserWheelEvent();
+        };
+        GanttDomService.prototype.getViewerScroll = function () {
+            var _this = this;
+            return rxjs.fromEvent(this.mainContainer, 'scroll').pipe(operators.map(function () { return _this.mainContainer.scrollLeft; }), operators.pairwise(), operators.map(function (_a) {
+                var _b = __read(_a, 2), previous = _b[0], current = _b[1];
+                var event = {
+                    target: _this.mainContainer,
+                    direction: ScrollDirection.NONE
+                };
+                if (current - previous < 0) {
+                    if (_this.mainContainer.scrollLeft < scrollThreshold && _this.mainContainer.scrollLeft > 0) {
+                        event.direction = ScrollDirection.LEFT;
+                    }
+                }
+                if (current - previous > 0) {
+                    if (_this.mainContainer.scrollWidth - _this.mainContainer.clientWidth - _this.mainContainer.scrollLeft < scrollThreshold) {
+                        event.direction = ScrollDirection.RIGHT;
+                    }
+                }
+                return event;
+            }));
+        };
+        GanttDomService.prototype.getResize = function () {
+            return rxjs.fromEvent(window, 'resize').pipe(operators.auditTime(150));
+        };
+        GanttDomService.prototype.scrollMainContainer = function (left) {
+            if (isNumber(left)) {
+                var scrollLeft = left - this.mainContainer.clientWidth / 2;
+                this.mainContainer.scrollLeft = scrollLeft > scrollThreshold ? scrollLeft : 0;
+                this.calendarOverlay.scrollLeft = this.mainContainer.scrollLeft;
+            }
+        };
+        GanttDomService.prototype.ngOnDestroy = function () {
+            this.unsubscribe$.next();
+            this.unsubscribe$.complete();
+        };
+        return GanttDomService;
+    }());
+    GanttDomService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttDomService, deps: [], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    GanttDomService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttDomService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttDomService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return []; } });
+
+    var GanttDragContainer = /** @class */ (function () {
+        function GanttDragContainer() {
+            this.dragStarted = new i0.EventEmitter();
+            this.dragEnded = new i0.EventEmitter();
+            this.linkDragStarted = new i0.EventEmitter();
+            this.linkDragEntered = new i0.EventEmitter();
+            this.linkDragEnded = new i0.EventEmitter();
+        }
+        GanttDragContainer.prototype.emitLinkDragStarted = function (from, item) {
+            this.linkDraggingId = item.id;
+            this.linkDragFrom = from;
+            this.linkDragSource = this.linkDragFrom === 'source' ? item : null;
+            this.linkDragTarget = this.linkDragFrom === 'target' ? item : null;
+            this.linkDragStarted.emit({
+                source: this.linkDragSource && this.linkDragSource.origin,
+                target: this.linkDragTarget && this.linkDragTarget.origin
+            });
+        };
+        GanttDragContainer.prototype.emitLinkDragEntered = function (item) {
+            if (this.linkDragFrom === 'source') {
+                this.linkDragTarget = item;
+            }
+            else {
+                this.linkDragSource = item;
+            }
+            this.linkDragEntered.emit({
+                source: this.linkDragSource.origin,
+                target: this.linkDragTarget.origin
+            });
+        };
+        GanttDragContainer.prototype.emitLinkDragLeaved = function () {
+            if (this.linkDragFrom === 'source') {
+                this.linkDragTarget = null;
+            }
+            else {
+                this.linkDragSource = null;
+            }
+        };
+        GanttDragContainer.prototype.emitLinkDragEnded = function () {
+            this.linkDraggingId = null;
+            if (this.linkDragSource && this.linkDragTarget) {
+                this.linkDragSource.addLink(this.linkDragTarget.id);
+                this.linkDragEnded.emit({
+                    source: this.linkDragSource.origin,
+                    target: this.linkDragTarget.origin
+                });
+            }
+            this.linkDragSource = null;
+            this.linkDragTarget = null;
+        };
+        return GanttDragContainer;
+    }());
+    GanttDragContainer.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttDragContainer, deps: [], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    GanttDragContainer.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttDragContainer });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttDragContainer, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return []; } });
+
+    var GanttPrintService = /** @class */ (function () {
+        function GanttPrintService() {
+        }
+        GanttPrintService.prototype.setInlineStyles = function (targetElem) {
+            var e_1, _a;
+            var svgElements = Array.from(targetElem.getElementsByTagName('svg'));
+            try {
+                for (var svgElements_1 = __values(svgElements), svgElements_1_1 = svgElements_1.next(); !svgElements_1_1.done; svgElements_1_1 = svgElements_1.next()) {
+                    var svgElement = svgElements_1_1.value;
+                    this.recursElementChildren(svgElement);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (svgElements_1_1 && !svgElements_1_1.done && (_a = svgElements_1.return)) _a.call(svgElements_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        };
+        GanttPrintService.prototype.recursElementChildren = function (node) {
+            var e_2, _a, e_3, _b;
+            var transformProperties = [
+                'fill',
+                'color',
+                'font-size',
+                'stroke',
+                'font',
+                'text-anchor',
+                'stroke-dasharray',
+                'shape-rendering',
+                'stroke-width'
+            ];
+            if (!node.style) {
+                return;
+            }
+            var styles = getComputedStyle(node);
+            try {
+                for (var transformProperties_1 = __values(transformProperties), transformProperties_1_1 = transformProperties_1.next(); !transformProperties_1_1.done; transformProperties_1_1 = transformProperties_1.next()) {
+                    var transformProperty = transformProperties_1_1.value;
+                    node.style[transformProperty] = styles[transformProperty];
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (transformProperties_1_1 && !transformProperties_1_1.done && (_a = transformProperties_1.return)) _a.call(transformProperties_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            try {
+                for (var _c = __values(Array.from(node.childNodes)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var child = _d.value;
+                    this.recursElementChildren(child);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        };
+        GanttPrintService.prototype.register = function (root) {
+            this.root = root.nativeElement;
+            this.mainContainer = this.root.getElementsByClassName('gantt-main-container')[0];
+        };
+        GanttPrintService.prototype.print = function (name, ignoreElementClass) {
+            var _this = this;
+            if (name === void 0) { name = 'download'; }
+            var root = this.root;
+            var mainContainer = this.mainContainer;
+            // set print width
+            var printWidth = root.offsetWidth;
+            // set print height
+            var printHeight = root.offsetHeight - mainContainer.offsetHeight + mainContainer.scrollHeight;
+            html2canvas__default['default'](root, {
+                logging: false,
+                allowTaint: true,
+                useCORS: true,
+                width: printWidth,
+                height: printHeight,
+                ignoreElements: function (element) {
+                    if (ignoreElementClass && element.classList.contains(ignoreElementClass)) {
+                        return true;
+                    }
+                    if (element.classList.contains('gantt-calendar-today-overlay')) {
+                        return true;
+                    }
+                },
+                onclone: function (cloneDocument) {
+                    var ganttClass = root.className;
+                    var cloneGanttDom = cloneDocument.querySelector("." + ganttClass.replace(/\s+/g, '.'));
+                    var cloneGanttContainerDom = cloneDocument.querySelector('.gantt-container');
+                    var cloneCalendarOverlay = cloneDocument.querySelector('.gantt-calendar-overlay-main');
+                    var cloneLinksOverlay = cloneDocument.querySelector('.gantt-links-overlay-main');
+                    // change targetDom width
+                    cloneGanttDom.style.width = printWidth + "px";
+                    cloneGanttDom.style.height = printHeight + "px";
+                    cloneGanttDom.style.overflow = "unset";
+                    cloneGanttContainerDom.style.backgroundColor = '#fff';
+                    cloneCalendarOverlay.setAttribute('height', "" + printHeight);
+                    cloneCalendarOverlay.setAttribute('style', "background: transparent");
+                    if (cloneLinksOverlay) {
+                        cloneLinksOverlay.setAttribute('height', "" + printHeight);
+                        cloneLinksOverlay.setAttribute('style', "height: " + printHeight + "px");
+                    }
+                    // setInlineStyles for svg
+                    _this.setInlineStyles(cloneGanttDom);
+                }
+            }).then(function (canvas) {
+                var link = document.createElement('a');
+                var dataUrl = canvas.toDataURL('image/png');
+                link.download = name + ".png";
+                link.href = dataUrl;
+                link.click();
+            });
+        };
+        return GanttPrintService;
+    }());
+    GanttPrintService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttPrintService, deps: [], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    GanttPrintService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttPrintService });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttPrintService, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return []; } });
+
+    var mainHeight = 5000;
+    var GanttCalendarComponent = /** @class */ (function () {
+        function GanttCalendarComponent(ganttUpper, ngZone, elementRef) {
+            this.ganttUpper = ganttUpper;
+            this.ngZone = ngZone;
+            this.elementRef = elementRef;
+            this.unsubscribe$ = new rxjs.Subject();
+            this.headerHeight = headerHeight;
+            this.mainHeight = mainHeight;
+            this.todayHeight = todayHeight;
+            this.todayWidth = todayWidth;
+            this.todayBorderRadius = todayBorderRadius;
+            this.viewTypes = exports.GanttViewType;
+            this.className = true;
+        }
+        Object.defineProperty(GanttCalendarComponent.prototype, "view", {
+            get: function () {
+                return this.ganttUpper.view;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        GanttCalendarComponent.prototype.setTodayPoint = function () {
+            var x = this.view.getTodayXPoint();
+            var today = new GanttDate().getDate();
+            var todayEle = this.elementRef.nativeElement.getElementsByClassName('gantt-calendar-today-overlay')[0];
+            var rect = this.elementRef.nativeElement.getElementsByClassName('today-rect')[0];
+            var line = this.elementRef.nativeElement.getElementsByClassName('today-line')[0];
+            if (isNumber(x)) {
+                if (rect) {
+                    rect.style.left = x - todayWidth / 2 + "px";
+                    rect.style.top = headerHeight - todayHeight + "px";
+                    rect.innerHTML = today.toString();
+                }
+                if (line) {
+                    line.style.left = x + "px";
+                    line.style.top = headerHeight + "px";
+                    line.style.bottom = -mainHeight + "px";
+                }
+            }
+            else {
+                todayEle.style.display = 'none';
+            }
+        };
+        GanttCalendarComponent.prototype.ngOnInit = function () {
+            var _this = this;
+            this.ngZone.onStable.pipe(operators.take(1)).subscribe(function () {
+                rxjs.merge(_this.ganttUpper.viewChange, _this.ganttUpper.view.start$)
+                    .pipe(operators.takeUntil(_this.unsubscribe$))
+                    .subscribe(function () {
+                    _this.setTodayPoint();
+                });
+            });
+        };
+        GanttCalendarComponent.prototype.ngAfterViewInit = function () { };
+        GanttCalendarComponent.prototype.ngOnChanges = function (changes) { };
+        GanttCalendarComponent.prototype.trackBy = function (point, index) {
+            return point.text || index;
+        };
+        GanttCalendarComponent.prototype.ngOnDestroy = function () {
+            this.unsubscribe$.next();
+            this.unsubscribe$.complete();
+        };
+        return GanttCalendarComponent;
+    }());
+    GanttCalendarComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttCalendarComponent, deps: [{ token: GANTT_UPPER_TOKEN }, { token: i0__namespace.NgZone }, { token: i0__namespace.ElementRef }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    GanttCalendarComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.1.2", type: GanttCalendarComponent, selector: "gantt-calendar-overlay", host: { properties: { "class.gantt-calendar-overlay": "this.className" } }, usesOnChanges: true, ngImport: i0__namespace, template: "<div class=\"gantt-calendar-today-overlay\" [style.width.px]=\"view.width\">\n  <span class=\"today-rect\" [hidden]=\"ganttUpper.viewType !== viewTypes.day\"> </span>\n  <span class=\"today-line\" *ngIf=\"ganttUpper.showTodayLine\"> </span>\n</div>\n\n<svg class=\"gantt-calendar-overlay-main\" [attr.width]=\"view.width\" [attr.height]=\"headerHeight\">\n  <g>\n    <text class=\"primary-text\" *ngFor=\"let point of view.primaryDatePoints; trackBy: trackBy\" [attr.x]=\"point.x\" [attr.y]=\"point.y\">\n      {{ point.text }}\n    </text>\n    <ng-container *ngFor=\"let point of view.secondaryDatePoints; trackBy: trackBy\">\n      <text class=\"secondary-text\" [class.secondary-text-weekend]=\"point.additions?.isWeekend\" [attr.x]=\"point.x\" [attr.y]=\"point.y\">\n        {{ point.text }}\n      </text>\n    </ng-container>\n\n    <g>\n      <line\n        *ngFor=\"let point of view.primaryDatePoints; let i = index; trackBy: trackBy\"\n        [attr.x1]=\"(i + 1) * view.primaryWidth\"\n        [attr.x2]=\"(i + 1) * view.primaryWidth\"\n        [attr.y1]=\"0\"\n        [attr.y2]=\"mainHeight\"\n        class=\"primary-line\"\n      ></line>\n    </g>\n\n    <g>\n      <line [attr.x1]=\"0\" [attr.x2]=\"view.width\" [attr.y1]=\"headerHeight\" [attr.y2]=\"headerHeight\" class=\"header-line\"></line>\n    </g>\n  </g>\n  <g>\n    <g *ngIf=\"view.showTimeline\">\n      <line\n        *ngFor=\"let point of view.secondaryDatePoints; let i = index; trackBy: trackBy\"\n        [attr.x1]=\"(i + 1) * view.cellWidth\"\n        [attr.x2]=\"(i + 1) * view.cellWidth\"\n        [attr.y1]=\"headerHeight\"\n        [attr.y2]=\"mainHeight\"\n        class=\"secondary-line\"\n      ></line>\n      <line\n        *ngFor=\"let point of view.primaryDatePoints; let i = index; trackBy: trackBy\"\n        [attr.x1]=\"(i + 1) * view.primaryWidth\"\n        [attr.x2]=\"(i + 1) * view.primaryWidth\"\n        [attr.y1]=\"0\"\n        [attr.y2]=\"mainHeight\"\n        class=\"primary-line\"\n      ></line>\n    </g>\n  </g>\n</svg>\n", directives: [{ type: i2__namespace.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2__namespace.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttCalendarComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: 'gantt-calendar-overlay',
+                        templateUrl: './calendar.component.html'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: GanttUpper, decorators: [{
+                            type: i0.Inject,
+                            args: [GANTT_UPPER_TOKEN]
+                        }] }, { type: i0__namespace.NgZone }, { type: i0__namespace.ElementRef }];
+        }, propDecorators: { className: [{
+                    type: i0.HostBinding,
+                    args: ['class.gantt-calendar-overlay']
+                }] } });
+
+    var GanttDragBackdropComponent = /** @class */ (function () {
+        function GanttDragBackdropComponent() {
+            this.backdropClass = true;
+        }
+        GanttDragBackdropComponent.prototype.ngOnInit = function () { };
+        return GanttDragBackdropComponent;
+    }());
+    GanttDragBackdropComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttDragBackdropComponent, deps: [], target: i0__namespace.ɵɵFactoryTarget.Component });
+    GanttDragBackdropComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.1.2", type: GanttDragBackdropComponent, selector: "gantt-drag-backdrop", host: { properties: { "class.gantt-drag-backdrop": "this.backdropClass" } }, ngImport: i0__namespace, template: "<div class=\"gantt-drag-mask\">\n  <div class=\"date-range\">\n    <span class=\"start\"></span>\n    <span class=\"end\"></span>\n  </div>\n</div>\n" });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttDragBackdropComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: 'gantt-drag-backdrop',
+                        templateUrl: "./drag-backdrop.component.html"
+                    }]
+            }], ctorParameters: function () { return []; }, propDecorators: { backdropClass: [{
+                    type: i0.HostBinding,
+                    args: ['class.gantt-drag-backdrop']
+                }] } });
+
+    var NgxGanttRootComponent = /** @class */ (function () {
+        function NgxGanttRootComponent(elementRef, ngZone, dom, dragContainer, ganttUpper, printService) {
+            this.elementRef = elementRef;
+            this.ngZone = ngZone;
+            this.dom = dom;
+            this.dragContainer = dragContainer;
+            this.ganttUpper = ganttUpper;
+            this.printService = printService;
+            this.ganttClass = true;
+            this.unsubscribe$ = new rxjs.Subject();
+            this.ganttUpper.dragContainer = dragContainer;
+        }
+        Object.defineProperty(NgxGanttRootComponent.prototype, "view", {
+            get: function () {
+                return this.ganttUpper.view;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        NgxGanttRootComponent.prototype.ngOnInit = function () {
+            var _this = this;
+            this.ngZone.onStable.pipe(operators.take(1)).subscribe(function () {
+                _this.dom.initialize(_this.elementRef);
+                if (_this.printService) {
+                    _this.printService.register(_this.elementRef);
+                }
+                _this.setupScrollClass();
+                _this.setupResize();
+                _this.setupViewScroll();
+                // 优化初始化时Scroll滚动体验问题，通过透明度解决，默认透明度为0，滚动结束后恢复
+                _this.elementRef.nativeElement.style.opacity = '1';
+                _this.ganttUpper.viewChange.pipe(operators.startWith(null)).subscribe(function () {
+                    _this.scrollToToday();
+                });
+            });
+        };
+        NgxGanttRootComponent.prototype.setupViewScroll = function () {
+            var _this = this;
+            if (this.ganttUpper.disabledLoadOnScroll) {
+                return;
+            }
+            this.dom
+                .getViewerScroll()
+                .pipe(operators.takeUntil(this.unsubscribe$))
+                .subscribe(function (event) {
+                if (event.direction === ScrollDirection.LEFT) {
+                    var dates_1 = _this.view.addStartDate();
+                    if (dates_1) {
+                        event.target.scrollLeft += _this.view.getDateRangeWidth(dates_1.start, dates_1.end);
+                        _this.ngZone.run(function () {
+                            _this.ganttUpper.loadOnScroll.emit({ start: dates_1.start.getUnixTime(), end: dates_1.end.getUnixTime() });
+                        });
+                    }
+                }
+                if (event.direction === ScrollDirection.RIGHT) {
+                    var dates_2 = _this.view.addEndDate();
+                    if (dates_2) {
+                        _this.ngZone.run(function () {
+                            _this.ganttUpper.loadOnScroll.emit({ start: dates_2.start.getUnixTime(), end: dates_2.end.getUnixTime() });
+                        });
+                    }
+                }
+            });
+        };
+        NgxGanttRootComponent.prototype.setupResize = function () {
+            var _this = this;
+            this.dom
+                .getResize()
+                .pipe(operators.takeUntil(this.unsubscribe$))
+                .subscribe(function () {
+                _this.setupScrollClass();
+            });
+        };
+        NgxGanttRootComponent.prototype.setupScrollClass = function () {
+            var mainContainer = this.dom.mainContainer;
+            var height = mainContainer.offsetHeight;
+            var scrollHeight = mainContainer.scrollHeight;
+            if (scrollHeight > height) {
+                this.elementRef.nativeElement.className = 'gantt gantt-scroll';
+            }
+            else {
+                this.elementRef.nativeElement.className = 'gantt';
+            }
+        };
+        NgxGanttRootComponent.prototype.scrollToToday = function () {
+            var x = this.view.getTodayXPoint();
+            this.dom.scrollMainContainer(x);
+        };
+        return NgxGanttRootComponent;
+    }());
+    NgxGanttRootComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttRootComponent, deps: [{ token: i0__namespace.ElementRef }, { token: i0__namespace.NgZone }, { token: GanttDomService }, { token: GanttDragContainer }, { token: GANTT_UPPER_TOKEN }, { token: GanttPrintService, optional: true }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    NgxGanttRootComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.1.2", type: NgxGanttRootComponent, selector: "ngx-gantt-root", inputs: { sideWidth: "sideWidth" }, host: { properties: { "class.gantt": "this.ganttClass" } }, providers: [GanttDomService, GanttDragContainer], queries: [{ propertyName: "sideTemplate", first: true, predicate: ["sideTemplate"], descendants: true, static: true }, { propertyName: "mainTemplate", first: true, predicate: ["mainTemplate"], descendants: true, static: true }], ngImport: i0__namespace, template: "<div class=\"gantt-side\" [style.width.px]=\"sideWidth\">\n  <div class=\"gantt-side-container\">\n    <ng-template [ngTemplateOutlet]=\"sideTemplate\"></ng-template>\n  </div>\n</div>\n<div class=\"gantt-container\">\n  <gantt-calendar-overlay></gantt-calendar-overlay>\n  <gantt-drag-backdrop></gantt-drag-backdrop>\n  <div class=\"gantt-main\">\n    <ng-template [ngTemplateOutlet]=\"mainTemplate\"></ng-template>\n  </div>\n</div>\n", components: [{ type: GanttCalendarComponent, selector: "gantt-calendar-overlay" }, { type: GanttDragBackdropComponent, selector: "gantt-drag-backdrop" }], directives: [{ type: i2__namespace.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }] });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttRootComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: 'ngx-gantt-root',
+                        templateUrl: './root.component.html',
+                        providers: [GanttDomService, GanttDragContainer]
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: i0__namespace.ElementRef }, { type: i0__namespace.NgZone }, { type: GanttDomService }, { type: GanttDragContainer }, { type: GanttUpper, decorators: [{
+                            type: i0.Inject,
+                            args: [GANTT_UPPER_TOKEN]
+                        }] }, { type: GanttPrintService, decorators: [{
+                            type: i0.Optional
+                        }] }];
+        }, propDecorators: { sideWidth: [{
+                    type: i0.Input
+                }], ganttClass: [{
+                    type: i0.HostBinding,
+                    args: ['class.gantt']
+                }], sideTemplate: [{
+                    type: i0.ContentChild,
+                    args: ['sideTemplate', { static: true }]
+                }], mainTemplate: [{
+                    type: i0.ContentChild,
+                    args: ['mainTemplate', { static: true }]
+                }] } });
+
+    var LinkColors;
+    (function (LinkColors) {
+        LinkColors["default"] = "#cacaca";
+        LinkColors["blocked"] = "#FF7575";
+        LinkColors["active"] = "#348FE4";
+    })(LinkColors || (LinkColors = {}));
+    var GanttLinksComponent = /** @class */ (function () {
+        function GanttLinksComponent(ganttUpper, cdr, elementRef, ganttDragContainer) {
+            this.ganttUpper = ganttUpper;
+            this.cdr = cdr;
+            this.elementRef = elementRef;
+            this.ganttDragContainer = ganttDragContainer;
+            this.groups = [];
+            this.items = [];
+            this.lineClick = new i0.EventEmitter();
+            this.links = [];
+            this.linkItems = [];
+            this.bezierWeight = -0.5;
+            this.firstChange = true;
+            this.unsubscribe$ = new rxjs.Subject();
+            this.ganttLinksOverlay = true;
+        }
+        GanttLinksComponent.prototype.ngOnInit = function () {
+            var _this = this;
+            this.buildLinks();
+            this.firstChange = false;
+            this.ganttDragContainer.dragStarted.pipe(operators.takeUntil(this.unsubscribe$)).subscribe(function () {
+                _this.elementRef.nativeElement.style.visibility = 'hidden';
+            });
+            rxjs.merge(this.ganttUpper.viewChange, this.ganttUpper.expandChange, this.ganttUpper.view.start$, this.ganttUpper.dragEnded, this.ganttUpper.linkDragEnded)
+                .pipe(operators.takeUntil(this.unsubscribe$), operators.skip(1))
+                .subscribe(function () {
+                _this.elementRef.nativeElement.style.visibility = 'visible';
+                _this.buildLinks();
+                _this.cdr.detectChanges();
+            });
+        };
+        GanttLinksComponent.prototype.ngOnChanges = function () {
+            if (!this.firstChange) {
+                this.buildLinks();
+            }
+        };
+        GanttLinksComponent.prototype.computeItemPosition = function () {
+            var _this = this;
+            var lineHeight = this.ganttUpper.styles.lineHeight;
+            var barHeight = this.ganttUpper.styles.barHeight;
+            this.linkItems = [];
+            if (this.groups.length > 0) {
+                var itemNum_1 = 0;
+                var groupNum_1 = 0;
+                this.groups.forEach(function (group) {
+                    groupNum_1++;
+                    if (group.expanded) {
+                        var items = recursiveItems(group.items);
+                        items.forEach(function (item, itemIndex) {
+                            var y = (groupNum_1 + itemNum_1 + itemIndex) * lineHeight + item.refs.y + barHeight / 2;
+                            _this.linkItems.push(Object.assign(Object.assign({}, item), { before: {
+                                    x: item.refs.x,
+                                    y: y
+                                }, after: {
+                                    x: item.refs.x + item.refs.width,
+                                    y: y
+                                } }));
+                        });
+                        itemNum_1 += items.length;
+                    }
+                });
+            }
+            else {
+                var items = recursiveItems(this.items);
+                items.forEach(function (item, itemIndex) {
+                    var y = itemIndex * lineHeight + item.refs.y + barHeight / 2;
+                    _this.linkItems.push(Object.assign(Object.assign({}, item), { before: {
+                            x: item.refs.x,
+                            y: y
+                        }, after: {
+                            x: item.refs.x + item.refs.width,
+                            y: y
+                        } }));
+                });
+            }
+        };
+        GanttLinksComponent.prototype.generatePath = function (source, target) {
+            if (source.before && source.after && target.before && target.after) {
+                var x1 = source.after.x;
+                var y1 = source.after.y;
+                var x4 = target.before.x;
+                var y4 = target.before.y;
+                var dx = Math.abs(x4 - x1) * this.bezierWeight;
+                var x2 = x1 - dx;
+                var x3 = x4 + dx;
+                var centerX = (x1 + x4) / 2;
+                var centerY = (y1 + y4) / 2;
+                var controlX = this.ganttUpper.styles.lineHeight / 2;
+                var controlY = this.ganttUpper.styles.lineHeight / 2;
+                if (x1 >= x4) {
+                    if (y4 > y1) {
+                        if (Math.abs(y4 - y1) <= this.ganttUpper.styles.lineHeight) {
+                            return "M " + x1 + " " + y1 + "\n                        C " + (x1 + controlX) + " " + y1 + " " + (x1 + controlX) + " " + (y1 + controlX) + " " + x1 + " " + (y1 + controlY) + "\n                        L " + x1 + " " + (y1 + controlY) + " " + centerX + " " + centerY + "\n\n                        M " + x4 + " " + y4 + "\n                        C " + (x4 - controlX) + " " + y4 + " " + (x4 - controlX) + " " + (y4 - controlX) + " " + x4 + " " + (y4 - controlY) + "\n                        L " + x4 + " " + (y4 - controlY) + " " + centerX + " " + centerY;
+                        }
+                        else {
+                            controlX = this.ganttUpper.styles.lineHeight;
+                            return "M " + x1 + " " + y1 + "\n                        C " + (x1 + controlX) + " " + y1 + " " + (x1 + controlX) + " " + (y1 + controlX) + " " + centerX + " " + centerY + "\n\n\n                        M " + x4 + " " + y4 + "\n                        C " + (x4 - controlX) + " " + y4 + " " + (x4 - controlX) + " " + (y4 - controlX) + " " + centerX + " " + centerY;
+                        }
+                    }
+                    else {
+                        if (Math.abs(y4 - y1) <= this.ganttUpper.styles.lineHeight) {
+                            return "M " + x1 + " " + y1 + "\n                        C " + (x1 + controlX) + " " + y1 + " " + (x1 + controlX) + " " + (y1 - controlX) + " " + x1 + " " + (y1 - controlY) + "\n                        L " + x1 + " " + (y1 - controlY) + " " + centerX + " " + centerY + "\n\n                        M " + x4 + " " + y4 + "\n                        C " + (x4 - controlX) + " " + y4 + " " + (x4 - controlX) + " " + (y4 + controlX) + " " + x4 + " " + (y4 + controlY) + "\n                        L " + x4 + " " + (y4 + controlY) + " " + centerX + " " + centerY + "\n                        ";
+                        }
+                        else {
+                            controlX = this.ganttUpper.styles.lineHeight;
+                            return "M " + x1 + " " + y1 + "\n                        C " + (x1 + controlX) + " " + y1 + " " + (x1 + controlX) + " " + (y1 - controlX) + " " + centerX + " " + centerY + "\n\n                        M " + x4 + " " + y4 + "\n                        C " + (x4 - controlX) + " " + y4 + " " + (x4 - controlX) + " " + (y4 + controlX) + " " + centerX + " " + centerY;
+                        }
+                    }
+                }
+                return "M " + x1 + " " + y1 + " C " + x2 + " " + y1 + " " + x3 + " " + y4 + " " + x4 + " " + y4;
+            }
+        };
+        GanttLinksComponent.prototype.buildLinks = function () {
+            var _this = this;
+            this.computeItemPosition();
+            this.links = [];
+            this.linkItems.forEach(function (source) {
+                if (source.origin.start || source.origin.end) {
+                    source.links.forEach(function (linkId) {
+                        var target = _this.linkItems.find(function (item) { return item.id === linkId; });
+                        if (target && (target.origin.start || target.origin.end)) {
+                            _this.links.push({
+                                path: _this.generatePath(source, target),
+                                source: source.origin,
+                                target: target.origin,
+                                color: source.end.getTime() > target.start.getTime() ? LinkColors.blocked : LinkColors.default
+                            });
+                        }
+                    });
+                }
+            });
+        };
+        GanttLinksComponent.prototype.trackBy = function (index) {
+            return index;
+        };
+        GanttLinksComponent.prototype.onLineClick = function (event, link) {
+            this.lineClick.emit({
+                event: event,
+                source: link.source,
+                target: link.target
+            });
+        };
+        GanttLinksComponent.prototype.mouseEnterPath = function (link) {
+            if (link.color === LinkColors.default) {
+                link.color = LinkColors.active;
+            }
+        };
+        GanttLinksComponent.prototype.mouseLeavePath = function (link) {
+            if (link.color === LinkColors.active) {
+                link.color = LinkColors.default;
+            }
+        };
+        GanttLinksComponent.prototype.ngOnDestroy = function () {
+            this.unsubscribe$.next();
+            this.unsubscribe$.complete();
+        };
+        return GanttLinksComponent;
+    }());
+    GanttLinksComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttLinksComponent, deps: [{ token: GANTT_UPPER_TOKEN }, { token: i0__namespace.ChangeDetectorRef }, { token: i0__namespace.ElementRef }, { token: GanttDragContainer }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    GanttLinksComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.1.2", type: GanttLinksComponent, selector: "gantt-links-overlay", inputs: { groups: "groups", items: "items" }, outputs: { lineClick: "lineClick" }, host: { properties: { "class.gantt-links-overlay": "this.ganttLinksOverlay" } }, usesOnChanges: true, ngImport: i0__namespace, template: "<svg [attr.width]=\"ganttUpper.view.width\" class=\"gantt-links-overlay-main\">\n  <ng-container *ngFor=\"let link of links; let i = index; trackBy: trackBy\">\n    <path [attr.d]=\"link.path\" fill=\"transparent\" stroke-width=\"2\" [attr.stroke]=\"link.color\" pointer-events=\"none\"></path>\n    <g>\n      <path\n        class=\"link-line\"\n        (click)=\"onLineClick($event, link)\"\n        (mouseenter)=\"mouseEnterPath(link)\"\n        (mouseleave)=\"mouseLeavePath(link)\"\n        [attr.d]=\"link.path\"\n        stroke=\"transparent\"\n        stroke-width=\"9\"\n        fill=\"none\"\n        cursor=\"pointer\"\n      ></path>\n    </g>\n  </ng-container>\n  <line class=\"link-dragging-line\"></line>\n</svg>\n", directives: [{ type: i2__namespace.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttLinksComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: 'gantt-links-overlay',
+                        templateUrl: './links.component.html'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: GanttUpper, decorators: [{
+                            type: i0.Inject,
+                            args: [GANTT_UPPER_TOKEN]
+                        }] }, { type: i0__namespace.ChangeDetectorRef }, { type: i0__namespace.ElementRef }, { type: GanttDragContainer }];
+        }, propDecorators: { groups: [{
+                    type: i0.Input
+                }], items: [{
+                    type: i0.Input
+                }], lineClick: [{
+                    type: i0.Output
+                }], ganttLinksOverlay: [{
+                    type: i0.HostBinding,
+                    args: ['class.gantt-links-overlay']
+                }] } });
+
+    var GanttItemUpper = /** @class */ (function () {
+        function GanttItemUpper(elementRef, ganttUpper) {
+            this.elementRef = elementRef;
+            this.ganttUpper = ganttUpper;
+            this.firstChange = true;
+            this.unsubscribe$ = new rxjs.Subject();
+        }
+        GanttItemUpper.prototype.onInit = function () {
+            var _this = this;
+            this.firstChange = false;
+            this.item.refs$.pipe(operators.takeUntil(this.unsubscribe$)).subscribe(function () {
+                _this.setPositions();
+            });
+        };
+        GanttItemUpper.prototype.onChanges = function () {
+            if (!this.firstChange) {
+                this.setPositions();
+            }
+        };
+        GanttItemUpper.prototype.setPositions = function () {
+            var itemElement = this.elementRef.nativeElement;
+            itemElement.style.left = this.item.refs.x + 'px';
+            itemElement.style.top = this.item.refs.y + 'px';
+            itemElement.style.width = this.item.refs.width + 'px';
+            if (this.item.type === exports.GanttItemType.bar) {
+                itemElement.style.height = this.ganttUpper.styles.barHeight + 'px';
+            }
+            else if (this.item.type === exports.GanttItemType.range) {
+                itemElement.style.height = rangeHeight + 'px';
+            }
+            else {
+            }
+        };
+        GanttItemUpper.prototype.onDestroy = function () {
+            this.unsubscribe$.next();
+            this.unsubscribe$.complete();
+        };
+        return GanttItemUpper;
+    }());
+    GanttItemUpper.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttItemUpper, deps: [{ token: i0__namespace.ElementRef }, { token: GANTT_UPPER_TOKEN }], target: i0__namespace.ɵɵFactoryTarget.Directive });
+    GanttItemUpper.ɵdir = i0__namespace.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.1.2", type: GanttItemUpper, inputs: { template: "template", item: "item" }, ngImport: i0__namespace });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttItemUpper, decorators: [{
+                type: i0.Directive
+            }], ctorParameters: function () {
+            return [{ type: i0__namespace.ElementRef }, { type: GanttUpper, decorators: [{
+                            type: i0.Inject,
+                            args: [GANTT_UPPER_TOKEN]
+                        }] }];
+        }, propDecorators: { template: [{
+                    type: i0.Input
+                }], item: [{
+                    type: i0.Input
+                }] } });
+
+    var NgxGanttRangeComponent = /** @class */ (function (_super) {
+        __extends(NgxGanttRangeComponent, _super);
+        function NgxGanttRangeComponent(elementRef, ganttUpper) {
+            var _this = _super.call(this, elementRef, ganttUpper) || this;
+            _this.ganttRangeClass = true;
+            return _this;
+        }
+        NgxGanttRangeComponent.prototype.ngOnInit = function () {
+            _super.prototype.onInit.call(this);
+        };
+        NgxGanttRangeComponent.prototype.ngOnChanges = function () {
+            _super.prototype.onChanges.call(this);
+        };
+        NgxGanttRangeComponent.prototype.ngOnDestroy = function () {
+            _super.prototype.onDestroy.call(this);
+        };
+        return NgxGanttRangeComponent;
+    }(GanttItemUpper));
+    NgxGanttRangeComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttRangeComponent, deps: [{ token: i0__namespace.ElementRef }, { token: GANTT_UPPER_TOKEN }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    NgxGanttRangeComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.1.2", type: NgxGanttRangeComponent, selector: "ngx-gantt-range,gantt-range", host: { properties: { "class.gantt-range": "this.ganttRangeClass" } }, usesInheritance: true, usesOnChanges: true, ngImport: i0__namespace, template: "<ng-container *ngIf=\"item.start && item.end\">\n  <div class=\"gantt-range-main\">\n    <div class=\"gantt-range-main-progress\" *ngIf=\"item.progress >= 0\" [style.width.%]=\"item.progress * 100\"></div>\n  </div>\n  <div class=\"gantt-range-triangle left\"></div>\n  <div class=\"gantt-range-triangle right\"></div>\n  <ng-template [ngTemplateOutlet]=\"template\" [ngTemplateOutletContext]=\"{ item: item.origin, refs: item.refs }\"></ng-template>\n</ng-container>\n", directives: [{ type: i2__namespace.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2__namespace.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }] });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttRangeComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: 'ngx-gantt-range,gantt-range',
+                        templateUrl: './range.component.html'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: i0__namespace.ElementRef }, { type: GanttUpper, decorators: [{
+                            type: i0.Inject,
+                            args: [GANTT_UPPER_TOKEN]
+                        }] }];
+        }, propDecorators: { ganttRangeClass: [{
+                    type: i0.HostBinding,
+                    args: ['class.gantt-range']
+                }] } });
+
+    var dragMinWidth = 10;
+    var activeClass = 'gantt-bar-active';
+    var linkDropClass = 'gantt-bar-link-drop';
+    function createSvgElement(qualifiedName, className) {
+        var element = document.createElementNS('http://www.w3.org/2000/svg', qualifiedName);
+        element.classList.add(className);
+        return element;
+    }
+    var GanttBarDrag = /** @class */ (function () {
+        function GanttBarDrag(dragDrop, dom, dragContainer) {
+            this.dragDrop = dragDrop;
+            this.dom = dom;
+            this.dragContainer = dragContainer;
+            this.dragRefs = [];
+            this.destroy$ = new rxjs.Subject();
+        }
+        Object.defineProperty(GanttBarDrag.prototype, "dragDisabled", {
+            get: function () {
+                return !this.item.draggable || !this.ganttUpper.draggable;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(GanttBarDrag.prototype, "linkDragDisabled", {
+            get: function () {
+                return !this.item.linkable || !this.ganttUpper.linkable;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        GanttBarDrag.prototype.createMouseEvents = function () {
+            var _this = this;
+            rxjs.fromEvent(this.barElement, 'mouseenter')
+                .pipe(operators.takeUntil(this.destroy$))
+                .subscribe(function () {
+                if (_this.dragContainer.linkDraggingId && _this.dragContainer.linkDraggingId !== _this.item.id) {
+                    if (_this.item.linkable) {
+                        _this.barElement.classList.add(linkDropClass);
+                        _this.dragContainer.emitLinkDragEntered(_this.item);
+                    }
+                }
+                else {
+                    _this.barElement.classList.add(activeClass);
+                }
+            });
+            rxjs.fromEvent(this.barElement, 'mouseleave')
+                .pipe(operators.takeUntil(this.destroy$))
+                .subscribe(function () {
+                if (!_this.dragContainer.linkDraggingId) {
+                    _this.barElement.classList.remove(activeClass);
+                }
+                else {
+                    _this.dragContainer.emitLinkDragLeaved();
+                }
+                _this.barElement.classList.remove(linkDropClass);
+            });
+        };
+        GanttBarDrag.prototype.createBarDrag = function () {
+            var _this = this;
+            var dragRef = this.dragDrop.createDrag(this.barElement);
+            dragRef.lockAxis = 'x';
+            dragRef.started.subscribe(function () {
+                _this.setDraggingStyles();
+                _this.dragContainer.dragStarted.emit({ item: _this.item.origin });
+            });
+            dragRef.moved.subscribe(function (event) {
+                var x = _this.item.refs.x + event.distance.x;
+                var days = dateFns.differenceInCalendarDays(_this.item.end.value, _this.item.start.value);
+                var start = _this.ganttUpper.view.getDateByXPoint(x);
+                var end = start.addDays(days);
+                _this.openDragBackdrop(_this.barElement, _this.ganttUpper.view.getDateByXPoint(x), end);
+            });
+            dragRef.ended.subscribe(function (event) {
+                var days = dateFns.differenceInCalendarDays(_this.item.end.value, _this.item.start.value);
+                var start = _this.ganttUpper.view.getDateByXPoint(_this.item.refs.x + event.distance.x);
+                var end = start.addDays(days);
+                _this.item.updateDate(start, end);
+                _this.clearDraggingStyles();
+                _this.closeDragBackdrop();
+                event.source.reset();
+                _this.dragContainer.dragEnded.emit({ item: _this.item.origin });
+            });
+            this.barDragRef = dragRef;
+            return dragRef;
+        };
+        GanttBarDrag.prototype.createBarHandleDrags = function () {
+            var _this = this;
+            var dragRefs = [];
+            var handles = this.barElement.querySelectorAll('.drag-handles .handle');
+            handles.forEach(function (handle, index) {
+                var isBefore = index === 0;
+                var dragRef = _this.dragDrop.createDrag(handle);
+                dragRef.lockAxis = 'x';
+                dragRef.withBoundaryElement(_this.dom.root);
+                dragRef.started.subscribe(function () {
+                    _this.setDraggingStyles();
+                    _this.dragContainer.dragStarted.emit({ item: _this.item.origin });
+                });
+                dragRef.moved.subscribe(function (event) {
+                    if (isBefore) {
+                        var x = _this.item.refs.x + event.distance.x;
+                        var width = _this.item.refs.width + event.distance.x * -1;
+                        if (width > dragMinWidth) {
+                            _this.barElement.style.width = width + 'px';
+                            _this.barElement.style.left = x + 'px';
+                            _this.openDragBackdrop(_this.barElement, _this.ganttUpper.view.getDateByXPoint(x), _this.ganttUpper.view.getDateByXPoint(x + width));
+                        }
+                    }
+                    else {
+                        var width = _this.item.refs.width + event.distance.x;
+                        if (width > dragMinWidth) {
+                            _this.barElement.style.width = width + 'px';
+                            _this.openDragBackdrop(_this.barElement, _this.ganttUpper.view.getDateByXPoint(_this.item.refs.x), _this.ganttUpper.view.getDateByXPoint(_this.item.refs.x + width));
+                        }
+                    }
+                    event.source.reset();
+                });
+                dragRef.ended.subscribe(function (event) {
+                    if (isBefore) {
+                        var width = _this.item.refs.width + event.distance.x * -1;
+                        if (width > dragMinWidth) {
+                            _this.item.updateDate(_this.ganttUpper.view.getDateByXPoint(_this.item.refs.x + event.distance.x), _this.item.end);
+                        }
+                        else {
+                            _this.item.updateDate(_this.item.end.startOfDay(), _this.item.end);
+                        }
+                    }
+                    else {
+                        var width = _this.item.refs.width + event.distance.x;
+                        if (width > dragMinWidth) {
+                            _this.item.updateDate(_this.item.start, _this.ganttUpper.view.getDateByXPoint(_this.item.refs.x + _this.item.refs.width + event.distance.x));
+                        }
+                        else {
+                            _this.item.updateDate(_this.item.start, _this.item.start.endOfDay());
+                        }
+                    }
+                    _this.clearDraggingStyles();
+                    _this.closeDragBackdrop();
+                    _this.dragContainer.dragEnded.emit({ item: _this.item.origin });
+                });
+                dragRefs.push(dragRef);
+            });
+            return dragRefs;
+        };
+        GanttBarDrag.prototype.createLinkHandleDrags = function () {
+            var _this = this;
+            var dragRefs = [];
+            var handles = this.barElement.querySelectorAll('.link-handles .handle');
+            handles.forEach(function (handle, index) {
+                var isBefore = index === 0;
+                var dragRef = _this.dragDrop.createDrag(handle);
+                dragRef.withBoundaryElement(_this.dom.root);
+                dragRef.beforeStarted.subscribe(function () {
+                    handle.style.pointerEvents = 'none';
+                    if (_this.barDragRef) {
+                        _this.barDragRef.disabled = true;
+                    }
+                    _this.createLinkDraggingLine();
+                    _this.dragContainer.emitLinkDragStarted(isBefore ? 'target' : 'source', _this.item);
+                });
+                dragRef.moved.subscribe(function () {
+                    var positions = _this.calcLinkLinePositions(handle, isBefore);
+                    _this.linkDraggingLine.setAttribute('x1', positions.x1.toString());
+                    _this.linkDraggingLine.setAttribute('y1', positions.y1.toString());
+                    _this.linkDraggingLine.setAttribute('x2', positions.x2.toString());
+                    _this.linkDraggingLine.setAttribute('y2', positions.y2.toString());
+                });
+                dragRef.ended.subscribe(function (event) {
+                    event.source.reset();
+                    handle.style.pointerEvents = '';
+                    if (_this.barDragRef) {
+                        _this.barDragRef.disabled = false;
+                    }
+                    _this.barElement.classList.remove(activeClass);
+                    _this.destroyLinkDraggingLine();
+                    _this.dragContainer.emitLinkDragEnded();
+                });
+                dragRefs.push(dragRef);
+            });
+            return dragRefs;
+        };
+        GanttBarDrag.prototype.openDragBackdrop = function (dragElement, start, end) {
+            var dragMaskElement = this.dom.root.querySelector('.gantt-drag-mask');
+            var dragBackdropElement = this.dom.root.querySelector('.gantt-drag-backdrop');
+            var rootRect = this.dom.root.getBoundingClientRect();
+            var dragRect = dragElement.getBoundingClientRect();
+            var left = dragRect.left - rootRect.left - this.dom.side.clientWidth;
+            var width = dragRect.right - dragRect.left;
+            dragMaskElement.style.left = left + 'px';
+            dragMaskElement.style.width = width + 'px';
+            dragMaskElement.querySelector('.start').innerHTML = start.format('MM-dd');
+            dragMaskElement.querySelector('.end').innerHTML = end.format('MM-dd');
+            dragMaskElement.style.display = 'block';
+            dragBackdropElement.style.display = 'block';
+        };
+        GanttBarDrag.prototype.closeDragBackdrop = function () {
+            var dragMaskElement = this.dom.root.querySelector('.gantt-drag-mask');
+            var dragBackdropElement = this.dom.root.querySelector('.gantt-drag-backdrop');
+            dragMaskElement.style.display = 'none';
+            dragBackdropElement.style.display = 'none';
+        };
+        GanttBarDrag.prototype.setDraggingStyles = function () {
+            this.barElement.style.pointerEvents = 'none';
+            this.barElement.classList.add('gantt-bar-draggable-drag');
+        };
+        GanttBarDrag.prototype.clearDraggingStyles = function () {
+            this.barElement.style.pointerEvents = '';
+            this.barElement.classList.remove('gantt-bar-draggable-drag');
+        };
+        GanttBarDrag.prototype.calcLinkLinePositions = function (target, isBefore) {
+            var rootRect = this.dom.root.getBoundingClientRect();
+            var targetRect = target.getBoundingClientRect();
+            var layerRect = target.parentElement.parentElement.getBoundingClientRect();
+            return {
+                x1: layerRect.left + (isBefore ? 0 : layerRect.width) - rootRect.left,
+                y1: layerRect.top + layerRect.height / 2 - rootRect.top,
+                x2: targetRect.left - rootRect.left + targetRect.width / 2,
+                y2: targetRect.top - rootRect.top + targetRect.height / 2
+            };
+        };
+        GanttBarDrag.prototype.createLinkDraggingLine = function () {
+            if (!this.linkDraggingLine) {
+                var svgElement = createSvgElement('svg', 'gantt-link-drag-container');
+                var linElement = createSvgElement('line', 'link-dragging-line');
+                svgElement.appendChild(linElement);
+                this.dom.root.appendChild(svgElement);
+                this.linkDraggingLine = linElement;
+            }
+        };
+        GanttBarDrag.prototype.destroyLinkDraggingLine = function () {
+            if (this.linkDraggingLine) {
+                this.linkDraggingLine.parentElement.remove();
+                this.linkDraggingLine = null;
+            }
+        };
+        GanttBarDrag.prototype.createDrags = function (elementRef, item, ganttUpper) {
+            var _a, _b;
+            this.item = item;
+            this.barElement = elementRef.nativeElement;
+            this.ganttUpper = ganttUpper;
+            if (!item.draggable || (this.dragDisabled && this.linkDragDisabled)) {
+                return;
+            }
+            else {
+                this.createMouseEvents();
+                if (!this.dragDisabled) {
+                    var dragRef = this.createBarDrag();
+                    var dragHandlesRefs = this.createBarHandleDrags();
+                    (_a = this.dragRefs).push.apply(_a, __spreadArray([dragRef], __read(dragHandlesRefs)));
+                }
+                if (!this.linkDragDisabled) {
+                    var linkDragRefs = this.createLinkHandleDrags();
+                    (_b = this.dragRefs).push.apply(_b, __spreadArray([], __read(linkDragRefs)));
+                }
+            }
+        };
+        GanttBarDrag.prototype.ngOnDestroy = function () {
+            this.closeDragBackdrop();
+            this.dragRefs.forEach(function (dragRef) { return dragRef.dispose(); });
+            this.destroy$.next();
+            this.destroy$.complete();
+        };
+        return GanttBarDrag;
+    }());
+    GanttBarDrag.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttBarDrag, deps: [{ token: i1__namespace.DragDrop }, { token: GanttDomService }, { token: GanttDragContainer }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    GanttBarDrag.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttBarDrag });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttBarDrag, decorators: [{
+                type: i0.Injectable
+            }], ctorParameters: function () { return [{ type: i1__namespace.DragDrop }, { type: GanttDomService }, { type: GanttDragContainer }]; } });
+
+    function linearGradient(sideOrCorner, color, stop) {
+        return "linear-gradient(" + sideOrCorner + "," + color + " 0%," + stop + " 40%)";
+    }
+    var NgxGanttBarComponent = /** @class */ (function (_super) {
+        __extends(NgxGanttBarComponent, _super);
+        function NgxGanttBarComponent(dragContainer, drag, elementRef, ganttUpper) {
+            var _this = _super.call(this, elementRef, ganttUpper) || this;
+            _this.dragContainer = dragContainer;
+            _this.drag = drag;
+            _this.ganttUpper = ganttUpper;
+            _this.barClick = new i0.EventEmitter();
+            _this.ganttItemClass = true;
+            _this.color = 'red';
+            return _this;
+        }
+        NgxGanttBarComponent.prototype.ngOnInit = function () {
+            var _this = this;
+            _super.prototype.onInit.call(this);
+            this.dragContainer.dragEnded.pipe(operators.takeUntil(this.unsubscribe$)).subscribe(function () {
+                _this.setContentBackground();
+            });
+        };
+        NgxGanttBarComponent.prototype.ngAfterViewInit = function () {
+            this.drag.createDrags(this.elementRef, this.item, this.ganttUpper);
+            this.setContentBackground();
+        };
+        NgxGanttBarComponent.prototype.ngOnChanges = function () {
+            _super.prototype.onChanges.call(this);
+        };
+        NgxGanttBarComponent.prototype.onBarClick = function (event) {
+            this.barClick.emit({ event: event, item: this.item.origin });
+        };
+        NgxGanttBarComponent.prototype.setContentBackground = function () {
+            var contentElement = this.contentElementRef.nativeElement;
+            var color = this.item.color || barBackground;
+            var style = this.item.barStyle || {};
+            if (this.item.origin.start && this.item.origin.end) {
+                style.background = color;
+                style.borderRadius = '';
+            }
+            if (this.item.origin.start && !this.item.origin.end) {
+                style.background = linearGradient('to left', hexToRgb(color, 0.55), hexToRgb(color, 1));
+                style.borderRadius = '4px 12.5px 12.5px 4px';
+            }
+            if (!this.item.origin.start && this.item.origin.end) {
+                style.background = linearGradient('to right', hexToRgb(color, 0.55), hexToRgb(color, 1));
+                style.borderRadius = '12.5px 4px 4px 12.5px';
+            }
+            if (this.item.progress >= 0) {
+                var contentProgressElement = contentElement.querySelector('.gantt-bar-content-progress');
+                style.background = hexToRgb(color, 0.3);
+                style.borderRadius = '';
+                contentProgressElement.style.background = color;
+            }
+            for (var key in style) {
+                if (style.hasOwnProperty(key)) {
+                    contentElement.style[key] = style[key];
+                }
+            }
+        };
+        NgxGanttBarComponent.prototype.stopPropagation = function (event) {
+            event.stopPropagation();
+        };
+        NgxGanttBarComponent.prototype.ngOnDestroy = function () {
+            _super.prototype.onDestroy.call(this);
+        };
+        return NgxGanttBarComponent;
+    }(GanttItemUpper));
+    NgxGanttBarComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttBarComponent, deps: [{ token: GanttDragContainer }, { token: GanttBarDrag }, { token: i0__namespace.ElementRef }, { token: GANTT_UPPER_TOKEN }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    NgxGanttBarComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.1.2", type: NgxGanttBarComponent, selector: "ngx-gantt-bar,gantt-bar", outputs: { barClick: "barClick" }, host: { properties: { "class.gantt-bar": "this.ganttItemClass" } }, providers: [GanttBarDrag], viewQueries: [{ propertyName: "contentElementRef", first: true, predicate: ["content"], descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0__namespace, template: "<div class=\"gantt-bar-layer\">\n  <div *ngIf=\"item.draggable && ganttUpper.draggable\" class=\"drag-handles\">\n    <ng-container>\n      <span class=\"handle\" (mousedown)=\"stopPropagation($event)\"></span>\n      <span class=\"handle\" (mousedown)=\"stopPropagation($event)\"></span>\n    </ng-container>\n  </div>\n  <div *ngIf=\"item.linkable && ganttUpper.linkable\" class=\"link-handles\">\n    <span class=\"handle\"><span class=\"point\"></span></span>\n    <span class=\"handle\"> <span class=\"point\"></span></span>\n  </div>\n</div>\n<div class=\"gantt-bar-border\"></div>\n<div #content class=\"gantt-bar-content\" (click)=\"onBarClick($event)\">\n  <div class=\"gantt-bar-content-progress\" *ngIf=\"item.progress >= 0\" [style.width.%]=\"item.progress * 100\"></div>\n  <ng-template [ngTemplateOutlet]=\"template\" [ngTemplateOutletContext]=\"{ item: item.origin, refs: item.refs }\"></ng-template>\n</div>\n", directives: [{ type: i2__namespace.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2__namespace.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }] });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttBarComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: 'ngx-gantt-bar,gantt-bar',
+                        templateUrl: './bar.component.html',
+                        providers: [GanttBarDrag]
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: GanttDragContainer }, { type: GanttBarDrag }, { type: i0__namespace.ElementRef }, { type: GanttUpper, decorators: [{
+                            type: i0.Inject,
+                            args: [GANTT_UPPER_TOKEN]
+                        }] }];
+        }, propDecorators: { barClick: [{
+                    type: i0.Output
+                }], contentElementRef: [{
+                    type: i0.ViewChild,
+                    args: ['content']
+                }], ganttItemClass: [{
+                    type: i0.HostBinding,
+                    args: ['class.gantt-bar']
+                }] } });
+
+    var GanttMainComponent = /** @class */ (function () {
+        function GanttMainComponent(ganttUpper) {
+            this.ganttUpper = ganttUpper;
+            this.barClick = new i0.EventEmitter();
+            this.lineClick = new i0.EventEmitter();
+            this.ganttMainClass = true;
+        }
+        GanttMainComponent.prototype.ngOnInit = function () { };
+        GanttMainComponent.prototype.trackBy = function (item, index) {
+            return item.id || index;
+        };
+        return GanttMainComponent;
+    }());
+    GanttMainComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttMainComponent, deps: [{ token: GANTT_UPPER_TOKEN }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    GanttMainComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.1.2", type: GanttMainComponent, selector: "gantt-main", inputs: { groups: "groups", items: "items", groupHeaderTemplate: "groupHeaderTemplate", itemTemplate: "itemTemplate", barTemplate: "barTemplate", rangeTemplate: "rangeTemplate" }, outputs: { barClick: "barClick", lineClick: "lineClick" }, host: { properties: { "class.gantt-main-container": "this.ganttMainClass" } }, ngImport: i0__namespace, template: "<gantt-links-overlay [groups]=\"groups\" [items]=\"items\" (lineClick)=\"lineClick.emit($event)\"></gantt-links-overlay>\n<!-- groups -->\n<div class=\"gantt-main-groups\" *ngIf=\"groups && groups.length > 0; else itemsTemplate\" [style.width.px]=\"ganttUpper.view.width\">\n  <ng-container *ngFor=\"let group of groups; trackBy: trackBy\">\n    <div class=\"gantt-group\" [ngClass]=\"group.class\">\n      <ng-template [ngTemplateOutlet]=\"groupHeaderTemplate\" [ngTemplateOutletContext]=\"{ group: group }\"></ng-template>\n    </div>\n    <div *ngIf=\"group.expanded\" class=\"gantt-items\">\n      <ng-template [ngTemplateOutlet]=\"ganttItems\" [ngTemplateOutletContext]=\"{ items: group.items }\"></ng-template>\n    </div>\n  </ng-container>\n</div>\n<!-- items -->\n<ng-template #itemsTemplate>\n  <div class=\"gantt-main-items\" [style.width.px]=\"ganttUpper.view.width\">\n    <ng-template [ngTemplateOutlet]=\"ganttItems\" [ngTemplateOutletContext]=\"{ items: items }\"></ng-template>\n  </div>\n</ng-template>\n\n<ng-template #ganttItems let-items=\"items\">\n  <ng-container *ngFor=\"let item of items; trackBy: trackBy\">\n    <div class=\"gantt-item\" [style.height.px]=\"ganttUpper.styles.lineHeight\">\n      <ng-container *ngIf=\"item.type | isGanttCustomItem\">\n        <ng-template [ngTemplateOutlet]=\"itemTemplate\" [ngTemplateOutletContext]=\"{ item: item.origin, refs: item.refs }\"></ng-template>\n      </ng-container>\n      <gantt-range *ngIf=\"item.type | isGanttRangeItem\" [template]=\"rangeTemplate\" [item]=\"item\"></gantt-range>\n      <gantt-bar *ngIf=\"item.type | isGanttBarItem\" [item]=\"item\" [template]=\"barTemplate\" (barClick)=\"barClick.emit($event)\"></gantt-bar>\n    </div>\n    <ng-template\n      *ngIf=\"item.children && item.expanded\"\n      [ngTemplateOutlet]=\"ganttItems\"\n      [ngTemplateOutletContext]=\"{ items: item.children }\"\n    ></ng-template>\n  </ng-container>\n</ng-template>\n", components: [{ type: GanttLinksComponent, selector: "gantt-links-overlay", inputs: ["groups", "items"], outputs: ["lineClick"] }, { type: NgxGanttRangeComponent, selector: "ngx-gantt-range,gantt-range" }, { type: NgxGanttBarComponent, selector: "ngx-gantt-bar,gantt-bar", outputs: ["barClick"] }], directives: [{ type: i2__namespace.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2__namespace.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2__namespace.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i2__namespace.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }], pipes: { "isGanttCustomItem": IsGanttCustomItemPipe, "isGanttRangeItem": IsGanttRangeItemPipe, "isGanttBarItem": IsGanttBarItemPipe } });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: GanttMainComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: 'gantt-main',
+                        templateUrl: './gantt-main.component.html'
+                    }]
+            }], ctorParameters: function () {
+            return [{ type: GanttUpper, decorators: [{
+                            type: i0.Inject,
+                            args: [GANTT_UPPER_TOKEN]
+                        }] }];
+        }, propDecorators: { groups: [{
+                    type: i0.Input
+                }], items: [{
+                    type: i0.Input
+                }], groupHeaderTemplate: [{
+                    type: i0.Input
+                }], itemTemplate: [{
+                    type: i0.Input
+                }], barTemplate: [{
+                    type: i0.Input
+                }], rangeTemplate: [{
+                    type: i0.Input
+                }], barClick: [{
+                    type: i0.Output
+                }], lineClick: [{
+                    type: i0.Output
+                }], ganttMainClass: [{
+                    type: i0.HostBinding,
+                    args: ['class.gantt-main-container']
+                }] } });
+
+    var NgxGanttComponent = /** @class */ (function (_super) {
+        __extends(NgxGanttComponent, _super);
+        function NgxGanttComponent(elementRef, cdr, ngZone) {
+            var _this = _super.call(this, elementRef, cdr, ngZone) || this;
+            _this.maxLevel = 2;
+            _this.linkDragStarted = new i0.EventEmitter();
+            _this.linkDragEnded = new i0.EventEmitter();
+            _this.lineClick = new i0.EventEmitter();
+            _this.ngUnsubscribe$ = new rxjs.Subject();
+            _this.sideTableWidth = sideWidth;
+            return _this;
+        }
+        NgxGanttComponent.prototype.ngOnInit = function () {
+            var _this = this;
+            _super.prototype.onInit.call(this);
+            this.ngZone.onStable.pipe(operators.take(1)).subscribe(function () {
+                _this.dragContainer.linkDragStarted.pipe(operators.takeUntil(_this.ngUnsubscribe$)).subscribe(function (event) {
+                    _this.linkDragStarted.emit(event);
+                });
+                _this.dragContainer.linkDragEnded.pipe(operators.takeUntil(_this.ngUnsubscribe$)).subscribe(function (event) {
+                    _this.linkDragEnded.emit(event);
+                });
+            });
+        };
+        NgxGanttComponent.prototype.ngAfterViewInit = function () {
+            var _this = this;
+            this.columns.changes.pipe(operators.startWith(true), operators.takeUntil(this.ngUnsubscribe$)).subscribe(function () {
+                _this.columns.forEach(function (column) {
+                    if (!column.columnWidth) {
+                        column.columnWidth = coercion.coerceCssPixelValue(defaultColumnWidth);
+                    }
+                });
+                _this.cdr.detectChanges();
+            });
+        };
+        NgxGanttComponent.prototype.ngOnChanges = function (changes) {
+            _super.prototype.onChanges.call(this, changes);
+        };
+        NgxGanttComponent.prototype.expandChildren = function (item) {
+            var _this = this;
+            if (!item.expanded) {
+                item.setExpand(true);
+                if (this.async && this.childrenResolve && item.children.length === 0) {
+                    item.loading = true;
+                    this.childrenResolve(item.origin)
+                        .pipe(operators.take(1), operators.finalize(function () {
+                        item.loading = false;
+                        _this.expandChange.emit();
+                        _this.cdr.detectChanges();
+                    }))
+                        .subscribe(function (items) {
+                        item.addChildren(items);
+                        _this.computeItemsRefs.apply(_this, __spreadArray([], __read(item.children)));
+                    });
+                }
+                else {
+                    this.computeItemsRefs.apply(this, __spreadArray([], __read(item.children)));
+                    this.expandChange.emit();
+                }
+            }
+            else {
+                item.setExpand(false);
+                this.expandChange.emit();
+            }
+        };
+        NgxGanttComponent.prototype.ngOnDestroy = function () {
+            _super.prototype.onDestroy.call(this);
+        };
+        return NgxGanttComponent;
+    }(GanttUpper));
+    NgxGanttComponent.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttComponent, deps: [{ token: i0__namespace.ElementRef }, { token: i0__namespace.ChangeDetectorRef }, { token: i0__namespace.NgZone }], target: i0__namespace.ɵɵFactoryTarget.Component });
+    NgxGanttComponent.ɵcmp = i0__namespace.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.1.2", type: NgxGanttComponent, selector: "ngx-gantt", inputs: { maxLevel: "maxLevel", async: "async", childrenResolve: "childrenResolve", linkable: "linkable" }, outputs: { linkDragStarted: "linkDragStarted", linkDragEnded: "linkDragEnded", lineClick: "lineClick" }, providers: [
+            {
+                provide: GANTT_UPPER_TOKEN,
+                useExisting: NgxGanttComponent
+            },
+            {
+                provide: GANTT_ABSTRACT_TOKEN,
+                useExisting: i0.forwardRef(function () { return NgxGanttComponent; })
+            }
+        ], queries: [{ propertyName: "table", first: true, predicate: NgxGanttTableComponent, descendants: true }, { propertyName: "tableEmptyTemplate", first: true, predicate: ["tableEmpty"], descendants: true, static: true }, { propertyName: "columns", predicate: NgxGanttTableColumnComponent, descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0__namespace, template: "<ngx-gantt-root>\n  <ng-template #sideTemplate>\n    <gantt-table [groups]=\"groups\" [items]=\"items\" [columns]=\"columns\" [groupTemplate]=\"groupTemplate\" [emptyTemplate]=\"tableEmptyTemplate\"></gantt-table>\n  </ng-template>\n  <ng-template #mainTemplate>\n    <gantt-main\n      [groups]=\"groups\"\n      [items]=\"items\"\n      [groupHeaderTemplate]=\"groupHeaderTemplate\"\n      [itemTemplate]=\"itemTemplate\"\n      [barTemplate]=\"barTemplate\"\n      [rangeTemplate]=\"rangeTemplate\"\n      (barClick)=\"barClick.emit($event)\"\n      (lineClick)=\"lineClick.emit($event)\"\n    >\n    </gantt-main>\n  </ng-template>\n</ngx-gantt-root>\n", components: [{ type: NgxGanttRootComponent, selector: "ngx-gantt-root", inputs: ["sideWidth"] }, { type: GanttTableComponent, selector: "gantt-table", inputs: ["groups", "items", "columns", "groupTemplate", "emptyTemplate"] }, { type: GanttMainComponent, selector: "gantt-main", inputs: ["groups", "items", "groupHeaderTemplate", "itemTemplate", "barTemplate", "rangeTemplate"], outputs: ["barClick", "lineClick"] }], changeDetection: i0__namespace.ChangeDetectionStrategy.OnPush });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttComponent, decorators: [{
+                type: i0.Component,
+                args: [{
+                        selector: 'ngx-gantt',
+                        templateUrl: './gantt.component.html',
+                        changeDetection: i0.ChangeDetectionStrategy.OnPush,
+                        providers: [
+                            {
+                                provide: GANTT_UPPER_TOKEN,
+                                useExisting: NgxGanttComponent
+                            },
+                            {
+                                provide: GANTT_ABSTRACT_TOKEN,
+                                useExisting: i0.forwardRef(function () { return NgxGanttComponent; })
+                            }
+                        ]
+                    }]
+            }], ctorParameters: function () { return [{ type: i0__namespace.ElementRef }, { type: i0__namespace.ChangeDetectorRef }, { type: i0__namespace.NgZone }]; }, propDecorators: { maxLevel: [{
+                    type: i0.Input
+                }], async: [{
+                    type: i0.Input
+                }], childrenResolve: [{
+                    type: i0.Input
+                }], linkable: [{
+                    type: i0.Input
+                }], linkDragStarted: [{
+                    type: i0.Output
+                }], linkDragEnded: [{
+                    type: i0.Output
+                }], lineClick: [{
+                    type: i0.Output
+                }], table: [{
+                    type: i0.ContentChild,
+                    args: [NgxGanttTableComponent]
+                }], columns: [{
+                    type: i0.ContentChildren,
+                    args: [NgxGanttTableColumnComponent, { descendants: true }]
+                }], tableEmptyTemplate: [{
+                    type: i0.ContentChild,
+                    args: ['tableEmpty', { static: true }]
+                }] } });
+
+    var NgxGanttModule = /** @class */ (function () {
+        function NgxGanttModule() {
+        }
+        return NgxGanttModule;
+    }());
+    NgxGanttModule.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttModule, deps: [], target: i0__namespace.ɵɵFactoryTarget.NgModule });
+    NgxGanttModule.ɵmod = i0__namespace.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttModule, declarations: [NgxGanttComponent,
+            NgxGanttTableComponent,
+            NgxGanttTableColumnComponent,
+            GanttTableComponent,
+            GanttMainComponent,
+            GanttCalendarComponent,
+            GanttLinksComponent,
+            NgxGanttBarComponent,
+            GanttIconComponent,
+            GanttDragBackdropComponent,
+            NgxGanttRangeComponent,
+            NgxGanttRootComponent,
+            IsGanttRangeItemPipe,
+            IsGanttBarItemPipe,
+            IsGanttCustomItemPipe], imports: [i2.CommonModule, i1.DragDropModule], exports: [NgxGanttComponent,
+            NgxGanttTableComponent,
+            NgxGanttTableColumnComponent,
+            NgxGanttRootComponent,
+            NgxGanttBarComponent,
+            NgxGanttRangeComponent] });
+    NgxGanttModule.ɵinj = i0__namespace.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttModule, providers: [], imports: [[i2.CommonModule, i1.DragDropModule]] });
+    i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.2", ngImport: i0__namespace, type: NgxGanttModule, decorators: [{
+                type: i0.NgModule,
+                args: [{
+                        imports: [i2.CommonModule, i1.DragDropModule],
+                        exports: [
+                            NgxGanttComponent,
+                            NgxGanttTableComponent,
+                            NgxGanttTableColumnComponent,
+                            NgxGanttRootComponent,
+                            NgxGanttBarComponent,
+                            NgxGanttRangeComponent
+                        ],
+                        declarations: [
+                            NgxGanttComponent,
+                            NgxGanttTableComponent,
+                            NgxGanttTableColumnComponent,
+                            GanttTableComponent,
+                            GanttMainComponent,
+                            GanttCalendarComponent,
+                            GanttLinksComponent,
+                            NgxGanttBarComponent,
+                            GanttIconComponent,
+                            GanttDragBackdropComponent,
+                            NgxGanttRangeComponent,
+                            NgxGanttRootComponent,
+                            IsGanttRangeItemPipe,
+                            IsGanttBarItemPipe,
+                            IsGanttCustomItemPipe
+                        ],
+                        providers: []
+                    }]
+            }] });
+
+    /*
+     * Public API Surface of gantt
+     */
+
+    /**
+     * Generated bundle index. Do not edit.
+     */
+
+    Object.defineProperty(exports, 'addDays', {
+        enumerable: true,
+        get: function () {
+            return dateFns.addDays;
+        }
+    });
+    Object.defineProperty(exports, 'addHours', {
+        enumerable: true,
+        get: function () {
+            return dateFns.addHours;
+        }
+    });
+    Object.defineProperty(exports, 'addMinutes', {
+        enumerable: true,
+        get: function () {
+            return dateFns.addMinutes;
+        }
+    });
+    Object.defineProperty(exports, 'addMonths', {
+        enumerable: true,
+        get: function () {
+            return dateFns.addMonths;
+        }
+    });
+    Object.defineProperty(exports, 'addQuarters', {
+        enumerable: true,
+        get: function () {
+            return dateFns.addQuarters;
+        }
+    });
+    Object.defineProperty(exports, 'addSeconds', {
+        enumerable: true,
+        get: function () {
+            return dateFns.addSeconds;
+        }
+    });
+    Object.defineProperty(exports, 'addWeeks', {
+        enumerable: true,
+        get: function () {
+            return dateFns.addWeeks;
+        }
+    });
+    Object.defineProperty(exports, 'addYears', {
+        enumerable: true,
+        get: function () {
+            return dateFns.addYears;
+        }
+    });
+    Object.defineProperty(exports, 'differenceInCalendarDays', {
+        enumerable: true,
+        get: function () {
+            return dateFns.differenceInCalendarDays;
+        }
+    });
+    Object.defineProperty(exports, 'differenceInCalendarQuarters', {
+        enumerable: true,
+        get: function () {
+            return dateFns.differenceInCalendarQuarters;
+        }
+    });
+    Object.defineProperty(exports, 'differenceInDays', {
+        enumerable: true,
+        get: function () {
+            return dateFns.differenceInDays;
+        }
+    });
+    Object.defineProperty(exports, 'eachDayOfInterval', {
+        enumerable: true,
+        get: function () {
+            return dateFns.eachDayOfInterval;
+        }
+    });
+    Object.defineProperty(exports, 'eachMonthOfInterval', {
+        enumerable: true,
+        get: function () {
+            return dateFns.eachMonthOfInterval;
+        }
+    });
+    Object.defineProperty(exports, 'eachWeekOfInterval', {
+        enumerable: true,
+        get: function () {
+            return dateFns.eachWeekOfInterval;
+        }
+    });
+    Object.defineProperty(exports, 'endOfDay', {
+        enumerable: true,
+        get: function () {
+            return dateFns.endOfDay;
+        }
+    });
+    Object.defineProperty(exports, 'endOfMonth', {
+        enumerable: true,
+        get: function () {
+            return dateFns.endOfMonth;
+        }
+    });
+    Object.defineProperty(exports, 'endOfQuarter', {
+        enumerable: true,
+        get: function () {
+            return dateFns.endOfQuarter;
+        }
+    });
+    Object.defineProperty(exports, 'endOfWeek', {
+        enumerable: true,
+        get: function () {
+            return dateFns.endOfWeek;
+        }
+    });
+    Object.defineProperty(exports, 'endOfYear', {
+        enumerable: true,
+        get: function () {
+            return dateFns.endOfYear;
+        }
+    });
+    Object.defineProperty(exports, 'format', {
+        enumerable: true,
+        get: function () {
+            return dateFns.format;
+        }
+    });
+    Object.defineProperty(exports, 'fromUnixTime', {
+        enumerable: true,
+        get: function () {
+            return dateFns.fromUnixTime;
+        }
+    });
+    Object.defineProperty(exports, 'getDaysInMonth', {
+        enumerable: true,
+        get: function () {
+            return dateFns.getDaysInMonth;
+        }
+    });
+    Object.defineProperty(exports, 'getUnixTime', {
+        enumerable: true,
+        get: function () {
+            return dateFns.getUnixTime;
+        }
+    });
+    Object.defineProperty(exports, 'getWeek', {
+        enumerable: true,
+        get: function () {
+            return dateFns.getWeek;
+        }
+    });
+    Object.defineProperty(exports, 'isToday', {
+        enumerable: true,
+        get: function () {
+            return dateFns.isToday;
+        }
+    });
+    Object.defineProperty(exports, 'isWeekend', {
+        enumerable: true,
+        get: function () {
+            return dateFns.isWeekend;
+        }
+    });
+    Object.defineProperty(exports, 'setDate', {
+        enumerable: true,
+        get: function () {
+            return dateFns.setDate;
+        }
+    });
+    Object.defineProperty(exports, 'startOfDay', {
+        enumerable: true,
+        get: function () {
+            return dateFns.startOfDay;
+        }
+    });
+    Object.defineProperty(exports, 'startOfMonth', {
+        enumerable: true,
+        get: function () {
+            return dateFns.startOfMonth;
+        }
+    });
+    Object.defineProperty(exports, 'startOfQuarter', {
+        enumerable: true,
+        get: function () {
+            return dateFns.startOfQuarter;
+        }
+    });
+    Object.defineProperty(exports, 'startOfWeek', {
+        enumerable: true,
+        get: function () {
+            return dateFns.startOfWeek;
+        }
+    });
+    Object.defineProperty(exports, 'startOfYear', {
+        enumerable: true,
+        get: function () {
+            return dateFns.startOfYear;
+        }
+    });
+    exports.GANTT_UPPER_TOKEN = GANTT_UPPER_TOKEN;
+    exports.GanttBarClickEvent = GanttBarClickEvent;
+    exports.GanttDate = GanttDate;
+    exports.GanttDatePoint = GanttDatePoint;
+    exports.GanttDragEvent = GanttDragEvent;
+    exports.GanttGroupInternal = GanttGroupInternal;
+    exports.GanttItemInternal = GanttItemInternal;
+    exports.GanttItemUpper = GanttItemUpper;
+    exports.GanttLineClickEvent = GanttLineClickEvent;
+    exports.GanttLinkDragEvent = GanttLinkDragEvent;
+    exports.GanttLoadOnScrollEvent = GanttLoadOnScrollEvent;
+    exports.GanttPrintService = GanttPrintService;
+    exports.GanttTableEvent = GanttTableEvent;
+    exports.GanttUpper = GanttUpper;
+    exports.GanttView = GanttView;
+    exports.IsGanttBarItemPipe = IsGanttBarItemPipe;
+    exports.IsGanttCustomItemPipe = IsGanttCustomItemPipe;
+    exports.IsGanttRangeItemPipe = IsGanttRangeItemPipe;
+    exports.NgxGanttBarComponent = NgxGanttBarComponent;
+    exports.NgxGanttComponent = NgxGanttComponent;
+    exports.NgxGanttModule = NgxGanttModule;
+    exports.NgxGanttRangeComponent = NgxGanttRangeComponent;
+    exports.NgxGanttRootComponent = NgxGanttRootComponent;
+    exports.NgxGanttTableColumnComponent = NgxGanttTableColumnComponent;
+    exports.NgxGanttTableComponent = NgxGanttTableComponent;
+    exports.primaryDatePointTop = primaryDatePointTop;
+    exports.secondaryDatePointTop = secondaryDatePointTop;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=worktile-gantt.umd.js.map