import { animation, animate, keyframes, style, trigger, transition } from '@angular/animations';
import { Subject, fromEvent, Subscription, of } from 'rxjs';
import { InjectionToken, inject, LOCALE_ID, Optional, Inject, Injectable, NgModule, EventEmitter, ElementRef, Renderer2, Input, Output, Directive, Pipe, Component, ViewEncapsulation, Attribute, ChangeDetectorRef, ViewChild, ChangeDetectionStrategy } from '@angular/core';
import { Platform, PlatformModule } from '@angular/cdk/platform';
import { filter, takeUntil, debounceTime, take, switchMap, delay, map, catchError } from 'rxjs/operators';
import { coerceNumberProperty, coerceBooleanProperty, coerceArray } from '@angular/cdk/coercion';
import { CommonModule, Location } from '@angular/common';
import { CdkConnectedOverlay, OverlayModule } from '@angular/cdk/overlay';
import { ESCAPE } from '@angular/cdk/keycodes';
import { HttpRequest, HttpEventType, HttpClient } from '@angular/common/http';

function transformAxis(name, axis, letter) {
    return axis === 'x'
        ? name + "(" + letter + ", 0, 0)"
        : name + "(0, " + letter + ", 0)";
}
function translate3d(axis, letter) {
    return transformAxis('translate3d', axis, letter);
}
var DEFAULT_TIMING = .5;

function fade(options) {
    return animation(animate((options.timing || DEFAULT_TIMING) + "s " + (options.delay || 0) + "s " + (options.timingFunction || 'ease'), keyframes([
        style({ opacity: "" + options.fromOpacity, transform: translate3d(options.axis, options.steps.a), offset: 0 }),
        style({ opacity: "" + options.toOpacity, transform: translate3d(options.axis, options.steps.b), offset: 1 }),
    ])));
}
function fadeInDirection(axis, steps, timing, delay) {
    return fade({ fromOpacity: 0, toOpacity: 1, axis: axis, steps: steps, timing: timing, delay: delay });
}
function fadeInX(steps, timing, delay) {
    return fadeInDirection('x', steps, timing, delay);
}
function fadeInY(steps, timing, delay) {
    return fadeInDirection('y', steps, timing, delay);
}
function fadeIn(timing, delay) {
    return fadeInX({ a: 0, b: 0 }, timing, delay);
}
function fadeInDown(timing, delay) {
    return fadeInY({ a: '-100%', b: 0 }, timing, delay);
}
function fadeInUp(timing, delay) {
    return fadeInY({ a: '100%', b: 0 }, timing, delay);
}
function fadeInLeft(timing, delay) {
    return fadeInX({ a: '-100%', b: 0 }, timing, delay);
}
function fadeInRight(timing, delay) {
    return fadeInX({ a: '100%', b: 0 }, timing, delay);
}
function fadeOutDirection(axis, steps, timing, delay) {
    return fade({ fromOpacity: 1, toOpacity: 0, axis: axis, steps: steps, timing: timing, delay: delay });
}
function fadeOutX(steps, timing, delay) {
    return fadeOutDirection('x', steps, timing, delay);
}
function fadeOutY(steps, timing, delay) {
    return fadeOutDirection('y', steps, timing, delay);
}
function fadeOut(timing, delay) {
    return fadeOutX({ a: 0, b: 0 }, timing, delay);
}
function fadeOutDown(timing, delay) {
    return fadeOutY({ a: '-100%', b: 0 }, timing, delay);
}
function fadeOutUp(timing, delay) {
    return fadeOutY({ a: '100%', b: 0 }, timing, delay);
}
function fadeOutLeft(timing, delay) {
    return fadeOutX({ a: '-100%', b: 0 }, timing, delay);
}
function fadeOutRight(timing, delay) {
    return fadeOutX({ a: '100%', b: 0 }, timing, delay);
}
function slideDirection(axis, steps, timing, delay) {
    return fade({ fromOpacity: 1, toOpacity: 1, axis: axis, steps: steps, timing: timing, delay: delay });
}
function slideX(steps, timing, delay) {
    return slideDirection('x', steps, timing, delay);
}
function slideY(steps, timing, delay) {
    return slideDirection('y', steps, timing, delay);
}
function slideInDown(timing, delay) {
    return slideY({ a: '100%', b: 0 }, timing, delay);
}
function slideInUp(timing, delay) {
    return slideY({ a: '-100%', b: 0 }, timing, delay);
}
function slideInLeft(timing, delay) {
    return slideX({ a: '-100%', b: 0 }, timing, delay);
}
function slideInRight(timing, delay) {
    return slideX({ a: '100%', b: 0 }, timing, delay);
}
function slideOutUp(timing, delay) {
    return slideY({ a: 0, b: '-100%' }, timing, delay);
}
function slideOutDown(timing, delay) {
    return slideY({ a: 0, b: '100%' }, timing, delay);
}
function slideOutLeft(timing, delay) {
    return slideX({ a: 0, b: '-100%' }, timing, delay);
}
function slideOutRight(timing, delay) {
    return slideX({ a: 0, b: '100%' }, timing, delay);
}

var NT_DATE_LOCALE = new InjectionToken('nt-date-locale', {
    providedIn: 'root',
    factory: NT_DATE_LOCALE_FACTORY
});
function NT_DATE_LOCALE_FACTORY() {
    return inject(LOCALE_ID);
}
var DateAdapter = (function () {
    function DateAdapter() {
        this._localeChanges = new Subject();
    }
    Object.defineProperty(DateAdapter.prototype, "localeChanges", {
        get: function () { return this._localeChanges; },
        enumerable: true,
        configurable: true
    });
    DateAdapter.prototype.deserialize = function (value) {
        if (value == null || this.isDateInstance(value) && this.isValid(value)) {
            return value;
        }
        return this.invalid();
    };
    DateAdapter.prototype.setLocale = function (locale) {
        this.locale = locale;
        this._localeChanges.next();
    };
    DateAdapter.prototype.compareDate = function (first, second) {
        return this.getYear(first) - this.getYear(second) ||
            this.getMonth(first) - this.getMonth(second) ||
            this.getDate(first) - this.getDate(second);
    };
    DateAdapter.prototype.sameDate = function (first, second) {
        if (first && second) {
            var firstValid = this.isValid(first);
            var secondValid = this.isValid(second);
            if (firstValid && secondValid) {
                return !this.compareDate(first, second);
            }
            return firstValid === secondValid;
        }
        return first === second;
    };
    DateAdapter.prototype.clampDate = function (date, min, max) {
        if (min && this.compareDate(date, min) < 0) {
            return min;
        }
        if (max && this.compareDate(date, max) > 0) {
            return max;
        }
        return date;
    };
    return DateAdapter;
}());

var NT_DATE_FORMATS = new InjectionToken('nt-date-formats');

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 __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(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);
};
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 SUPPORTS_INTL_API = typeof Intl !== 'undefined';
var DEFAULT_MONTH_NAMES = {
    'long': [
        '一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月',
        '十月', '十一月', '十二月'
    ],
    'short': ['1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月', '10月', '11月', '12月'],
    'narrow': ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12']
};
var DEFAULT_DAY_OF_WEEK_NAMES = {
    'long': ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'],
    'short': ['周日', '周一', '周二', '周三', '周四', '周五', '周六'],
    'narrow': ['日', '一', '二', '三', '四', '五', '六']
};
var ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;
var LIKE_ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:(?:\+|-)\d{4})?)?$/;
function range(length, valueFunction) {
    var valuesArray = Array(length);
    for (var i = 0; i < length; i++) {
        valuesArray[i] = valueFunction(i);
    }
    return valuesArray;
}
var NativeDateAdapter = (function (_super) {
    __extends(NativeDateAdapter, _super);
    function NativeDateAdapter(ntDateLocale, platform) {
        var _this = _super.call(this) || this;
        _this.useUtcForDisplay = true;
        _super.prototype.setLocale.call(_this, ntDateLocale);
        _this.useUtcForDisplay = !platform.TRIDENT;
        _this._clampDate = platform.TRIDENT || platform.EDGE;
        return _this;
    }
    NativeDateAdapter.prototype.getYear = function (date) {
        return date.getFullYear();
    };
    NativeDateAdapter.prototype.getMonth = function (date) {
        return date.getMonth();
    };
    NativeDateAdapter.prototype.getDate = function (date) {
        return date.getDate();
    };
    NativeDateAdapter.prototype.getMilliseconds = function (date) {
        return date.getTime();
    };
    NativeDateAdapter.prototype.getDayOfWeek = function (date) {
        return date.getDay();
    };
    NativeDateAdapter.prototype.getMonthNames = function (style, locale) {
        var _this = this;
        if (locale === void 0) { locale = this.locale; }
        if (SUPPORTS_INTL_API) {
            var dtf_1 = new Intl.DateTimeFormat(locale, { month: style, timeZone: 'utc' });
            return range(12, function (i) {
                return _this._stripDirectionalityCharacters(_this._format(dtf_1, new Date(2017, i, 1)));
            });
        }
        return DEFAULT_MONTH_NAMES[style];
    };
    NativeDateAdapter.prototype.getDateNames = function (locale) {
        var _this = this;
        if (locale === void 0) { locale = 'en-US'; }
        if (SUPPORTS_INTL_API) {
            var dtf_2 = new Intl.DateTimeFormat(locale, { day: 'numeric', timeZone: 'utc' });
            return range(31, function (i) { return _this._stripDirectionalityCharacters(_this._format(dtf_2, new Date(2017, 0, i + 1))); });
        }
        return range(31, function (i) { return String(i + 1); });
    };
    NativeDateAdapter.prototype.getDayOfWeekNames = function (style, locale) {
        var _this = this;
        if (locale === void 0) { locale = this.locale; }
        if (SUPPORTS_INTL_API) {
            var dtf_3 = new Intl.DateTimeFormat(locale, { weekday: style, timeZone: 'utc' });
            return range(7, function (i) { return _this._stripDirectionalityCharacters(_this._format(dtf_3, new Date(2017, 0, i + 1))); });
        }
        return DEFAULT_DAY_OF_WEEK_NAMES[style];
    };
    NativeDateAdapter.prototype.getYearName = function (date, locale) {
        if (locale === void 0) { locale = this.locale; }
        if (SUPPORTS_INTL_API) {
            var dtf = new Intl.DateTimeFormat(locale, { year: 'numeric', timeZone: 'utc' });
            return this._stripDirectionalityCharacters(this._format(dtf, date));
        }
        return String(this.getYear(date));
    };
    NativeDateAdapter.prototype.getFirstDayOfWeek = function () {
        return 0;
    };
    NativeDateAdapter.prototype.getNumDaysInMonth = function (date) {
        return this.getDate(this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + 1, 0));
    };
    NativeDateAdapter.prototype.clone = function (date) {
        return this.createDate(this.getYear(date), this.getMonth(date), this.getDate(date));
    };
    NativeDateAdapter.prototype.createDate = function (year, month, date) {
        if (month < 0 || month > 11) {
            throw Error("Invalid month index \"" + month + "\". Month index has to be between 0 and 11.");
        }
        if (date < 1) {
            throw Error("Invalid date \"" + date + "\". Date has to be greater than 0.");
        }
        var result = this._createDateWithOverflow(year, month, date);
        if (result.getMonth() !== month) {
            throw Error("Invalid date \"" + date + "\" for month with index \"" + month + "\".");
        }
        return result;
    };
    NativeDateAdapter.prototype.today = function () {
        return new Date();
    };
    NativeDateAdapter.prototype.parse = function (value) {
        if (typeof value === 'number') {
            return new Date(value);
        }
        return value ? new Date(Date.parse(value)) : null;
    };
    NativeDateAdapter.prototype.format = function (date, displayFormat, locale) {
        if (locale === void 0) { locale = this.locale; }
        if (!this.isValid(date)) {
            throw Error('NativeDateAdapter: Cannot format invalid date.');
        }
        if (SUPPORTS_INTL_API) {
            if (this._clampDate && (date.getFullYear() < 1 || date.getFullYear() > 9999)) {
                date = this.clone(date);
                date.setFullYear(Math.max(1, Math.min(9999, date.getFullYear())));
            }
            displayFormat = __assign(__assign({}, displayFormat), { timeZone: 'utc' });
            var dtf = new Intl.DateTimeFormat(locale, displayFormat);
            return this._stripDirectionalityCharacters(this._format(dtf, date));
        }
        return this._stripDirectionalityCharacters(date.toDateString());
    };
    NativeDateAdapter.prototype.addCalendarYears = function (date, years) {
        return this.addCalendarMonths(date, years * 12);
    };
    NativeDateAdapter.prototype.addCalendarMonths = function (date, months) {
        var newDate = this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + months, this.getDate(date));
        if (this.getMonth(newDate) !== ((this.getMonth(date) + months) % 12 + 12) % 12) {
            newDate = this._createDateWithOverflow(this.getYear(newDate), this.getMonth(newDate), 0);
        }
        return newDate;
    };
    NativeDateAdapter.prototype.addCalendarDays = function (date, days) {
        return this._createDateWithOverflow(this.getYear(date), this.getMonth(date), this.getDate(date) + days);
    };
    NativeDateAdapter.prototype.toIso8601 = function (date) {
        return [
            date.getUTCFullYear(),
            this._2digit(date.getUTCMonth() + 1),
            this._2digit(date.getUTCDate())
        ].join('-');
    };
    NativeDateAdapter.prototype.deserialize = function (value) {
        if (typeof value === 'string') {
            if (!value) {
                return null;
            }
            if (LIKE_ISO_8601_REGEX.test(value)) {
                value = value.slice(0, value.length - 2) + ":" + value.slice(value.length - 2);
            }
            if (ISO_8601_REGEX.test(value)) {
                var date = new Date(value);
                if (this.isValid(date)) {
                    return date;
                }
            }
        }
        return _super.prototype.deserialize.call(this, value);
    };
    NativeDateAdapter.prototype.isDateInstance = function (obj) {
        return obj instanceof Date;
    };
    NativeDateAdapter.prototype.isValid = function (date) {
        return !isNaN(date.getTime());
    };
    NativeDateAdapter.prototype.invalid = function () {
        return new Date(NaN);
    };
    NativeDateAdapter.prototype._createDateWithOverflow = function (year, month, date) {
        var result = new Date(year, month, date);
        if (year >= 0 && year < 100) {
            result.setFullYear(this.getYear(result) - 1900);
        }
        return result;
    };
    NativeDateAdapter.prototype._2digit = function (n) {
        return ('00' + n).slice(-2);
    };
    NativeDateAdapter.prototype._stripDirectionalityCharacters = function (str) {
        return str.replace(/[\u200e\u200f]/g, '');
    };
    NativeDateAdapter.prototype._format = function (dtf, date) {
        var d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));
        return dtf.format(d);
    };
    NativeDateAdapter.ctorParameters = function () { return [
        { type: String, decorators: [{ type: Optional }, { type: Inject, args: [NT_DATE_LOCALE,] }] },
        { type: Platform }
    ]; };
    NativeDateAdapter = __decorate([
        Injectable(),
        __param(0, Optional()), __param(0, Inject(NT_DATE_LOCALE))
    ], NativeDateAdapter);
    return NativeDateAdapter;
}(DateAdapter));

var NT_NATIVE_DATE_FORMATS = {
    parse: {
        dateInput: null,
    },
    display: {
        dateInput: { year: 'numeric', month: 'numeric', day: 'numeric' },
        monthYearLabel: { year: 'numeric', month: 'short' },
        monthLabel: { month: 'short' }
    }
};

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 NativeDateModule = (function () {
    function NativeDateModule() {
    }
    NativeDateModule = __decorate$1([
        NgModule({
            imports: [PlatformModule],
            providers: [
                { provide: DateAdapter, useClass: NativeDateAdapter }
            ],
        })
    ], NativeDateModule);
    return NativeDateModule;
}());
var ɵ0 = NT_NATIVE_DATE_FORMATS;
var NtNativeDateModule = (function () {
    function NtNativeDateModule() {
    }
    NtNativeDateModule = __decorate$1([
        NgModule({
            imports: [NativeDateModule],
            providers: [
                { provide: NT_DATE_FORMATS, useValue: ɵ0 }
            ],
        })
    ], NtNativeDateModule);
    return NtNativeDateModule;
}());

function fromOutsideElementClick(children, container) {
    if (container === void 0) { container = document.body; }
    var isMatchElement = function (target, parent) {
        var matched = target === parent;
        while (!matched
            && target.parentElement
            && target.parentElement !== container) {
            matched = parent === (target = target.parentElement);
        }
        return matched;
    };
    return fromEvent(container, 'click').pipe(filter(function (event) { return !children.some(function (element) { return isMatchElement(event.target, element); }); }));
}
function fromOutsideClick(zones, container) {
    if (container === void 0) { container = document.body; }
    var isClickZone = function (event, zone) {
        var rect = zone.getBoundingClientRect();
        var clickX = event.clientX, clickY = event.clientY, x1 = rect.left, y1 = rect.top, x2 = rect.right, y2 = rect.bottom;
        return clickX >= x1 && clickX <= x2 && clickY >= y1 && clickY <= y2;
    };
    return fromEvent(container, 'click').pipe(filter(function (event) { return !zones.some(function (element) { return isClickZone(event, element); }); }));
}

var NtFileTypeError = (function () {
    function NtFileTypeError(file, type) {
        this.file = file;
        this.type = type;
    }
    return NtFileTypeError;
}());
var NtFileSizeError = (function () {
    function NtFileSizeError(file, limitSize, limitSizeString) {
        this.file = file;
        this.limitSize = limitSize;
        this.limitSizeString = limitSizeString;
    }
    return NtFileSizeError;
}());

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 NtFileSelectDirective = (function () {
    function NtFileSelectDirective(_elementRef, _renderer) {
        this._elementRef = _elementRef;
        this._renderer = _renderer;
        this._destroy = new Subject();
        this._accept = '*';
        this._limitSize = Number.MAX_VALUE;
        this._multiple = false;
        this._disabled = false;
        this.select = new EventEmitter();
        this.errors = new EventEmitter();
    }
    Object.defineProperty(NtFileSelectDirective.prototype, "accept", {
        get: function () { return this._accept; },
        set: function (value) {
            if (typeof value === 'string') {
                this._accept = value.replace(' ', '');
            }
            else {
                this._accept = value.join(',');
            }
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtFileSelectDirective.prototype, "limitSize", {
        get: function () { return this._limitSize; },
        set: function (value) { this._limitSize = coerceNumberProperty(value, 5); },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtFileSelectDirective.prototype, "multiple", {
        get: function () { return this._multiple; },
        set: function (value) {
            this._multiple = coerceBooleanProperty(value);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtFileSelectDirective.prototype, "disabled", {
        get: function () { return this._disabled; },
        set: function (value) {
            this._disabled = coerceBooleanProperty(value);
        },
        enumerable: true,
        configurable: true
    });
    NtFileSelectDirective.prototype.ngOnChanges = function (changes) {
        var change = changes.accept || changes.maxSize || changes.multiple;
        if (change && !change.firstChange) {
            this._updateProperty();
        }
    };
    NtFileSelectDirective.prototype.ngOnInit = function () {
        var _this = this;
        this._input = this._renderer.createElement('input');
        this._renderer.setStyle(this._input, 'visibility', 'hidden');
        this._renderer.setStyle(this._input, 'width', 0);
        this._renderer.setStyle(this._input, 'height', 0);
        this._renderer.setStyle(this._input, 'margin', 0);
        this._renderer.setProperty(this._input, 'type', 'file');
        this._updateProperty();
        fromEvent(this._input, 'change')
            .pipe(takeUntil(this._destroy))
            .subscribe(function (event) { return _this._change(event); });
    };
    NtFileSelectDirective.prototype.trigger = function (event) {
        if (!this.disabled) {
            this._input.click();
        }
        event.preventDefault();
    };
    NtFileSelectDirective.prototype._updateProperty = function () {
        this._renderer.setProperty(this._input, 'accept', this._accept);
        this._renderer.setProperty(this._input, 'disabled', this.disabled);
        this._renderer.setProperty(this._input, 'multiple', this.multiple ? 'multiple' : null);
    };
    NtFileSelectDirective.prototype._change = function (_) {
        var _this = this;
        var errors = [];
        var files = Array.from(this._input.files || []).filter(function (file) {
            var valid = true;
            if (!(valid = _this._fileSizeValid(file))) {
                errors.push(new NtFileSizeError(file, _this.limitSize));
            }
            else if (!(valid = _this._fileTypeValid(file))) {
                errors.push(new NtFileTypeError(file, file.type));
            }
            return valid;
        });
        if (errors.length > 0) {
            this.errors.next(errors);
        }
        if (files.length > 0) {
            this.select.next(files);
        }
        this._input.value = '';
    };
    NtFileSelectDirective.prototype._fileTypeValid = function (file) {
        return this.accept.indexOf(file.type) > -1 || this.accept.indexOf('*') > -1;
    };
    NtFileSelectDirective.prototype._fileSizeValid = function (file) {
        return file.size <= this.limitSize * 1024 * 1024;
    };
    NtFileSelectDirective.prototype.ngOnDestroy = function () {
        if (this._input) {
            this._destroy.next();
        }
    };
    NtFileSelectDirective.ctorParameters = function () { return [
        { type: ElementRef },
        { type: Renderer2 }
    ]; };
    __decorate$2([
        Input()
    ], NtFileSelectDirective.prototype, "accept", null);
    __decorate$2([
        Input()
    ], NtFileSelectDirective.prototype, "limitSize", null);
    __decorate$2([
        Input()
    ], NtFileSelectDirective.prototype, "multiple", null);
    __decorate$2([
        Input()
    ], NtFileSelectDirective.prototype, "disabled", null);
    __decorate$2([
        Output()
    ], NtFileSelectDirective.prototype, "select", void 0);
    __decorate$2([
        Output()
    ], NtFileSelectDirective.prototype, "errors", void 0);
    NtFileSelectDirective = __decorate$2([
        Directive({
            selector: '[ntFileSelect]',
            host: {
                '(click)': 'trigger($event)'
            }
        })
    ], NtFileSelectDirective);
    return NtFileSelectDirective;
}());

var si = { radix: 1e3, unit: ['b', 'kb', 'Mb', 'Gb', 'Tb', 'Pb', 'Eb', 'Zb', 'Yb'] };
var iec = { radix: 1024, unit: ['b', 'Kib', 'Mib', 'Gib', 'Tib', 'Pib', 'Eib', 'Zib', 'Yib'] };
var jedec = { radix: 1024, unit: ['b', 'Kb', 'Mb', 'Gb', 'Tb', 'Pb', 'Eb', 'Zb', 'Yb'] };
var SPECS = { si: si, iec: iec, jedec: jedec, };
function byteStringify(bytes, fixed, spec) {
    if (fixed === void 0) { fixed = 2; }
    if (spec === void 0) { spec = 'jedec'; }
    bytes = Math.abs(bytes);
    var _a = SPECS[spec], radix = _a.radix, unit = _a.unit;
    var loop = 0;
    while (bytes >= radix) {
        bytes /= radix;
        ++loop;
    }
    return bytes.toFixed(fixed) + " " + unit[loop];
}

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 NtFileSizePipe = (function () {
    function NtFileSizePipe() {
    }
    NtFileSizePipe.prototype.transform = function (bytes, precision) {
        if (bytes === void 0) { bytes = 0; }
        if (precision === void 0) { precision = 2; }
        if (isNaN(parseFloat(String(bytes))) || !isFinite(bytes)) {
            return '?';
        }
        return byteStringify(bytes, precision);
    };
    NtFileSizePipe = __decorate$3([
        Pipe({ name: 'filesize' })
    ], NtFileSizePipe);
    return NtFileSizePipe;
}());

var __assign$1 = (this && this.__assign) || function () {
    __assign$1 = Object.assign || function(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$1.apply(this, arguments);
};
var FILE_EXTENSIONS_MAP = {
    'rar': 'archive',
    'zip': 'archive',
    'cab': 'archive',
    'iso': 'archive',
    'jar': 'archive',
    '7z': 'archive',
    'tar': 'archive',
    'gz': 'archive',
    'bz2': 'archive',
    'z': 'archive',
    'jpg': 'image',
    'bmp': 'image',
    'eps': 'image',
    'gif': 'image',
    'mif': 'image',
    'miff': 'image',
    'png': 'image',
    'tif': 'image',
    'tiff': 'image',
    'svg': 'image',
    'wmf': 'image',
    'jpe': 'image',
    'jpeg': 'image',
    'dib': 'image',
    'ico': 'image',
    'tga': 'image',
    'cut': 'image',
    'pic': 'image',
    'wma': 'audio',
    'ra': 'audio',
    'ogg': 'audio',
    'mpc': 'audio',
    'm4a': 'audio',
    'aac': 'audio',
    'mpa': 'audio',
    'mp2': 'audio',
    'm1a': 'audio',
    'm2a': 'audio',
    'mp3': 'audio',
    'mid': 'audio',
    'midi': 'audio',
    'rmi': 'audio',
    'mka': 'audio',
    'ac3': 'audio',
    'dts': 'audio',
    'cda': 'audio',
    'au': 'audio',
    'snd': 'audio',
    'aif': 'audio',
    'aifc': 'audio',
    'aiff': 'audio',
    'mp4': 'video',
    'avi': 'video',
    'wav': 'video',
    'wmv': 'video',
    'rmvb': 'video',
    'rm': 'video',
    'flv': 'video',
    'mkv': 'video',
    'mpg': 'video',
    'mpeg': 'video',
    'mov': 'video',
    '3gp': 'video',
    'doc': 'word',
    'docx': 'word',
    'xls': 'excel',
    'xlsx': 'excel',
    'ppt': 'ppt',
    'pptx': 'ppt'
};
var FILE_MIME_TYPES_MAP = {
    'application/x-bzip': 'archive',
    'application/x-bzip2': 'archive',
    'application/msword': 'word',
    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'word',
    'application/vnd.ms-fontobject': 'font',
    'application/epub+zip': 'archive',
    'application/gzip': 'archive',
    'application/java-archive': 'archive',
    'application/json': 'code',
    'application/pdf': 'pdf',
    'application/php': 'code',
    'application/vnd.ms-powerpoint': 'ppt',
    'application/vnd.openxmlformats-officedocument.presentationml.presentation': 'ppt',
    'application/x-rar-compressed': 'archive',
    'application/x-sh': 'code',
    'application/x-tar': 'archive',
    'application/xhtml+xml': 'code',
    'application/vnd.ms-excel': 'excel',
    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'excel',
    'application/xml': 'code',
    'application/vnd.mozilla.xul+xml': 'code',
    'application/zip': 'archive',
    'application/x-7z-compressed': 'archive',
    'text/css': 'code',
    'text/csv': 'code',
    'text/html': 'code',
    'text/calendar': 'code',
    'text/javascript': 'code',
    'text/xml': 'code',
    'font/otf': 'font',
    'font/ttf': 'font',
    'font/woff': 'font',
    'font/woff2': 'font',
    'image/bmp': 'image',
    'image/gif': 'image',
    'image/vnd.microsoft.icon': 'image',
    'image/jpeg': 'image',
    'image/png': 'image',
    'image/svg+xml': 'image',
    'image/tiff': 'image',
    'image/webp': 'image',
    'video/x-msvideo': 'video',
    'video/mpeg': 'video',
    'video/ogg': 'video',
    'video/mp2t': 'video',
    'video/webm': 'video',
    'video/3gpp': 'video',
    'video/3gpp2': 'video',
    'audio/aac': 'audio',
    'audio/midi audio/x-midi': 'audio',
    'audio/mpeg': 'audio',
    'audio/ogg': 'audio',
    'audio/opus': 'audio',
    'audio/wav': 'audio',
    'audio/webm': 'audio',
    'audio/3gpp': 'audio',
    'audio/3gpp2': 'audio',
};
var NT_FILE_CATEGORIES = __assign$1(__assign$1({}, FILE_EXTENSIONS_MAP), FILE_MIME_TYPES_MAP);
function findCategoryByFile(file) {
    var type = file.type || file.name.substring(file.name.lastIndexOf('.') + 1, file.name.length);
    return NT_FILE_CATEGORIES[type] || '';
}
function findCategoryByExtensions(extension) {
    return FILE_EXTENSIONS_MAP[extension] || '';
}
function findCategoryByMimeType(type) {
    return FILE_MIME_TYPES_MAP[type] || '';
}

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 NtFileModule = (function () {
    function NtFileModule() {
    }
    NtFileModule = __decorate$4([
        NgModule({
            imports: [CommonModule],
            exports: [
                NtFileSizePipe,
                NtFileSelectDirective
            ],
            declarations: [
                NtFileSizePipe,
                NtFileSelectDirective
            ]
        })
    ], NtFileModule);
    return NtFileModule;
}());

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 NtPseudoCaretComponent = (function () {
    function NtPseudoCaretComponent() {
    }
    NtPseudoCaretComponent = __decorate$5([
        Component({
            selector: 'nt-pseudo-caret',
            template: '<ng-content></ng-content>',
            encapsulation: ViewEncapsulation.None,
            host: {
                'class': 'nt-pseudo-caret'
            }
        })
    ], NtPseudoCaretComponent);
    return NtPseudoCaretComponent;
}());

var __decorate$6 = (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 NtPseudoInputComponent = (function () {
    function NtPseudoInputComponent(_elementRef, tabIndex) {
        this._elementRef = _elementRef;
        this._disabled = false;
        this.tabIndex = parseInt(tabIndex) || 0;
    }
    Object.defineProperty(NtPseudoInputComponent.prototype, "value", {
        get: function () { return this._value; },
        set: function (value) { this._value = value; },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtPseudoInputComponent.prototype, "placeholder", {
        get: function () { return this._placeholder; },
        set: function (value) { this._placeholder = value; },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtPseudoInputComponent.prototype, "disabled", {
        get: function () { return this._disabled; },
        set: function (value) { this._disabled = coerceBooleanProperty(value); },
        enumerable: true,
        configurable: true
    });
    NtPseudoInputComponent.prototype.ngOnInit = function () { };
    NtPseudoInputComponent.ctorParameters = function () { return [
        { type: ElementRef },
        { type: String, decorators: [{ type: Attribute, args: ['tabindex',] }] }
    ]; };
    __decorate$6([
        Input()
    ], NtPseudoInputComponent.prototype, "value", null);
    __decorate$6([
        Input()
    ], NtPseudoInputComponent.prototype, "placeholder", null);
    __decorate$6([
        Input()
    ], NtPseudoInputComponent.prototype, "disabled", null);
    NtPseudoInputComponent = __decorate$6([
        Component({
            selector: 'nt-pseudo-input',
            template: "\n    <div class=\"nt-pseudo-value\" *ngIf=\"value\">{{ value }}</div>\n    <div class=\"nt-pseudo-placeholder\" *ngIf=\"!value\">{{ placeholder }}</div>\n    <ng-content select=\"nt-pseudo-caret\"></ng-content>\n  ",
            encapsulation: ViewEncapsulation.None,
            host: {
                'class': 'nt-pseudo-input',
                '[class.disabled]': 'disabled',
                '[tabindex]': 'tabIndex'
            }
        }),
        __param$1(1, Attribute('tabindex'))
    ], NtPseudoInputComponent);
    return NtPseudoInputComponent;
}());

var __decorate$7 = (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 NtPseudoInputModule = (function () {
    function NtPseudoInputModule() {
    }
    NtPseudoInputModule = __decorate$7([
        NgModule({
            imports: [CommonModule],
            declarations: [
                NtPseudoInputComponent,
                NtPseudoCaretComponent
            ],
            exports: [
                NtPseudoInputComponent,
                NtPseudoCaretComponent
            ]
        })
    ], NtPseudoInputModule);
    return NtPseudoInputModule;
}());

var __decorate$8 = (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$2 = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
var NtOptionSelectionChange = (function () {
    function NtOptionSelectionChange(source, isUserInput) {
        if (isUserInput === void 0) { isUserInput = false; }
        this.source = source;
        this.isUserInput = isUserInput;
    }
    return NtOptionSelectionChange;
}());
var NT_OPTION_PARENT_COMPONENT = new InjectionToken('nt-option-parent-component');
var NtOptionComponent = (function () {
    function NtOptionComponent(_element, _changeDetectorRef, _parent) {
        this._element = _element;
        this._changeDetectorRef = _changeDetectorRef;
        this._parent = _parent;
        this._selected = false;
        this._disabled = false;
        this._label = '';
        this._hidden = false;
        this._mostRecentViewValue = '';
        this._isActive = false;
        this.stateChanges = new Subject();
        this.selectionChange = new EventEmitter();
    }
    Object.defineProperty(NtOptionComponent.prototype, "label", {
        get: function () {
            if (!this._label.trim()) {
                return (this._element.nativeElement.textContent || '').trim();
            }
            return this._label.trim();
        },
        set: function (value) { this._label = value; },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtOptionComponent.prototype, "multiple", {
        get: function () { return this._parent && this._parent.multiple; },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtOptionComponent.prototype, "value", {
        get: function () { return this._value; },
        set: function (value) { this._value = value; },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtOptionComponent.prototype, "disabled", {
        get: function () { return this._disabled; },
        set: function (value) { this._disabled = coerceBooleanProperty(value); },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtOptionComponent.prototype, "hidden", {
        get: function () { return this._hidden; },
        set: function (value) {
            this._hidden = coerceBooleanProperty(value);
            this._disabled = this._hidden;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtOptionComponent.prototype, "selected", {
        get: function () { return this._selected; },
        enumerable: true,
        configurable: true
    });
    NtOptionComponent.prototype.ngAfterViewChecked = function () {
        if (this._selected) {
            var viewValue = this.label;
            if (viewValue !== this._mostRecentViewValue) {
                this._mostRecentViewValue = viewValue;
                this.stateChanges.next();
            }
        }
    };
    NtOptionComponent.prototype.focus = function () {
        var element = this._element.nativeElement;
        if (typeof element.focus === 'function') {
            element.focus();
        }
    };
    NtOptionComponent.prototype.select = function () {
        this._selected = true;
        this._changeDetectorRef.markForCheck();
        this._emitSelectionChangeEvent();
    };
    NtOptionComponent.prototype.deselect = function () {
        this._selected = false;
        this._changeDetectorRef.markForCheck();
        this._emitSelectionChangeEvent();
    };
    NtOptionComponent.prototype.selectViaInteraction = function () {
        if (!this.disabled) {
            this._selected = this.multiple ? !this._selected : true;
            this._emitSelectionChangeEvent(true);
        }
    };
    NtOptionComponent.prototype.setActiveStyles = function () {
        this._isActive = true;
    };
    NtOptionComponent.prototype.setInactiveStyles = function () {
        this._isActive = false;
    };
    NtOptionComponent.prototype.getLabel = function () {
        return this.label;
    };
    NtOptionComponent.prototype.getOffsetTop = function () {
        return this._element.nativeElement.offsetTop;
    };
    NtOptionComponent.prototype.getOffsetHeight = function () {
        return this._element.nativeElement.offsetHeight;
    };
    NtOptionComponent.prototype._emitSelectionChangeEvent = function (isUserInput) {
        if (isUserInput === void 0) { isUserInput = false; }
        this.selectionChange.emit(new NtOptionSelectionChange(this, isUserInput));
    };
    NtOptionComponent.ctorParameters = function () { return [
        { type: ElementRef },
        { type: ChangeDetectorRef },
        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NT_OPTION_PARENT_COMPONENT,] }] }
    ]; };
    __decorate$8([
        Input()
    ], NtOptionComponent.prototype, "label", null);
    __decorate$8([
        Input()
    ], NtOptionComponent.prototype, "value", null);
    __decorate$8([
        Input()
    ], NtOptionComponent.prototype, "disabled", null);
    __decorate$8([
        Output()
    ], NtOptionComponent.prototype, "selectionChange", void 0);
    NtOptionComponent = __decorate$8([
        Component({
            selector: 'nt-option',
            template: "<ng-content></ng-content>",
            encapsulation: ViewEncapsulation.None,
            host: {
                'class': 'nt-option',
                '[class.nt-option-selected]': 'selected',
                '[class.nt-option-disabled]': 'disabled',
                '[class.nt-option-active]': '_isActive',
                '[class.nt-option-hidden]': 'hidden',
                '(click)': 'selectViaInteraction()'
            }
        }),
        __param$2(2, Optional()), __param$2(2, Inject(NT_OPTION_PARENT_COMPONENT))
    ], NtOptionComponent);
    return NtOptionComponent;
}());

var __decorate$9 = (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 NtOptionModule = (function () {
    function NtOptionModule() {
    }
    NtOptionModule = __decorate$9([
        NgModule({
            imports: [CommonModule],
            exports: [NtOptionComponent],
            declarations: [NtOptionComponent]
        })
    ], NtOptionModule);
    return NtOptionModule;
}());

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 _a;
var NtOverlayPosition;
(function (NtOverlayPosition) {
    NtOverlayPosition["Bottom"] = "bottom";
    NtOverlayPosition["BottomLeft"] = "bottomLeft";
    NtOverlayPosition["BottomRight"] = "bottomRight";
    NtOverlayPosition["Top"] = "top";
    NtOverlayPosition["TopLeft"] = "topLeft";
    NtOverlayPosition["TopRight"] = "topRight";
    NtOverlayPosition["Left"] = "left";
    NtOverlayPosition["LeftTop"] = "leftTop";
    NtOverlayPosition["LeftBottom"] = "leftBottom";
    NtOverlayPosition["Right"] = "right";
    NtOverlayPosition["RightTop"] = "rightTop";
    NtOverlayPosition["RightBottom"] = "rightBottom";
})(NtOverlayPosition || (NtOverlayPosition = {}));
var NtOverlayOrientation;
(function (NtOverlayOrientation) {
    NtOverlayOrientation["Vertical"] = "vertical";
    NtOverlayOrientation["Horizontal"] = "horizontal";
})(NtOverlayOrientation || (NtOverlayOrientation = {}));
var BOTTOM_LEFT = (_a = __read([
    getConnectionPositionPair('start', 'bottom', 'start', 'top'),
    getConnectionPositionPair('center', 'bottom', 'center', 'top'),
    getConnectionPositionPair('end', 'bottom', 'end', 'top'),
    getConnectionPositionPair('start', 'top', 'start', 'bottom'),
    getConnectionPositionPair('center', 'top', 'center', 'bottom'),
    getConnectionPositionPair('end', 'top', 'end', 'bottom'),
    getConnectionPositionPair('start', 'top', 'end', 'top'),
    getConnectionPositionPair('start', 'center', 'end', 'center'),
    getConnectionPositionPair('start', 'bottom', 'end', 'bottom'),
    getConnectionPositionPair('end', 'top', 'start', 'top'),
    getConnectionPositionPair('end', 'center', 'start', 'center'),
    getConnectionPositionPair('end', 'bottom', 'start', 'bottom')
], 12), _a[0]), BOTTOM_CENTER = _a[1], BOTTOM_RIGHT = _a[2], TOP_LEFT = _a[3], TOP_CENTER = _a[4], TOP_RIGHT = _a[5], LEFT_TOP = _a[6], LEFT_CENTER = _a[7], LEFT_BOTTOM = _a[8], RIGHT_TOP = _a[9], RIGHT_CENTER = _a[10], RIGHT_BOTTOM = _a[11];
var NT_OVERLAY_POSITION_PAIRS = {
    bottom: [
        BOTTOM_CENTER, BOTTOM_LEFT, BOTTOM_RIGHT,
        TOP_CENTER, TOP_LEFT, TOP_RIGHT,
        RIGHT_CENTER, RIGHT_TOP, RIGHT_BOTTOM,
        LEFT_CENTER, LEFT_TOP, LEFT_BOTTOM
    ],
    bottomLeft: [
        BOTTOM_LEFT, BOTTOM_CENTER, BOTTOM_RIGHT,
        TOP_LEFT, TOP_CENTER, TOP_RIGHT,
        RIGHT_CENTER, RIGHT_TOP, RIGHT_BOTTOM,
        LEFT_CENTER, LEFT_TOP, LEFT_BOTTOM
    ],
    bottomRight: [
        BOTTOM_RIGHT, BOTTOM_CENTER, BOTTOM_LEFT,
        TOP_RIGHT, TOP_CENTER, TOP_LEFT,
        RIGHT_CENTER, RIGHT_TOP, RIGHT_BOTTOM,
        LEFT_CENTER, LEFT_TOP, LEFT_BOTTOM
    ],
    top: [
        TOP_CENTER, TOP_LEFT, TOP_RIGHT,
        BOTTOM_CENTER, BOTTOM_LEFT, BOTTOM_RIGHT,
        LEFT_CENTER, LEFT_TOP, LEFT_BOTTOM,
        RIGHT_CENTER, RIGHT_TOP, RIGHT_BOTTOM
    ],
    topLeft: [
        TOP_LEFT, TOP_CENTER, TOP_RIGHT,
        BOTTOM_LEFT, BOTTOM_CENTER, BOTTOM_RIGHT,
        LEFT_CENTER, LEFT_TOP, LEFT_BOTTOM,
        RIGHT_CENTER, RIGHT_TOP, RIGHT_BOTTOM
    ],
    topRight: [
        TOP_RIGHT, TOP_CENTER, TOP_LEFT,
        BOTTOM_RIGHT, BOTTOM_CENTER, BOTTOM_LEFT,
        LEFT_CENTER, LEFT_TOP, LEFT_BOTTOM,
        RIGHT_CENTER, RIGHT_TOP, RIGHT_BOTTOM
    ],
    left: [
        LEFT_CENTER, LEFT_TOP, LEFT_BOTTOM,
        TOP_LEFT, TOP_CENTER, TOP_RIGHT,
        BOTTOM_LEFT, BOTTOM_CENTER, BOTTOM_RIGHT,
        RIGHT_CENTER, RIGHT_TOP, RIGHT_BOTTOM
    ],
    leftTop: [
        LEFT_TOP, LEFT_CENTER, LEFT_BOTTOM,
        TOP_LEFT, TOP_CENTER, TOP_RIGHT,
        BOTTOM_LEFT, BOTTOM_CENTER, BOTTOM_RIGHT,
        RIGHT_TOP, RIGHT_CENTER, RIGHT_BOTTOM
    ],
    leftBottom: [
        LEFT_BOTTOM, LEFT_CENTER, LEFT_TOP,
        TOP_LEFT, TOP_CENTER, TOP_RIGHT,
        BOTTOM_LEFT, BOTTOM_CENTER, BOTTOM_RIGHT,
        RIGHT_BOTTOM, RIGHT_CENTER, RIGHT_TOP
    ],
    right: [
        RIGHT_CENTER, RIGHT_TOP, RIGHT_BOTTOM,
        TOP_LEFT, TOP_CENTER, TOP_RIGHT,
        BOTTOM_LEFT, BOTTOM_CENTER, BOTTOM_RIGHT,
        LEFT_CENTER, LEFT_TOP, LEFT_BOTTOM
    ],
    rightTop: [
        RIGHT_TOP, RIGHT_CENTER, RIGHT_BOTTOM,
        TOP_LEFT, TOP_CENTER, TOP_RIGHT,
        BOTTOM_LEFT, BOTTOM_CENTER, BOTTOM_RIGHT,
        LEFT_TOP, LEFT_CENTER, LEFT_BOTTOM
    ],
    rightBottom: [
        RIGHT_BOTTOM, RIGHT_CENTER, RIGHT_TOP,
        TOP_LEFT, TOP_CENTER, TOP_RIGHT,
        BOTTOM_LEFT, BOTTOM_CENTER, BOTTOM_RIGHT,
        LEFT_BOTTOM, LEFT_CENTER, LEFT_TOP
    ],
};
function getConnectionPositionPair(originX, originY, overlayX, overlayY) {
    return { originX: originX, originY: originY, overlayX: overlayX, overlayY: overlayY };
}
function getPositionClassName(pair) {
    return pair.originX + "-" + pair.originY + "-" + pair.overlayX + "-" + pair.overlayY;
}
function getPositionOrientation(position) {
    return Object.keys(NT_OVERLAY_POSITION_PAIRS).indexOf(position) > 5
        ? NtOverlayOrientation.Horizontal
        : NtOverlayOrientation.Vertical;
}

var __decorate$a = (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$3 = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
var NtOverlayComponent = (function () {
    function NtOverlayComponent(_renderer, _changeDetectorRef, location) {
        var _this = this;
        this._renderer = _renderer;
        this._changeDetectorRef = _changeDetectorRef;
        this._destroy = new Subject();
        this._debounceClose = new EventEmitter();
        this._positionChange = new EventEmitter();
        this._locationChanges = Subscription.EMPTY;
        this._opened = false;
        this._markClosed = true;
        this._position = NtOverlayPosition.BottomLeft;
        this._positionPairs = NT_OVERLAY_POSITION_PAIRS[this._position];
        this._paddingClass = getPositionClassName(this._positionPairs[0]);
        this._fixed = false;
        this._arrow = false;
        this._nospacing = false;
        this._overlayClass = '';
        this._backdrop = false;
        this.afterOpen = new EventEmitter();
        this.afterClosed = new EventEmitter();
        this.beforeOpen = new EventEmitter();
        this.beforeClosed = new EventEmitter();
        this.overlayEnter = new EventEmitter();
        this.overlayLeave = new EventEmitter();
        this.positionChange = new EventEmitter();
        this.keydownEvents = new EventEmitter();
        this._debounceClose.
            pipe(takeUntil(this._destroy), debounceTime(100), filter(function () { return _this._markClosed; })).
            subscribe(function () { return _this.close(); });
        this._positionChange.
            pipe(takeUntil(this._destroy), filter(function (position) { return position !== _this._paddingClass; })).
            subscribe(function (position) { return _this._setContainerStyles(position); });
        if (location) {
            this._locationChanges = location.subscribe(function () { return _this.close(); });
        }
    }
    Object.defineProperty(NtOverlayComponent.prototype, "opened", {
        get: function () { return this._opened; },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtOverlayComponent.prototype, "origin", {
        get: function () { return this._origin; },
        set: function (value) { this._origin = value; },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtOverlayComponent.prototype, "position", {
        set: function (value) {
            if (value) {
                this._position = value;
                this._positionPairs = NT_OVERLAY_POSITION_PAIRS[value];
            }
            else {
                this._position = NtOverlayPosition.BottomLeft;
            }
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtOverlayComponent.prototype, "positionPairs", {
        get: function () { return this._positionPairs; },
        set: function (value) { this._positionPairs = coerceArray(value); },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtOverlayComponent.prototype, "paddingClass", {
        get: function () { return this._paddingClass; },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtOverlayComponent.prototype, "fixed", {
        get: function () { return this._fixed; },
        set: function (value) { this._fixed = coerceBooleanProperty(value); },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtOverlayComponent.prototype, "arrow", {
        get: function () { return this._arrow; },
        set: function (value) { this._arrow = coerceBooleanProperty(value); },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtOverlayComponent.prototype, "nospacing", {
        get: function () { return this._nospacing; },
        set: function (value) { this._nospacing = coerceBooleanProperty(value); },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtOverlayComponent.prototype, "overlayClass", {
        get: function () { return this._overlayClass; },
        set: function (value) { this._overlayClass = value; },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(NtOverlayComponent.prototype, "backdrop", {
        get: function () { return this._backdrop; },
        set: function (value) { this._backdrop = coerceBooleanProperty(value); },
        enumerable: true,
        configurable: true
    });
    NtOverlayComponent.prototype.ngAfterViewInit = function () {
        var _this = this;
        this.cdkConnectedOverlay.attach
            .pipe(take(1), switchMap(function () { return _this.cdkConnectedOverlay.overlayRef.keydownEvents(); }), takeUntil(this._destroy))
            .subscribe(function (event) {
            if (event.keyCode === ESCAPE) {
                _this.close();
            }
            _this.keydownEvents.next(event);
        });
        this.cdkConnectedOverlay.attach
            .pipe(takeUntil(this._destroy), delay(0))
            .subscribe(function () { return _this._subscribeOutsideClickEvent(); });
        this.cdkConnectedOverlay.detach
            .pipe(takeUntil(this._destroy))
            .subscribe(function () { return _this._unsubscribeOutsideClickEvent(); });
    };
    NtOverlayComponent.prototype.ngOnChanges = function (changes) {
        var change = changes.position || changes.fixed || changes.positionPairs;
        if (change && !change.firstChange) {
            this._setPosition();
        }
    };
    NtOverlayComponent.prototype.ngOnDestroy = function () {
        this._destroy.next();
        this._destroy.complete();
        this._locationChanges.unsubscribe();
    };
    NtOverlayComponent.prototype._setPosition = function () {
        this._positionPairs = this.fixed ?
            this._positionPairs.slice(0, 1) :
            this._positionPairs;
        this._paddingClass = getPositionClassName(this._positionPairs[0]);
    };
    NtOverlayComponent.prototype._subscribeOutsideClickEvent = function () {
        var _this = this;
        if (!this._outsideClickSubscription) {
            this._outsideClickSubscription = fromOutsideClick([
                this.cdkConnectedOverlay.overlayRef.overlayElement,
                this.origin.elementRef.nativeElement
            ])
                .pipe(takeUntil(this._destroy))
                .subscribe(function () {
                _this.close();
            });
        }
    };
    NtOverlayComponent.prototype._unsubscribeOutsideClickEvent = function () {
        if (this._outsideClickSubscription) {
            this._outsideClickSubscription.unsubscribe();
            this._outsideClickSubscription = null;
        }
    };
    NtOverlayComponent.prototype.open = function () {
        this._opened = true;
        this._markClosed = false;
        this._changeDetectorRef.markForCheck();
    };
    NtOverlayComponent.prototype.close = function () {
        this._opened = false;
        this._markClosed = true;
        this._changeDetectorRef.markForCheck();
    };
    NtOverlayComponent.prototype.toggle = function () {
        this.opened ? this.close() : this.open();
    };
    NtOverlayComponent.prototype.onOverlayPositionChange = function (event) {
        this._positionChange.next(getPositionClassName(event.connectionPair));
    };
    NtOverlayComponent.prototype.markOpen = function () {
        this.open();
    };
    NtOverlayComponent.prototype.markClose = function () {
        this._markClosed = true;
        this._debounceClose.next();
    };
    NtOverlayComponent.prototype.onAnimationStart = function (event) {
        if (event.toState === null) {
            this.beforeOpen.next();
        }
        else if (event.toState === 'void') {
            this.beforeClosed.next();
        }
    };
    NtOverlayComponent.prototype.onAnimationDone = function (event) {
        if (event.toState === null) {
            this.afterOpen.next();
        }
        else if (event.toState === 'void') {
            this.afterClosed.next();
        }
    };
    NtOverlayComponent.prototype._setContainerStyles = function (position) {
        var pane = this.cdkConnectedOverlay.overlayRef.overlayElement.querySelector('.nt-overlay-container');
        this._paddingClass && this._renderer.removeClass(pane, this._paddingClass);
        this._paddingClass = position;
        this._renderer.addClass(pane, this._paddingClass);
    };
    NtOverlayComponent.ctorParameters = function () { return [
        { type: Renderer2 },
        { type: ChangeDetectorRef },
        { type: Location, decorators: [{ type: Optional }] }
    ]; };
    __decorate$a([
        Input()
    ], NtOverlayComponent.prototype, "origin", null);
    __decorate$a([
        Input()
    ], NtOverlayComponent.prototype, "position", null);
    __decorate$a([
        Input()
    ], NtOverlayComponent.prototype, "positionPairs", null);
    __decorate$a([
        Input()
    ], NtOverlayComponent.prototype, "fixed", null);
    __decorate$a([
        Input()
    ], NtOverlayComponent.prototype, "arrow", null);
    __decorate$a([
        Input()
    ], NtOverlayComponent.prototype, "nospacing", null);
    __decorate$a([
        Input()
    ], NtOverlayComponent.prototype, "overlayClass", null);
    __decorate$a([
        Input()
    ], NtOverlayComponent.prototype, "backdrop", null);
    __decorate$a([
        ViewChild(CdkConnectedOverlay, { static: true })
    ], NtOverlayComponent.prototype, "cdkConnectedOverlay", void 0);
    __decorate$a([
        Output()
    ], NtOverlayComponent.prototype, "afterOpen", void 0);
    __decorate$a([
        Output()
    ], NtOverlayComponent.prototype, "afterClosed", void 0);
    __decorate$a([
        Output()
    ], NtOverlayComponent.prototype, "beforeOpen", void 0);
    __decorate$a([
        Output()
    ], NtOverlayComponent.prototype, "beforeClosed", void 0);
    __decorate$a([
        Output()
    ], NtOverlayComponent.prototype, "overlayEnter", void 0);
    __decorate$a([
        Output()
    ], NtOverlayComponent.prototype, "overlayLeave", void 0);
    __decorate$a([
        Output()
    ], NtOverlayComponent.prototype, "positionChange", void 0);
    __decorate$a([
        Output()
    ], NtOverlayComponent.prototype, "keydownEvents", void 0);
    NtOverlayComponent = __decorate$a([
        Component({
            selector: 'nt-overlay, [nt-overlay]',
            template: "<ng-template\n  cdk-connected-overlay\n  [cdkConnectedOverlayOpen]=\"opened\"\n  [cdkConnectedOverlayHasBackdrop]=\"backdrop\"\n  [cdkConnectedOverlayPositions]=\"positionPairs\"\n  [cdkConnectedOverlayOrigin]=\"origin\"\n  (positionChange)=\"onOverlayPositionChange($event)\"\n  (backdropClick)=\"close()\">\n  <div class=\"nt-overlay-container {{paddingClass}} {{overlayClass}}\"\n    (mouseenter)=\"overlayEnter.emit($event)\"\n    (mouseleave)=\"overlayLeave.emit($event)\"\n    (click)=\"$event.stopPropagation()\"\n    [class.no-spacing]=\"nospacing\"\n    [@fade]\n    (@fade.start)=\"onAnimationStart($event)\"\n    (@fade.done)=\"onAnimationDone($event)\">\n    <div class=\"nt-overlay-shadow\"></div>\n    <div class=\"nt-overlay-arrow\" *ngIf=\"arrow\"></div>\n    <div class=\"nt-overlay-pane\">\n      <ng-content></ng-content>\n    </div>\n  </div>\n</ng-template>\n",
            animations: [
                trigger('fade', [
                    transition('void => *', fadeIn(.15)),
                    transition('* => void', fadeOut(.15))
                ])
            ],
            encapsulation: ViewEncapsulation.None,
            changeDetection: ChangeDetectionStrategy.OnPush
        }),
        __param$3(2, Optional())
    ], NtOverlayComponent);
    return NtOverlayComponent;
}());

var __decorate$b = (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 NtOverlayModule = (function () {
    function NtOverlayModule() {
    }
    NtOverlayModule = __decorate$b([
        NgModule({
            imports: [CommonModule, OverlayModule],
            exports: [NtOverlayComponent],
            declarations: [NtOverlayComponent],
        })
    ], NtOverlayModule);
    return NtOverlayModule;
}());

var NtUploadStatus;
(function (NtUploadStatus) {
    NtUploadStatus[NtUploadStatus["BEGIN"] = 0] = "BEGIN";
    NtUploadStatus[NtUploadStatus["SENDING"] = 1] = "SENDING";
    NtUploadStatus[NtUploadStatus["SUCCESS"] = 2] = "SUCCESS";
    NtUploadStatus[NtUploadStatus["ERROR"] = 3] = "ERROR";
    NtUploadStatus[NtUploadStatus["UPLOADED"] = 4] = "UPLOADED";
})(NtUploadStatus || (NtUploadStatus = {}));
var NtUploadRef = (function () {
    function NtUploadRef(file, name, size) {
        this.file = file;
        this.name = name;
        this.size = size;
    }
    return NtUploadRef;
}());

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 __decorate$c = (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 REQUEST_PROGRESS = { reportProgress: true };
var NtUploadResponse = (function () {
    function NtUploadResponse(data) {
        this.data = data;
    }
    return NtUploadResponse;
}());
var NtUploadError = (function () {
    function NtUploadError(file, error) {
        this.file = file;
        this.error = error;
    }
    return NtUploadError;
}());
var NtUploadHandler = (function () {
    function NtUploadHandler(_http) {
        this._http = _http;
    }
    NtUploadHandler.prototype.upload = function (url, uploadRef) {
        var _this = this;
        var data = this.getRequestData(uploadRef.file);
        return this._http.request(new HttpRequest('POST', url, data, REQUEST_PROGRESS))
            .pipe(map(function (event) { return _this._progress(event, uploadRef); }), filter(function (event) { return event.type === HttpEventType.Response; }), map(function (event) {
            return new NtUploadResponse(_this.getResponseData(event.body));
        }), catchError(function (error) {
            return of(new NtUploadError(uploadRef.file, _this.getErrorMessage(error)));
        }));
    };
    NtUploadHandler.prototype._progress = function (event, uploadRef) {
        if (event.type === HttpEventType.Sent) {
            uploadRef.status = NtUploadStatus.BEGIN;
        }
        else if (event.type === HttpEventType.UploadProgress && (event.total && event.total > 0)) {
            uploadRef.progress = Math.round(event.loaded / event.total * 100);
        }
        else if (event.type === HttpEventType.Response) {
            uploadRef.status = NtUploadStatus.UPLOADED;
        }
        return event;
    };
    NtUploadHandler.ctorParameters = function () { return [
        { type: HttpClient }
    ]; };
    NtUploadHandler = __decorate$c([
        Injectable()
    ], NtUploadHandler);
    return NtUploadHandler;
}());
var NtNoopUploadHandler = (function (_super) {
    __extends$1(NtNoopUploadHandler, _super);
    function NtNoopUploadHandler() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    NtNoopUploadHandler.prototype.getRequestData = function (file) { return file; };
    NtNoopUploadHandler.prototype.getResponseData = function (body) { return body; };
    NtNoopUploadHandler.prototype.getErrorMessage = function (error) { return error.statusText; };
    NtNoopUploadHandler = __decorate$c([
        Injectable()
    ], NtNoopUploadHandler);
    return NtNoopUploadHandler;
}(NtUploadHandler));
var NT_UPLOAD_HANDLER = new InjectionToken('nt-upload-handler');

var __decorate$d = (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 NtUploadModule = (function () {
    function NtUploadModule() {
    }
    NtUploadModule_1 = NtUploadModule;
    NtUploadModule.forRoot = function (handler) {
        return {
            ngModule: NtUploadModule_1,
            providers: [
                { provide: NT_UPLOAD_HANDLER, useClass: handler || NtNoopUploadHandler }
            ]
        };
    };
    var NtUploadModule_1;
    NtUploadModule = NtUploadModule_1 = __decorate$d([
        NgModule()
    ], NtUploadModule);
    return NtUploadModule;
}());

export { BOTTOM_CENTER, BOTTOM_LEFT, BOTTOM_RIGHT, DEFAULT_TIMING, DateAdapter, FILE_EXTENSIONS_MAP, FILE_MIME_TYPES_MAP, LEFT_BOTTOM, LEFT_CENTER, LEFT_TOP, NT_DATE_FORMATS, NT_DATE_LOCALE, NT_DATE_LOCALE_FACTORY, NT_FILE_CATEGORIES, NT_NATIVE_DATE_FORMATS, NT_OPTION_PARENT_COMPONENT, NT_OVERLAY_POSITION_PAIRS, NT_UPLOAD_HANDLER, NativeDateAdapter, NativeDateModule, NtFileModule, NtFileSelectDirective, NtFileSizeError, NtFileSizePipe, NtFileTypeError, NtNativeDateModule, NtNoopUploadHandler, NtOptionComponent, NtOptionModule, NtOptionSelectionChange, NtOverlayComponent, NtOverlayModule, NtOverlayOrientation, NtOverlayPosition, NtPseudoCaretComponent, NtPseudoInputComponent, NtPseudoInputModule, NtUploadError, NtUploadHandler, NtUploadModule, NtUploadRef, NtUploadResponse, NtUploadStatus, RIGHT_BOTTOM, RIGHT_CENTER, RIGHT_TOP, SPECS, TOP_CENTER, TOP_LEFT, TOP_RIGHT, byteStringify, fade, fadeIn, fadeInDirection, fadeInDown, fadeInLeft, fadeInRight, fadeInUp, fadeInX, fadeInY, fadeOut, fadeOutDirection, fadeOutDown, fadeOutLeft, fadeOutRight, fadeOutUp, fadeOutX, fadeOutY, findCategoryByExtensions, findCategoryByFile, findCategoryByMimeType, fromOutsideClick, fromOutsideElementClick, getConnectionPositionPair, getPositionClassName, getPositionOrientation, slideDirection, slideInDown, slideInLeft, slideInRight, slideInUp, slideOutDown, slideOutLeft, slideOutRight, slideOutUp, slideX, slideY, transformAxis, translate3d, ɵ0 };
//# sourceMappingURL=core.js.map
