(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs'), require('rxjs/operators'), require('@angular/cdk/collections'), require('@angular/cdk/coercion'), require('@angular/cdk/tree'), require('@angular/core'), require('@angular/common')) :
    typeof define === 'function' && define.amd ? define('@ng-tangram/components/tree', ['exports', 'rxjs', 'rxjs/operators', '@angular/cdk/collections', '@angular/cdk/coercion', '@angular/cdk/tree', '@angular/core', '@angular/common'], factory) :
    (global = global || self, factory((global.nt = global.nt || {}, global.nt.components = global.nt.components || {}, global.nt.components.tree = {}), global.rxjs, global.rxjs.operators, global.ng.cdk.collections, global.ng.cdk.coercion, global.ng.cdk.tree, global.ng.core, global.ng.common));
}(this, (function (exports, rxjs, operators, collections, coercion, tree, core, common) { 'use strict';

    var __extends = (this && this.__extends) || (function () {
        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 (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var __read = (this && this.__read) || function (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;
    };
    var __spread = (this && this.__spread) || function () {
        for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
        return ar;
    };
    var NtTreeNestedDataSource = (function (_super) {
        __extends(NtTreeNestedDataSource, _super);
        function NtTreeNestedDataSource() {
            var _this = _super !== null && _super.apply(this, arguments) || this;
            _this._data = new rxjs.BehaviorSubject([]);
            return _this;
        }
        Object.defineProperty(NtTreeNestedDataSource.prototype, "data", {
            get: function () { return this._data.value; },
            set: function (value) { this._data.next(value); },
            enumerable: true,
            configurable: true
        });
        NtTreeNestedDataSource.prototype.connect = function (collectionViewer) {
            var _this = this;
            return rxjs.merge.apply(void 0, __spread([collectionViewer.viewChange, this._data])).pipe(operators.map(function () { return _this.data; }));
        };
        NtTreeNestedDataSource.prototype.disconnect = function () {
        };
        return NtTreeNestedDataSource;
    }(collections.DataSource));

    var __extends$1 = (this && this.__extends) || (function () {
        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 (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var __read$1 = (this && this.__read) || function (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;
    };
    var __spread$1 = (this && this.__spread) || function () {
        for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read$1(arguments[i]));
        return ar;
    };
    var NtTreeFlattener = (function () {
        function NtTreeFlattener(transformFunction, getLevel, isExpandable, getChildren) {
            this.transformFunction = transformFunction;
            this.getLevel = getLevel;
            this.isExpandable = isExpandable;
            this.getChildren = getChildren;
        }
        NtTreeFlattener.prototype._flattenNode = function (node, level, resultNodes, parentMap) {
            var _this = this;
            var flatNode = this.transformFunction(node, level);
            resultNodes.push(flatNode);
            if (this.isExpandable(flatNode)) {
                var childrenNodes = this.getChildren(node);
                if (Array.isArray(childrenNodes)) {
                    this._flattenChildren(childrenNodes, level, resultNodes, parentMap);
                }
                else {
                    childrenNodes.pipe(operators.take(1)).subscribe(function (children) {
                        _this._flattenChildren(children, level, resultNodes, parentMap);
                    });
                }
            }
            return resultNodes;
        };
        NtTreeFlattener.prototype._flattenChildren = function (children, level, resultNodes, parentMap) {
            var _this = this;
            children.forEach(function (child, index) {
                var childParentMap = parentMap.slice();
                childParentMap.push(index !== children.length - 1);
                _this._flattenNode(child, level + 1, resultNodes, childParentMap);
            });
        };
        NtTreeFlattener.prototype.flattenNodes = function (structuredData) {
            var _this = this;
            var resultNodes = [];
            structuredData.forEach(function (node) { return _this._flattenNode(node, 0, resultNodes, []); });
            return resultNodes;
        };
        NtTreeFlattener.prototype.expandFlattenedNodes = function (nodes, treeControl) {
            var _this = this;
            var results = [];
            var currentExpand = [];
            currentExpand[0] = true;
            nodes.forEach(function (node) {
                var expand = true;
                for (var i = 0; i <= _this.getLevel(node); i++) {
                    expand = expand && currentExpand[i];
                }
                if (expand) {
                    results.push(node);
                }
                if (_this.isExpandable(node)) {
                    currentExpand[_this.getLevel(node) + 1] = treeControl.isExpanded(node);
                }
            });
            return results;
        };
        return NtTreeFlattener;
    }());
    var NtTreeFlatDataSource = (function (_super) {
        __extends$1(NtTreeFlatDataSource, _super);
        function NtTreeFlatDataSource(treeControl, treeFlattener, initialData) {
            if (initialData === void 0) { initialData = []; }
            var _this = _super.call(this) || this;
            _this.treeControl = treeControl;
            _this.treeFlattener = treeFlattener;
            _this._flattenedData = new rxjs.BehaviorSubject([]);
            _this._expandedData = new rxjs.BehaviorSubject([]);
            _this._data = new rxjs.BehaviorSubject(initialData);
            return _this;
        }
        Object.defineProperty(NtTreeFlatDataSource.prototype, "data", {
            get: function () { return this._data.value; },
            set: function (value) {
                this._data.next(value);
                this._flattenedData.next(this.treeFlattener.flattenNodes(this.data));
                this.treeControl.dataNodes = this._flattenedData.value;
            },
            enumerable: true,
            configurable: true
        });
        NtTreeFlatDataSource.prototype.connect = function (collectionViewer) {
            var _this = this;
            var changes = [
                collectionViewer.viewChange,
                this.treeControl.expansionModel.changed,
                this._flattenedData
            ];
            return rxjs.merge.apply(void 0, __spread$1(changes)).pipe(operators.map(function () {
                _this._expandedData.next(_this.treeFlattener.expandFlattenedNodes(_this._flattenedData.value, _this.treeControl));
                return _this._expandedData.value;
            }));
        };
        NtTreeFlatDataSource.prototype.disconnect = function () { };
        return NtTreeFlatDataSource;
    }(collections.DataSource));

    var __extends$2 = (this && this.__extends) || (function () {
        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 (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var __decorate = (this && this.__decorate) || function (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;
    };
    var __param = (this && this.__param) || function (paramIndex, decorator) {
        return function (target, key) { decorator(target, key, paramIndex); }
    };
    var NtTreeNodeDirective = (function (_super) {
        __extends$2(NtTreeNodeDirective, _super);
        function NtTreeNodeDirective(_elementRef, _tree, tabIndex) {
            var _this = _super.call(this, _elementRef, _tree) || this;
            _this._elementRef = _elementRef;
            _this._tree = _tree;
            _this._disabled = false;
            _this._tabIndex = 0;
            _this.role = 'treeitem';
            _this.tabIndex = Number(tabIndex) || 0;
            return _this;
        }
        NtTreeNodeDirective_1 = NtTreeNodeDirective;
        Object.defineProperty(NtTreeNodeDirective.prototype, "disabled", {
            get: function () { return this._disabled; },
            set: function (value) { this._disabled = coercion.coerceBooleanProperty(value); },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(NtTreeNodeDirective.prototype, "tabIndex", {
            get: function () { return this.disabled ? -1 : this._tabIndex; },
            set: function (value) { this._tabIndex = value != null ? value : 0; },
            enumerable: true,
            configurable: true
        });
        var NtTreeNodeDirective_1;
        NtTreeNodeDirective.ctorParameters = function () { return [
            { type: core.ElementRef },
            { type: tree.CdkTree },
            { type: String, decorators: [{ type: core.Attribute, args: ['tabindex',] }] }
        ]; };
        __decorate([
            core.Input()
        ], NtTreeNodeDirective.prototype, "role", void 0);
        NtTreeNodeDirective = NtTreeNodeDirective_1 = __decorate([
            core.Directive({
                selector: 'nt-tree-node, [nt-tree-node]',
                exportAs: 'ntTreeNode',
                inputs: ['disabled', 'tabIndex'],
                host: {
                    'class': 'nt-tree-node'
                },
                providers: [{ provide: tree.CdkTreeNode, useExisting: NtTreeNodeDirective_1 }]
            }),
            __param(2, core.Attribute('tabindex'))
        ], NtTreeNodeDirective);
        return NtTreeNodeDirective;
    }(tree.CdkTreeNode));
    var NtTreeNodeDefDirective = (function (_super) {
        __extends$2(NtTreeNodeDefDirective, _super);
        function NtTreeNodeDefDirective() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        NtTreeNodeDefDirective_1 = NtTreeNodeDefDirective;
        var NtTreeNodeDefDirective_1;
        __decorate([
            core.Input('ntTreeNode')
        ], NtTreeNodeDefDirective.prototype, "data", void 0);
        NtTreeNodeDefDirective = NtTreeNodeDefDirective_1 = __decorate([
            core.Directive({
                selector: '[ntTreeNodeDef]',
                inputs: [
                    'when: ntTreeNodeDefWhen'
                ],
                providers: [{ provide: tree.CdkTreeNodeDef, useExisting: NtTreeNodeDefDirective_1 }]
            })
        ], NtTreeNodeDefDirective);
        return NtTreeNodeDefDirective;
    }(tree.CdkTreeNodeDef));
    var NtNestedTreeNodeDirective = (function (_super) {
        __extends$2(NtNestedTreeNodeDirective, _super);
        function NtNestedTreeNodeDirective(_elementRef, _tree, _differs, tabIndex) {
            var _this = _super.call(this, _elementRef, _tree, _differs) || this;
            _this._elementRef = _elementRef;
            _this._tree = _tree;
            _this._differs = _differs;
            _this._disabled = false;
            _this._tabIndex = 0;
            _this.tabIndex = Number(tabIndex) || 0;
            return _this;
        }
        NtNestedTreeNodeDirective_1 = NtNestedTreeNodeDirective;
        Object.defineProperty(NtNestedTreeNodeDirective.prototype, "disabled", {
            get: function () { return this._disabled; },
            set: function (value) { this._disabled = coercion.coerceBooleanProperty(value); },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(NtNestedTreeNodeDirective.prototype, "tabIndex", {
            get: function () { return this.disabled ? -1 : this._tabIndex; },
            set: function (value) { this._tabIndex = value != null ? value : 0; },
            enumerable: true,
            configurable: true
        });
        NtNestedTreeNodeDirective.prototype.ngAfterContentInit = function () {
            _super.prototype.ngAfterContentInit.call(this);
        };
        NtNestedTreeNodeDirective.prototype.ngOnDestroy = function () {
            _super.prototype.ngOnDestroy.call(this);
        };
        var NtNestedTreeNodeDirective_1;
        NtNestedTreeNodeDirective.ctorParameters = function () { return [
            { type: core.ElementRef },
            { type: tree.CdkTree },
            { type: core.IterableDiffers },
            { type: String, decorators: [{ type: core.Attribute, args: ['tabindex',] }] }
        ]; };
        __decorate([
            core.Input('ntNestedTreeNode')
        ], NtNestedTreeNodeDirective.prototype, "node", void 0);
        NtNestedTreeNodeDirective = NtNestedTreeNodeDirective_1 = __decorate([
            core.Directive({
                selector: 'nt-nested-tree-node, [nt-nested-tree-node]',
                exportAs: 'ntNestedTreeNode',
                host: {
                    'class': 'nt-nested-tree-node',
                },
                inputs: ['disabled', 'tabIndex'],
                providers: [
                    { provide: tree.CdkNestedTreeNode, useExisting: NtNestedTreeNodeDirective_1 },
                    { provide: tree.CdkTreeNode, useExisting: NtNestedTreeNodeDirective_1 }
                ]
            }),
            __param(3, core.Attribute('tabindex'))
        ], NtNestedTreeNodeDirective);
        return NtNestedTreeNodeDirective;
    }(tree.CdkNestedTreeNode));

    var __decorate$1 = (this && this.__decorate) || function (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;
    };
    var __param$1 = (this && this.__param) || function (paramIndex, decorator) {
        return function (target, key) { decorator(target, key, paramIndex); }
    };
    var NtTreeNodeOutletDirective = (function () {
        function NtTreeNodeOutletDirective(viewContainer, _node) {
            this.viewContainer = viewContainer;
            this._node = _node;
        }
        NtTreeNodeOutletDirective_1 = NtTreeNodeOutletDirective;
        var NtTreeNodeOutletDirective_1;
        NtTreeNodeOutletDirective.ctorParameters = function () { return [
            { type: core.ViewContainerRef },
            { type: undefined, decorators: [{ type: core.Inject, args: [tree.CDK_TREE_NODE_OUTLET_NODE,] }, { type: core.Optional }] }
        ]; };
        NtTreeNodeOutletDirective = NtTreeNodeOutletDirective_1 = __decorate$1([
            core.Directive({
                selector: '[ntTreeNodeOutlet]',
                providers: [
                    { provide: tree.CdkTreeNodeOutlet, useExisting: NtTreeNodeOutletDirective_1 }
                ]
            }),
            __param$1(1, core.Inject(tree.CDK_TREE_NODE_OUTLET_NODE)), __param$1(1, core.Optional())
        ], NtTreeNodeOutletDirective);
        return NtTreeNodeOutletDirective;
    }());

    var __extends$3 = (this && this.__extends) || (function () {
        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 (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var __decorate$2 = (this && this.__decorate) || function (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;
    };
    var NtTreeNodePaddingDirective = (function (_super) {
        __extends$3(NtTreeNodePaddingDirective, _super);
        function NtTreeNodePaddingDirective() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        NtTreeNodePaddingDirective_1 = NtTreeNodePaddingDirective;
        var NtTreeNodePaddingDirective_1;
        __decorate$2([
            core.Input('ntTreeNodePadding')
        ], NtTreeNodePaddingDirective.prototype, "level", void 0);
        __decorate$2([
            core.Input('ntTreeNodePaddingIndent')
        ], NtTreeNodePaddingDirective.prototype, "indent", void 0);
        NtTreeNodePaddingDirective = NtTreeNodePaddingDirective_1 = __decorate$2([
            core.Directive({
                selector: '[ntTreeNodePadding]',
                providers: [{ provide: tree.CdkTreeNodePadding, useExisting: NtTreeNodePaddingDirective_1 }]
            })
        ], NtTreeNodePaddingDirective);
        return NtTreeNodePaddingDirective;
    }(tree.CdkTreeNodePadding));

    var __extends$4 = (this && this.__extends) || (function () {
        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 (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var __decorate$3 = (this && this.__decorate) || function (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;
    };
    var NtTreeNodeToggleDirective = (function (_super) {
        __extends$4(NtTreeNodeToggleDirective, _super);
        function NtTreeNodeToggleDirective() {
            var _this = _super !== null && _super.apply(this, arguments) || this;
            _this.recursive = false;
            return _this;
        }
        NtTreeNodeToggleDirective_1 = NtTreeNodeToggleDirective;
        var NtTreeNodeToggleDirective_1;
        __decorate$3([
            core.Input('ntTreeNodeToggleRecursive')
        ], NtTreeNodeToggleDirective.prototype, "recursive", void 0);
        NtTreeNodeToggleDirective = NtTreeNodeToggleDirective_1 = __decorate$3([
            core.Directive({
                selector: '[ntTreeNodeToggle]',
                providers: [{ provide: tree.CdkTreeNodeToggle, useExisting: NtTreeNodeToggleDirective_1 }]
            })
        ], NtTreeNodeToggleDirective);
        return NtTreeNodeToggleDirective;
    }(tree.CdkTreeNodeToggle));

    var __extends$5 = (this && this.__extends) || (function () {
        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 (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var __decorate$4 = (this && this.__decorate) || function (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;
    };
    var NtTreeComponent = (function (_super) {
        __extends$5(NtTreeComponent, _super);
        function NtTreeComponent() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        NtTreeComponent_1 = NtTreeComponent;
        var NtTreeComponent_1;
        __decorate$4([
            core.ViewChild(NtTreeNodeOutletDirective, { static: true })
        ], NtTreeComponent.prototype, "_nodeOutlet", void 0);
        NtTreeComponent = NtTreeComponent_1 = __decorate$4([
            core.Component({
                selector: 'nt-tree, [nt-tree]',
                template: "<ng-container ntTreeNodeOutlet></ng-container>",
                encapsulation: core.ViewEncapsulation.None,
                changeDetection: core.ChangeDetectionStrategy.OnPush,
                providers: [
                    { provide: tree.CdkTree, useExisting: NtTreeComponent_1 }
                ],
                host: {
                    'class': 'nt-tree'
                }
            })
        ], NtTreeComponent);
        return NtTreeComponent;
    }(tree.CdkTree));

    var __decorate$5 = (this && this.__decorate) || function (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;
    };
    var NT_TREE_DIRECTIVES = [
        NtNestedTreeNodeDirective,
        NtTreeNodeDefDirective,
        NtTreeNodePaddingDirective,
        NtTreeNodeToggleDirective,
        NtTreeComponent,
        NtTreeNodeDirective,
        NtTreeNodeOutletDirective
    ];
    var NtTreeModule = (function () {
        function NtTreeModule() {
        }
        NtTreeModule = __decorate$5([
            core.NgModule({
                imports: [tree.CdkTreeModule, common.CommonModule],
                exports: NT_TREE_DIRECTIVES,
                declarations: NT_TREE_DIRECTIVES
            })
        ], NtTreeModule);
        return NtTreeModule;
    }());

    exports.NtNestedTreeNodeDirective = NtNestedTreeNodeDirective;
    exports.NtTreeComponent = NtTreeComponent;
    exports.NtTreeFlatDataSource = NtTreeFlatDataSource;
    exports.NtTreeFlattener = NtTreeFlattener;
    exports.NtTreeModule = NtTreeModule;
    exports.NtTreeNestedDataSource = NtTreeNestedDataSource;
    exports.NtTreeNodeDefDirective = NtTreeNodeDefDirective;
    exports.NtTreeNodeDirective = NtTreeNodeDirective;
    exports.NtTreeNodeOutletDirective = NtTreeNodeOutletDirective;
    exports.NtTreeNodePaddingDirective = NtTreeNodePaddingDirective;
    exports.NtTreeNodeToggleDirective = NtTreeNodeToggleDirective;

    Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=tree.umd.js.map
