(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular-ru/cdk/utils'), require('@angular/material/core'), require('@angular/common'), require('@angular-ru/cdk/number'), require('@angular-ru/cdk/string')) :
    typeof define === 'function' && define.amd ? define('@angular-ru/cdk/date', ['exports', '@angular/core', '@angular-ru/cdk/utils', '@angular/material/core', '@angular/common', '@angular-ru/cdk/number', '@angular-ru/cdk/string'], factory) :
    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global['angular-ru'] = global['angular-ru'] || {}, global['angular-ru'].cdk = global['angular-ru'].cdk || {}, global['angular-ru'].cdk.date = {}), global.ng.core, global['angular-ru'].cdk.utils, global.ng.material.core, global.ng.common, global['angular-ru'].cdk.number, global['angular-ru'].cdk.string));
}(this, (function (exports, i0, utils, i1, common, number, string) { 'use strict';

    function _interopNamespace(e) {
        if (e && e.__esModule) return e;
        var n = Object.create(null);
        if (e) {
            Object.keys(e).forEach(function (k) {
                if (k !== 'default') {
                    var d = Object.getOwnPropertyDescriptor(e, k);
                    Object.defineProperty(n, k, d.get ? d : {
                        enumerable: true,
                        get: function () {
                            return e[k];
                        }
                    });
                }
            });
        }
        n['default'] = e;
        return Object.freeze(n);
    }

    var i0__namespace = /*#__PURE__*/_interopNamespace(i0);
    var i1__namespace = /*#__PURE__*/_interopNamespace(i1);

    var MAX_YEAR = 3000;
    function dateStringToDate(date) {
        if (date instanceof Date) {
            return date;
        }
        var firstItem = 1;
        var parsedDate = (date || '')
            .replace(/^(\d{1,1})/, '0$1')
            .replace(/\.(\d{1,1})\./, '.0$1.')
            .replace('..', '.01.')
            .replace(/^\./, '01.')
            .replace(/(\d{3})\./g, function (str) { return str.slice(firstItem); })
            .replace(/(\d{2}).(\d{2}).(\d{4})/, '$2/$1/$3')
            .replace(/00\//g, '01/');
        var dateValue = new Date(parsedDate);
        if (dateValue.getFullYear() > MAX_YEAR) {
            return new Date();
        }
        return isNaN(dateValue.getTime()) ? new Date() : dateValue;
    }

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation.

    Permission to use, copy, modify, and/or distribute this software for any
    purpose with or without fee is hereby granted.

    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
    PERFORMANCE OF THIS SOFTWARE.
    ***************************************************************************** */
    /* global Reflect, Promise */
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b)
                if (Object.prototype.hasOwnProperty.call(b, p))
                    d[p] = b[p]; };
        return extendStatics(d, b);
    };
    function __extends(d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    }
    var __assign = function () {
        __assign = Object.assign || function __assign(t) {
            for (var s, i = 1, n = arguments.length; i < n; i++) {
                s = arguments[i];
                for (var p in s)
                    if (Object.prototype.hasOwnProperty.call(s, p))
                        t[p] = s[p];
            }
            return t;
        };
        return __assign.apply(this, arguments);
    };
    function __rest(s, e) {
        var t = {};
        for (var p in s)
            if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
                t[p] = s[p];
        if (s != null && typeof Object.getOwnPropertySymbols === "function")
            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                    t[p[i]] = s[p[i]];
            }
        return t;
    }
    function __decorate(decorators, target, key, desc) {
        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
            r = Reflect.decorate(decorators, target, key, desc);
        else
            for (var i = decorators.length - 1; i >= 0; i--)
                if (d = decorators[i])
                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
        return c > 3 && r && Object.defineProperty(target, key, r), r;
    }
    function __param(paramIndex, decorator) {
        return function (target, key) { decorator(target, key, paramIndex); };
    }
    function __metadata(metadataKey, metadataValue) {
        if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
            return Reflect.metadata(metadataKey, metadataValue);
    }
    function __awaiter(thisArg, _arguments, P, generator) {
        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
        return new (P || (P = Promise))(function (resolve, reject) {
            function fulfilled(value) { try {
                step(generator.next(value));
            }
            catch (e) {
                reject(e);
            } }
            function rejected(value) { try {
                step(generator["throw"](value));
            }
            catch (e) {
                reject(e);
            } }
            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
            step((generator = generator.apply(thisArg, _arguments || [])).next());
        });
    }
    function __generator(thisArg, body) {
        var _ = { label: 0, sent: function () { if (t[0] & 1)
                throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
        function verb(n) { return function (v) { return step([n, v]); }; }
        function step(op) {
            if (f)
                throw new TypeError("Generator is already executing.");
            while (_)
                try {
                    if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
                        return t;
                    if (y = 0, t)
                        op = [op[0] & 2, t.value];
                    switch (op[0]) {
                        case 0:
                        case 1:
                            t = op;
                            break;
                        case 4:
                            _.label++;
                            return { value: op[1], done: false };
                        case 5:
                            _.label++;
                            y = op[1];
                            op = [0];
                            continue;
                        case 7:
                            op = _.ops.pop();
                            _.trys.pop();
                            continue;
                        default:
                            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
                                _ = 0;
                                continue;
                            }
                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
                                _.label = op[1];
                                break;
                            }
                            if (op[0] === 6 && _.label < t[1]) {
                                _.label = t[1];
                                t = op;
                                break;
                            }
                            if (t && _.label < t[2]) {
                                _.label = t[2];
                                _.ops.push(op);
                                break;
                            }
                            if (t[2])
                                _.ops.pop();
                            _.trys.pop();
                            continue;
                    }
                    op = body.call(thisArg, _);
                }
                catch (e) {
                    op = [6, e];
                    y = 0;
                }
                finally {
                    f = t = 0;
                }
            if (op[0] & 5)
                throw op[1];
            return { value: op[0] ? op[1] : void 0, done: true };
        }
    }
    var __createBinding = Object.create ? (function (o, m, k, k2) {
        if (k2 === undefined)
            k2 = k;
        Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
    }) : (function (o, m, k, k2) {
        if (k2 === undefined)
            k2 = k;
        o[k2] = m[k];
    });
    function __exportStar(m, o) {
        for (var p in m)
            if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
                __createBinding(o, m, p);
    }
    function __values(o) {
        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
        if (m)
            return m.call(o);
        if (o && typeof o.length === "number")
            return {
                next: function () {
                    if (o && i >= o.length)
                        o = void 0;
                    return { value: o && o[i++], done: !o };
                }
            };
        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
    }
    function __read(o, n) {
        var m = typeof Symbol === "function" && o[Symbol.iterator];
        if (!m)
            return o;
        var i = m.call(o), r, ar = [], e;
        try {
            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
                ar.push(r.value);
        }
        catch (error) {
            e = { error: error };
        }
        finally {
            try {
                if (r && !r.done && (m = i["return"]))
                    m.call(i);
            }
            finally {
                if (e)
                    throw e.error;
            }
        }
        return ar;
    }
    /** @deprecated */
    function __spread() {
        for (var ar = [], i = 0; i < arguments.length; i++)
            ar = ar.concat(__read(arguments[i]));
        return ar;
    }
    /** @deprecated */
    function __spreadArrays() {
        for (var s = 0, i = 0, il = arguments.length; i < il; i++)
            s += arguments[i].length;
        for (var r = Array(s), k = 0, i = 0; i < il; i++)
            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
                r[k] = a[j];
        return r;
    }
    function __spreadArray(to, from, pack) {
        if (pack || arguments.length === 2)
            for (var i = 0, l = from.length, ar; i < l; i++) {
                if (ar || !(i in from)) {
                    if (!ar)
                        ar = Array.prototype.slice.call(from, 0, i);
                    ar[i] = from[i];
                }
            }
        return to.concat(ar || Array.prototype.slice.call(from));
    }
    function __await(v) {
        return this instanceof __await ? (this.v = v, this) : new __await(v);
    }
    function __asyncGenerator(thisArg, _arguments, generator) {
        if (!Symbol.asyncIterator)
            throw new TypeError("Symbol.asyncIterator is not defined.");
        var g = generator.apply(thisArg, _arguments || []), i, q = [];
        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
        function verb(n) { if (g[n])
            i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
        function resume(n, v) { try {
            step(g[n](v));
        }
        catch (e) {
            settle(q[0][3], e);
        } }
        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
        function fulfill(value) { resume("next", value); }
        function reject(value) { resume("throw", value); }
        function settle(f, v) { if (f(v), q.shift(), q.length)
            resume(q[0][0], q[0][1]); }
    }
    function __asyncDelegator(o) {
        var i, p;
        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
    }
    function __asyncValues(o) {
        if (!Symbol.asyncIterator)
            throw new TypeError("Symbol.asyncIterator is not defined.");
        var m = o[Symbol.asyncIterator], i;
        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
    }
    function __makeTemplateObject(cooked, raw) {
        if (Object.defineProperty) {
            Object.defineProperty(cooked, "raw", { value: raw });
        }
        else {
            cooked.raw = raw;
        }
        return cooked;
    }
    ;
    var __setModuleDefault = Object.create ? (function (o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
    }) : function (o, v) {
        o["default"] = v;
    };
    function __importStar(mod) {
        if (mod && mod.__esModule)
            return mod;
        var result = {};
        if (mod != null)
            for (var k in mod)
                if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
                    __createBinding(result, mod, k);
        __setModuleDefault(result, mod);
        return result;
    }
    function __importDefault(mod) {
        return (mod && mod.__esModule) ? mod : { default: mod };
    }
    function __classPrivateFieldGet(receiver, state, kind, f) {
        if (kind === "a" && !f)
            throw new TypeError("Private accessor was defined without a getter");
        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
            throw new TypeError("Cannot read private member from an object whose class did not declare it");
        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
    }
    function __classPrivateFieldSet(receiver, state, value, kind, f) {
        if (kind === "m")
            throw new TypeError("Private method is not writable");
        if (kind === "a" && !f)
            throw new TypeError("Private accessor was defined without a setter");
        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
            throw new TypeError("Cannot write private member to an object whose class did not declare it");
        return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
    }

    var SUGGESTION_STRATEGY_MAP = new i0.InjectionToken('Suggestion strategy map');

    var DateSuggestionComposer = /** @class */ (function () {
        function DateSuggestionComposer(suggestionStrategyMap, injector) {
            this.suggestionStrategyMap = suggestionStrategyMap;
            this.injector = injector;
        }
        DateSuggestionComposer.prototype.getSuggestions = function () {
            return Object.keys(this.suggestionStrategyMap);
        };
        DateSuggestionComposer.prototype.getStrategy = function (type) {
            var _a;
            var descriptor = this.suggestionStrategyMap[type];
            var strategy = i0.Injector.create({
                providers: __spreadArray([
                    { provide: descriptor.strategy, useClass: descriptor.strategy }
                ], __read(((_a = descriptor.providers) !== null && _a !== void 0 ? _a : [])), false),
                parent: this.injector
            }).get(descriptor.strategy, null, i0.InjectFlags.Optional);
            if (utils.isNil(strategy)) {
                throw new Error('This type of date suggestion is not supported');
            }
            return strategy;
        };
        return DateSuggestionComposer;
    }());
    /** @nocollapse */ /** @nocollapse */ DateSuggestionComposer.ɵfac = function DateSuggestionComposer_Factory(t) { return new (t || DateSuggestionComposer)(i0__namespace.ɵɵinject(SUGGESTION_STRATEGY_MAP), i0__namespace.ɵɵinject(i0__namespace.Injector)); };
    /** @nocollapse */ /** @nocollapse */ DateSuggestionComposer.ɵprov = /** @pureOrBreakMyCode */ i0__namespace.ɵɵdefineInjectable({ token: DateSuggestionComposer, factory: DateSuggestionComposer.ɵfac });
    (function () {
        (typeof ngDevMode === "undefined" || ngDevMode) && i0__namespace.ɵsetClassMetadata(DateSuggestionComposer, [{
                type: i0.Injectable
            }], function () {
            return [{ type: undefined, decorators: [{
                            type: i0.Inject,
                            args: [SUGGESTION_STRATEGY_MAP]
                        }] }, { type: i0__namespace.Injector }];
        }, null);
    })();

    function endOfDay(date) {
        if (date === void 0) { date = new Date(); }
        // eslint-disable-next-line @typescript-eslint/no-magic-numbers
        return new Date(date.setHours(23, 59, 59, 999));
    }

    // eslint-disable-next-line complexity
    function shiftDate(interval, inputDate) {
        if (inputDate === void 0) { inputDate = new Date(); }
        var _a, _b, _c, _d, _e, _f, _g;
        var date = new Date(inputDate);
        var years = date.getFullYear() + ((_a = interval.years) !== null && _a !== void 0 ? _a : 0);
        var months = date.getMonth() + ((_b = interval.months) !== null && _b !== void 0 ? _b : 0);
        var days = date.getDate() + ((_c = interval.days) !== null && _c !== void 0 ? _c : 0);
        var hours = date.getHours() + ((_d = interval.hours) !== null && _d !== void 0 ? _d : 0);
        var minutes = date.getMinutes() + ((_e = interval.minutes) !== null && _e !== void 0 ? _e : 0);
        var seconds = date.getSeconds() + ((_f = interval.seconds) !== null && _f !== void 0 ? _f : 0);
        var milliseconds = date.getMilliseconds() + ((_g = interval.milliseconds) !== null && _g !== void 0 ? _g : 0);
        return new Date(years, months, days, hours, minutes, seconds, milliseconds);
    }

    function startOfDay(date) {
        if (date === void 0) { date = new Date(); }
        return new Date(date.setHours(0, 0, 0, 0));
    }

    var WEEK_LENGTH = 7;
    var DateSuggestionCalendarWeekStrategy = /** @class */ (function () {
        function DateSuggestionCalendarWeekStrategy(dateAdapter) {
            this.dateAdapter = dateAdapter;
        }
        DateSuggestionCalendarWeekStrategy.prototype.updateIntervalFor = function (control, _a) {
            var _b;
            var dateFromKey = _a.dateFromKey, dateToKey = _a.dateToKey;
            var localizedDayOfWeek = (new Date().getDay() + WEEK_LENGTH - this.dateAdapter.getFirstDayOfWeek()) % WEEK_LENGTH;
            control.patchValue((_b = {},
                _b[dateFromKey] = startOfDay(shiftDate({ days: -localizedDayOfWeek })),
                _b[dateToKey] = endOfDay(),
                _b));
        };
        return DateSuggestionCalendarWeekStrategy;
    }());
    /** @nocollapse */ /** @nocollapse */ DateSuggestionCalendarWeekStrategy.ɵfac = function DateSuggestionCalendarWeekStrategy_Factory(t) { return new (t || DateSuggestionCalendarWeekStrategy)(i0__namespace.ɵɵinject(i1__namespace.DateAdapter)); };
    /** @nocollapse */ /** @nocollapse */ DateSuggestionCalendarWeekStrategy.ɵprov = /** @pureOrBreakMyCode */ i0__namespace.ɵɵdefineInjectable({ token: DateSuggestionCalendarWeekStrategy, factory: DateSuggestionCalendarWeekStrategy.ɵfac });
    (function () {
        (typeof ngDevMode === "undefined" || ngDevMode) && i0__namespace.ɵsetClassMetadata(DateSuggestionCalendarWeekStrategy, [{
                type: i0.Injectable
            }], function () { return [{ type: i1__namespace.DateAdapter }]; }, null);
    })();

    var DateSuggestionFirstDayOfIntervalStrategy = /** @class */ (function () {
        function DateSuggestionFirstDayOfIntervalStrategy() {
        }
        DateSuggestionFirstDayOfIntervalStrategy.prototype.updateIntervalFor = function (control, _a) {
            var _b;
            var dateFromKey = _a.dateFromKey, dateToKey = _a.dateToKey;
            control.patchValue((_b = {},
                _b[dateFromKey] = startOfDay(control.value[dateFromKey]),
                _b[dateToKey] = endOfDay(control.value[dateFromKey]),
                _b));
        };
        return DateSuggestionFirstDayOfIntervalStrategy;
    }());
    /** @nocollapse */ /** @nocollapse */ DateSuggestionFirstDayOfIntervalStrategy.ɵfac = function DateSuggestionFirstDayOfIntervalStrategy_Factory(t) { return new (t || DateSuggestionFirstDayOfIntervalStrategy)(); };
    /** @nocollapse */ /** @nocollapse */ DateSuggestionFirstDayOfIntervalStrategy.ɵprov = /** @pureOrBreakMyCode */ i0__namespace.ɵɵdefineInjectable({ token: DateSuggestionFirstDayOfIntervalStrategy, factory: DateSuggestionFirstDayOfIntervalStrategy.ɵfac });
    (function () {
        (typeof ngDevMode === "undefined" || ngDevMode) && i0__namespace.ɵsetClassMetadata(DateSuggestionFirstDayOfIntervalStrategy, [{
                type: i0.Injectable
            }], null, null);
    })();

    var DAYS_COUNT = new i0.InjectionToken('Days count for date suggestion');

    var DateSuggestionLastDaysOfIntervalStrategy = /** @class */ (function () {
        function DateSuggestionLastDaysOfIntervalStrategy(lastDaysCount) {
            this.lastDaysCount = lastDaysCount;
        }
        DateSuggestionLastDaysOfIntervalStrategy.prototype.updateIntervalFor = function (control, _a) {
            var _b;
            var dateFromKey = _a.dateFromKey, dateToKey = _a.dateToKey;
            var daysShiftAgo = -(this.lastDaysCount - 1);
            control.patchValue((_b = {},
                _b[dateFromKey] = startOfDay(shiftDate({ days: daysShiftAgo }, control.value[dateToKey])),
                _b[dateToKey] = endOfDay(control.value[dateToKey]),
                _b));
        };
        return DateSuggestionLastDaysOfIntervalStrategy;
    }());
    /** @nocollapse */ /** @nocollapse */ DateSuggestionLastDaysOfIntervalStrategy.ɵfac = function DateSuggestionLastDaysOfIntervalStrategy_Factory(t) { return new (t || DateSuggestionLastDaysOfIntervalStrategy)(i0__namespace.ɵɵinject(DAYS_COUNT)); };
    /** @nocollapse */ /** @nocollapse */ DateSuggestionLastDaysOfIntervalStrategy.ɵprov = /** @pureOrBreakMyCode */ i0__namespace.ɵɵdefineInjectable({ token: DateSuggestionLastDaysOfIntervalStrategy, factory: DateSuggestionLastDaysOfIntervalStrategy.ɵfac });
    (function () {
        (typeof ngDevMode === "undefined" || ngDevMode) && i0__namespace.ɵsetClassMetadata(DateSuggestionLastDaysOfIntervalStrategy, [{
                type: i0.Injectable
            }], function () {
            return [{ type: undefined, decorators: [{
                            type: i0.Inject,
                            args: [DAYS_COUNT]
                        }] }];
        }, null);
    })();

    var DateSuggestionLastFewDaysStrategy = /** @class */ (function () {
        function DateSuggestionLastFewDaysStrategy(daysCount) {
            this.daysCount = daysCount;
        }
        DateSuggestionLastFewDaysStrategy.prototype.updateIntervalFor = function (control, _a) {
            var _b;
            var dateFromKey = _a.dateFromKey, dateToKey = _a.dateToKey;
            var daysShiftAgo = -(this.daysCount - 1);
            control.patchValue((_b = {},
                _b[dateFromKey] = startOfDay(shiftDate({ days: daysShiftAgo })),
                _b[dateToKey] = endOfDay(),
                _b));
        };
        return DateSuggestionLastFewDaysStrategy;
    }());
    /** @nocollapse */ /** @nocollapse */ DateSuggestionLastFewDaysStrategy.ɵfac = function DateSuggestionLastFewDaysStrategy_Factory(t) { return new (t || DateSuggestionLastFewDaysStrategy)(i0__namespace.ɵɵinject(DAYS_COUNT)); };
    /** @nocollapse */ /** @nocollapse */ DateSuggestionLastFewDaysStrategy.ɵprov = /** @pureOrBreakMyCode */ i0__namespace.ɵɵdefineInjectable({ token: DateSuggestionLastFewDaysStrategy, factory: DateSuggestionLastFewDaysStrategy.ɵfac });
    (function () {
        (typeof ngDevMode === "undefined" || ngDevMode) && i0__namespace.ɵsetClassMetadata(DateSuggestionLastFewDaysStrategy, [{
                type: i0.Injectable
            }], function () {
            return [{ type: undefined, decorators: [{
                            type: i0.Inject,
                            args: [DAYS_COUNT]
                        }] }];
        }, null);
    })();

    var DateSuggestionSomeDayAgoStrategy = /** @class */ (function () {
        function DateSuggestionSomeDayAgoStrategy(daysCount) {
            this.daysCount = daysCount;
        }
        DateSuggestionSomeDayAgoStrategy.prototype.updateIntervalFor = function (control, _a) {
            var _b;
            var dateFromKey = _a.dateFromKey, dateToKey = _a.dateToKey;
            var day = shiftDate({ days: -this.daysCount });
            control.patchValue((_b = {},
                _b[dateFromKey] = startOfDay(day),
                _b[dateToKey] = endOfDay(day),
                _b));
        };
        return DateSuggestionSomeDayAgoStrategy;
    }());
    /** @nocollapse */ /** @nocollapse */ DateSuggestionSomeDayAgoStrategy.ɵfac = function DateSuggestionSomeDayAgoStrategy_Factory(t) { return new (t || DateSuggestionSomeDayAgoStrategy)(i0__namespace.ɵɵinject(DAYS_COUNT)); };
    /** @nocollapse */ /** @nocollapse */ DateSuggestionSomeDayAgoStrategy.ɵprov = /** @pureOrBreakMyCode */ i0__namespace.ɵɵdefineInjectable({ token: DateSuggestionSomeDayAgoStrategy, factory: DateSuggestionSomeDayAgoStrategy.ɵfac });
    (function () {
        (typeof ngDevMode === "undefined" || ngDevMode) && i0__namespace.ɵsetClassMetadata(DateSuggestionSomeDayAgoStrategy, [{
                type: i0.Injectable
            }], function () {
            return [{ type: undefined, decorators: [{
                            type: i0.Inject,
                            args: [DAYS_COUNT]
                        }] }];
        }, null);
    })();

    var _a;
    var DEFAULT_SUGGESTION_STRATEGY_MAP = (_a = {},
        _a["TODAY" /* TODAY */] = {
            strategy: DateSuggestionSomeDayAgoStrategy,
            providers: [{ provide: DAYS_COUNT, useValue: 0 }]
        },
        _a["YESTERDAY" /* YESTERDAY */] = {
            strategy: DateSuggestionSomeDayAgoStrategy,
            providers: [{ provide: DAYS_COUNT, useValue: 1 }]
        },
        _a["CALENDAR_WEEK" /* CALENDAR_WEEK */] = { strategy: DateSuggestionCalendarWeekStrategy },
        _a["LAST_3_DAYS" /* LAST_3_DAYS */] = {
            strategy: DateSuggestionLastFewDaysStrategy,
            providers: [{ provide: DAYS_COUNT, useValue: 3 }]
        },
        _a["LAST_7_DAYS" /* LAST_7_DAYS */] = {
            strategy: DateSuggestionLastFewDaysStrategy,
            providers: [{ provide: DAYS_COUNT, useValue: 7 }]
        },
        _a["LAST_60_DAYS" /* LAST_60_DAYS */] = {
            strategy: DateSuggestionLastFewDaysStrategy,
            providers: [{ provide: DAYS_COUNT, useValue: 60 }]
        },
        _a["FIRST_DAY_OF_INTERVAL" /* FIRST_DAY_OF_INTERVAL */] = { strategy: DateSuggestionFirstDayOfIntervalStrategy },
        _a["LAST_180_DAYS_OF_INTERVAL" /* LAST_180_DAYS_OF_INTERVAL */] = {
            strategy: DateSuggestionLastDaysOfIntervalStrategy,
            providers: [{ provide: DAYS_COUNT, useValue: 180 }]
        },
        _a);

    var DateSuggestionModule = /** @class */ (function () {
        function DateSuggestionModule() {
        }
        DateSuggestionModule.forRoot = function (customSuggestionStrategyMap) {
            return {
                ngModule: DateSuggestionModule,
                providers: [
                    DateSuggestionComposer,
                    {
                        provide: SUGGESTION_STRATEGY_MAP,
                        useValue: customSuggestionStrategyMap !== null && customSuggestionStrategyMap !== void 0 ? customSuggestionStrategyMap : DEFAULT_SUGGESTION_STRATEGY_MAP
                    }
                ]
            };
        };
        return DateSuggestionModule;
    }());
    /** @nocollapse */ /** @nocollapse */ DateSuggestionModule.ɵfac = function DateSuggestionModule_Factory(t) { return new (t || DateSuggestionModule)(); };
    /** @nocollapse */ /** @nocollapse */ DateSuggestionModule.ɵmod = /** @pureOrBreakMyCode */ i0__namespace.ɵɵdefineNgModule({ type: DateSuggestionModule });
    /** @nocollapse */ /** @nocollapse */ DateSuggestionModule.ɵinj = /** @pureOrBreakMyCode */ i0__namespace.ɵɵdefineInjector({});
    (function () {
        (typeof ngDevMode === "undefined" || ngDevMode) && i0__namespace.ɵsetClassMetadata(DateSuggestionModule, [{
                type: i0.NgModule
            }], null, null);
    })();

    function getToday() {
        return new Date(new Date().setHours(0, 0, 0, 0));
    }

    function isDateValid(date) {
        return date instanceof Date && Boolean(date.getTime());
    }

    function isToday(someDate) {
        var today = new Date();
        return (someDate.getDate() === today.getDate() &&
            someDate.getMonth() === today.getMonth() &&
            someDate.getFullYear() === today.getFullYear());
    }

    function toFormat(value, format) {
        return new common.DatePipe('en-US').transform(value, format);
    }

    function toFormatDateTime(time, options) {
        if (options === void 0) { options = {}; }
        var _a, _b;
        var timeValue = time !== null && time !== void 0 ? time : new Date().getTime();
        var formatValue = (_a = options.format) !== null && _a !== void 0 ? _a : 'dd.MM.yyyy HH:mm:ss';
        return (_b = new common.DatePipe('en-US').transform(timeValue, formatValue, options.timezone)) !== null && _b !== void 0 ? _b : '';
    }

    function toISOString(time, defaultValue) {
        if (defaultValue === void 0) { defaultValue = ''; }
        try {
            return utils.checkValueIsFilled(time) ? new Date(time).toISOString() : defaultValue;
        }
        catch (_a) {
            return defaultValue;
        }
    }

    function toISOStringWithoutTimezone(inputDate) {
        var date = new Date(inputDate);
        var shiftInMinutes = date.getMinutes() - date.getTimezoneOffset();
        var localDateTime = new Date(date.setMinutes(shiftInMinutes));
        return localDateTime.toISOString().slice(0, -1);
    }

    function toMilliseconds(seconds) {
        if (seconds instanceof Date) {
            return seconds.getTime();
        }
        // eslint-disable-next-line @typescript-eslint/no-magic-numbers
        return number.toNumber(seconds === null || seconds === void 0 ? void 0 : seconds.toString()) * 1000;
    }

    function toPrettyFormat(timestamp) {
        return toFormat(timestamp, 'dd.MM.yyyy HH:mm:ss');
    }

    function toTimestamp(date, format) {
        var correctDate = dateStringToDate(date);
        return toFormat(correctDate, format);
    }

    function toUnix(date) {
        if (date instanceof Date) {
            return date.getTime();
        }
        else if (string.isString(date)) {
            return new Date(date).getTime();
        }
        return date;
    }

    function toUtc(config) {
        if (config === void 0) { config = {}; }
        var _a = Object.assign({
            fullYear: new Date().getFullYear(),
            month: new Date().getMonth(),
            date: new Date().getDate(),
            hours: 0,
            minutes: 0,
            seconds: 0,
            // eslint-disable-next-line @typescript-eslint/no-magic-numbers
            timeZoneHours: new Date().getTimezoneOffset() /* TIMEZONE_OFFSET */ / 60 /* ONE_HOUR */
        }, config), fullYear = _a.fullYear, month = _a.month, date = _a.date, hours = _a.hours, minutes = _a.minutes, seconds = _a.seconds, timeZoneHours = _a.timeZoneHours;
        return new Date(Date.UTC(fullYear, month, date, hours + timeZoneHours, minutes, seconds)).toISOString();
    }

    /**
     * Generated bundle index. Do not edit.
     */

    exports.DAYS_COUNT = DAYS_COUNT;
    exports.DEFAULT_SUGGESTION_STRATEGY_MAP = DEFAULT_SUGGESTION_STRATEGY_MAP;
    exports.DateSuggestionCalendarWeekStrategy = DateSuggestionCalendarWeekStrategy;
    exports.DateSuggestionComposer = DateSuggestionComposer;
    exports.DateSuggestionFirstDayOfIntervalStrategy = DateSuggestionFirstDayOfIntervalStrategy;
    exports.DateSuggestionLastDaysOfIntervalStrategy = DateSuggestionLastDaysOfIntervalStrategy;
    exports.DateSuggestionLastFewDaysStrategy = DateSuggestionLastFewDaysStrategy;
    exports.DateSuggestionModule = DateSuggestionModule;
    exports.DateSuggestionSomeDayAgoStrategy = DateSuggestionSomeDayAgoStrategy;
    exports.SUGGESTION_STRATEGY_MAP = SUGGESTION_STRATEGY_MAP;
    exports.dateStringToDate = dateStringToDate;
    exports.endOfDay = endOfDay;
    exports.getToday = getToday;
    exports.isDateValid = isDateValid;
    exports.isToday = isToday;
    exports.shiftDate = shiftDate;
    exports.startOfDay = startOfDay;
    exports.toFormat = toFormat;
    exports.toFormatDateTime = toFormatDateTime;
    exports.toISOString = toISOString;
    exports.toISOStringWithoutTimezone = toISOStringWithoutTimezone;
    exports.toMilliseconds = toMilliseconds;
    exports.toPrettyFormat = toPrettyFormat;
    exports.toTimestamp = toTimestamp;
    exports.toUnix = toUnix;
    exports.toUtc = toUtc;

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

})));
//# sourceMappingURL=angular-ru-cdk-date.umd.js.map
