@coreui/angular-pro 4.0.2 → 4.1.0-next.0

package/esm2020/lib/calendar/calendar/calendar.component.mjs

@@ -0,0 +1,366 @@
+import { Component, EventEmitter, HostBinding, Input, Output, ViewChildren } from '@angular/core';
+import { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
+import { tryDate } from '../calendar.utils';
+import { CalendarService } from '../calendar.service';
+import { CalendarMonthComponent } from '../calendar-month/calendar-month.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../calendar.service";
+import * as i2 from "../calendar-navigation/calendar-navigation.component";
+import * as i3 from "../calendar-month/calendar-month.component";
+import * as i4 from "@angular/common";
+import * as i5 from "./calendar-class-view.pipe";
+export class CalendarComponent {
+    constructor(calendarService) {
+        this.calendarService = calendarService;
+        this._calendarDate = tryDate(new Date());
+        this._calendars = 1;
+        this._dayFormat = 'numeric';
+        this._disabledDates = [];
+        this._startDate = null;
+        this._endDate = null;
+        this._firstDayOfWeek = 1;
+        this._locale = 'default';
+        this._maxDate = null;
+        this._minDate = null;
+        this._navigation = true;
+        this._navYearFirst = false;
+        this._range = false;
+        this._view = 'days';
+        this._weekdayFormat = 'short';
+        this.calendarCellHover = new EventEmitter();
+        this.calendarDateChange = new EventEmitter();
+        this.endDateChange = new EventEmitter();
+        this.startDateChange = new EventEmitter();
+        this.viewChange = new EventEmitter();
+        this._hoverDate = null;
+        this.calendarStateSubscribe();
+    }
+    /**
+     * Default date of the component
+     * @type  (Date | string)
+     */
+    set calendarDate(value) {
+        const _value = new Date(tryDate((value ?? this.startDate ?? new Date()), 'calendarDate'));
+        if (this._calendarDate.getTime() !== _value.getTime()) {
+            this._calendarDate = new Date(_value.setDate(1));
+            this.calendarDateChange.emit(_value);
+            this.calendarService.update({ calendarDate: _value });
+        }
+    }
+    get calendarDate() {
+        return this._calendarDate;
+    }
+    /**
+     * The number of calendars that render on desktop devices.
+     * @type number
+     * default 1
+     */
+    set calendars(value) {
+        this._calendars = coerceNumberProperty(value);
+    }
+    get calendars() {
+        return this._calendars;
+    }
+    get calendarsArray() {
+        return Array.from({ length: this.calendars });
+    }
+    /**
+     * Set the format of day name.
+     * @default 'numeric'
+     * @type DayFormatType
+     */
+    set dayFormat(value) {
+        this._dayFormat = value;
+        this.calendarService.update({ dayFormat: this._dayFormat });
+    }
+    get dayFormat() {
+        return this._dayFormat;
+    }
+    /**
+     * Specify the list of dates that cannot be selected.
+     * @type  (Date[] | Date[][])
+     */
+    set disabledDates(value) {
+        this._disabledDates = value;
+        this.calendarService.update({ disabledDates: this._disabledDates });
+    }
+    get disabledDates() {
+        return this._disabledDates;
+    }
+    /**
+     * Initial selected date.
+     * @type  (Date | null)
+     */
+    set startDate(value) {
+        this._startDate = !!value ? tryDate(value, 'startDate') : null;
+        this.calendarService.update({ startDate: this._startDate });
+    }
+    get startDate() {
+        return this._startDate;
+    }
+    /**
+     * Initial selected to date (range).
+     * @type  (Date | null)
+     */
+    set endDate(value) {
+        this._endDate = !!value ? tryDate(value, 'endDate') : null;
+        this.calendarService.update({ endDate: this._endDate });
+    }
+    get endDate() {
+        return this._endDate;
+    }
+    /**
+     * Sets the day of start week.
+     * - 0 - Sunday,
+     * - 1 - Monday,
+     * - 2 - Tuesday,
+     * - 3 - Wednesday,
+     * - 4 - Thursday,
+     * - 5 - Friday,
+     * - 6 - Saturday,
+     *
+     * @type number
+     * @default 1
+     */
+    set firstDayOfWeek(value) {
+        this._firstDayOfWeek = coerceNumberProperty(value);
+    }
+    get firstDayOfWeek() {
+        return this._firstDayOfWeek;
+    }
+    /**
+     * Sets the default locale for components. If not set, it is inherited from the browser.
+     * @default 'default'
+     */
+    set locale(value) {
+        this._locale = value;
+        this.calendarService.update({ locale: value });
+    }
+    get locale() {
+        return this._locale;
+    }
+    /**
+     * Max selectable date.
+     */
+    set maxDate(value) {
+        this._maxDate = !!value ? tryDate(value, 'maxDate') : null;
+        this.calendarService.update({ maxDate: this._maxDate });
+    }
+    get maxDate() {
+        return this._maxDate;
+    }
+    /**
+     * Min selectable date.
+     */
+    set minDate(value) {
+        this._minDate = value ? tryDate(value, 'minDate') : null;
+        this.calendarService.update({ minDate: this._minDate });
+    }
+    get minDate() {
+        return this._minDate;
+    }
+    /**
+     * Show navigation.
+     * @type boolean
+     */
+    set navigation(value) {
+        this._navigation = coerceBooleanProperty(value);
+    }
+    get navigation() {
+        return this._navigation;
+    }
+    /**
+     * Reorder year-month navigation, and render year first.
+     * @type boolean
+     * @default false
+     */
+    set navYearFirst(value) {
+        this._navYearFirst = coerceBooleanProperty(value);
+        this.calendarService.update({ navYearFirst: this._navYearFirst });
+    }
+    get navYearFirst() {
+        return this._navYearFirst;
+    }
+    /**
+     * Allow range selection.
+     * @type boolean
+     * @default false
+     */
+    set range(value) {
+        this._range = coerceBooleanProperty(value);
+        this.calendarService.update({ range: this._range });
+    }
+    get range() {
+        return this._range;
+    }
+    /**
+     * Set calendar view.
+     * @type 'days' | 'months' | 'years'
+     * @default 'days'
+     */
+    set view(value) {
+        this._view = value;
+        this.calendarService.update({ view: value });
+    }
+    get view() {
+        return this._view;
+    }
+    /**
+     * Set length or format of day name.
+     * @type number | 'long' | 'narrow' | 'short'
+     * @default 'short'
+     */
+    set weekdayFormat(value) {
+        this._weekdayFormat = value;
+        this.calendarService.update({ weekdayFormat: this._weekdayFormat });
+    }
+    get weekdayFormat() {
+        return this._weekdayFormat;
+    }
+    set dateFilter(value) {
+        this.calendarService.update({ dateFilter: value });
+    }
+    // used with calendarService
+    set hoverDate(value) {
+        this._hoverDate = value;
+        this.calendarCellHover.emit(value);
+    }
+    get hoverDate() {
+        return this._hoverDate;
+    }
+    get hostClasses() {
+        return {
+            'calendars': true
+        };
+    }
+    ngOnDestroy() {
+        this.calendarStateSubscribe(false);
+    }
+    ngOnInit() {
+        this.calendarService.update({ locale: this.locale, view: this.view, range: this.range });
+    }
+    calendarStateSubscribe(subscribe = true) {
+        if (subscribe) {
+            this.calendarStateSubscription =
+                this.calendarService.calendarState$.subscribe(state => {
+                    const keys = Object.keys(state);
+                    for (const key of keys) {
+                        if (key in this) {
+                            // @ts-ignore
+                            this[key] = state[key];
+                            if (key === 'startDate') {
+                                setTimeout(() => {
+                                    this.startDateChange.emit(this._startDate);
+                                });
+                                continue;
+                            }
+                            if (key === 'endDate') {
+                                setTimeout(() => {
+                                    this.endDateChange.emit(this._endDate);
+                                });
+                            }
+                        }
+                    }
+                });
+            return;
+        }
+        this.calendarStateSubscription.unsubscribe();
+    }
+    setCalendarPage(years, months = 0, setMonth) {
+        const year = this.calendarDate.getFullYear();
+        const month = this.calendarDate.getMonth();
+        const d = new Date(year, month, 1);
+        years && d.setFullYear(d.getFullYear() + years);
+        months && d.setMonth(d.getMonth() + months);
+        typeof setMonth === 'number' && d.setMonth(setMonth);
+        this.calendarDate = d;
+    }
+    handleNavigationClick(direction, years = false) {
+        if (direction === 'prev') {
+            if (years) {
+                this.setCalendarPage(this.view === 'years' ? -10 : -1);
+                return;
+            }
+            if (this.view !== 'days') {
+                this.setCalendarPage(-1);
+                return;
+            }
+            this.setCalendarPage(0, -1);
+            return;
+        }
+        if (direction === 'next') {
+            if (years) {
+                this.setCalendarPage(this.view === 'years' ? 10 : 1);
+                return;
+            }
+            if (this.view !== 'days') {
+                this.setCalendarPage(1);
+                return;
+            }
+            this.setCalendarPage(0, 1);
+            return;
+        }
+    }
+    /**
+     * Clear startDate and endDate
+     * @type void
+     */
+    clearDates() {
+        this.calendarService.update({ startDate: null, endDate: null });
+    }
+}
+CalendarComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarComponent, deps: [{ token: i1.CalendarService }], target: i0.ɵɵFactoryTarget.Component });
+CalendarComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: CalendarComponent, selector: "c-calendar", inputs: { calendarDate: "calendarDate", calendars: "calendars", dayFormat: "dayFormat", disabledDates: "disabledDates", startDate: "startDate", endDate: "endDate", firstDayOfWeek: "firstDayOfWeek", locale: "locale", maxDate: "maxDate", minDate: "minDate", navigation: "navigation", navYearFirst: "navYearFirst", range: "range", view: "view", weekdayFormat: "weekdayFormat", dateFilter: "dateFilter" }, outputs: { calendarCellHover: "calendarCellHover", calendarDateChange: "calendarDateChange", endDateChange: "endDateChange", startDateChange: "startDateChange", viewChange: "viewChange" }, host: { properties: { "class": "this.hostClasses" } }, providers: [CalendarService], viewQueries: [{ propertyName: "calendarMonths", predicate: CalendarMonthComponent, descendants: true }], exportAs: ["cCalendar"], ngImport: i0, template: "<ng-container *ngFor=\"let calendar of calendarsArray; let i=index;\">\r\n  <div [ngClass]=\"view | calendarClassView\">\r\n    <c-calendar-navigation\r\n      [addMonths]=\"i\"\r\n      [navigation]=\"navigation\"\r\n      (navigationClick)=\"handleNavigationClick($event.direction, $event.years)\"\r\n    ></c-calendar-navigation>\r\n\r\n    <c-calendar-month\r\n      [addMonths]=\"i\"\r\n      [firstDayOfWeek]=\"firstDayOfWeek\"\r\n      [weekdayFormat]=\"weekdayFormat\"\r\n    ></c-calendar-month>\r\n  </div>\r\n</ng-container>\r\n", styles: [".btn-transparent:focus-visible{outline:-webkit-focus-ring-color auto 1px}\n"], components: [{ type: i2.CalendarNavigationComponent, selector: "c-calendar-navigation", inputs: ["addMonths", "calendarDate", "navigation", "navYearFirst"], outputs: ["navigationClick"] }, { type: i3.CalendarMonthComponent, selector: "c-calendar-month", inputs: ["addMonths", "startDate", "endDate", "disabledDates", "firstDayOfWeek", "locale", "range", "weekdayFormat", "view", "maxDate", "minDate", "calendarDate"], exportAs: ["cCalendarMonth"] }], directives: [{ type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], pipes: { "calendarClassView": i5.CalendarClassViewPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'c-calendar', exportAs: 'cCalendar', providers: [CalendarService], template: "<ng-container *ngFor=\"let calendar of calendarsArray; let i=index;\">\r\n  <div [ngClass]=\"view | calendarClassView\">\r\n    <c-calendar-navigation\r\n      [addMonths]=\"i\"\r\n      [navigation]=\"navigation\"\r\n      (navigationClick)=\"handleNavigationClick($event.direction, $event.years)\"\r\n    ></c-calendar-navigation>\r\n\r\n    <c-calendar-month\r\n      [addMonths]=\"i\"\r\n      [firstDayOfWeek]=\"firstDayOfWeek\"\r\n      [weekdayFormat]=\"weekdayFormat\"\r\n    ></c-calendar-month>\r\n  </div>\r\n</ng-container>\r\n", styles: [".btn-transparent:focus-visible{outline:-webkit-focus-ring-color auto 1px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.CalendarService }]; }, propDecorators: { calendarDate: [{
+                type: Input
+            }], calendars: [{
+                type: Input
+            }], dayFormat: [{
+                type: Input
+            }], disabledDates: [{
+                type: Input
+            }], startDate: [{
+                type: Input
+            }], endDate: [{
+                type: Input
+            }], firstDayOfWeek: [{
+                type: Input
+            }], locale: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], navigation: [{
+                type: Input
+            }], navYearFirst: [{
+                type: Input
+            }], range: [{
+                type: Input
+            }], view: [{
+                type: Input
+            }], weekdayFormat: [{
+                type: Input
+            }], dateFilter: [{
+                type: Input
+            }], calendarCellHover: [{
+                type: Output
+            }], calendarDateChange: [{
+                type: Output
+            }], endDateChange: [{
+                type: Output
+            }], startDateChange: [{
+                type: Output
+            }], viewChange: [{
+                type: Output
+            }], hostClasses: [{
+                type: HostBinding,
+                args: ['class']
+            }], calendarMonths: [{
+                type: ViewChildren,
+                args: [CalendarMonthComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calendar.component.js","sourceRoot":"","sources":["../../../../../../projects/coreui-angular/src/lib/calendar/calendar/calendar.component.ts","../../../../../../projects/coreui-angular/src/lib/calendar/calendar/calendar.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Component,\r\n  EventEmitter,\r\n  HostBinding,\r\n  Input,\r\n  OnDestroy,\r\n  OnInit,\r\n  Output,\r\n  QueryList,\r\n  ViewChildren\r\n} from '@angular/core';\r\nimport { BooleanInput, coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';\r\n\r\nimport { tryDate } from '../calendar.utils';\r\n\r\nimport { CalendarService, DateFilterType, DayFormatType, WeekdayFormatType } from '../calendar.service';\r\nimport { CalendarMonthComponent } from '../calendar-month/calendar-month.component';\r\nimport { Subscription } from 'rxjs';\r\n\r\n@Component({\r\n  selector: 'c-calendar',\r\n  templateUrl: './calendar.component.html',\r\n  styleUrls: ['./calendar.component.scss'],\r\n  exportAs: 'cCalendar',\r\n  providers: [CalendarService]\r\n})\r\nexport class CalendarComponent implements OnInit, OnDestroy {\r\n\r\n  static ngAcceptInputType_navigation: BooleanInput;\r\n  static ngAcceptInputType_navYearFirst: BooleanInput;\r\n  static ngAcceptInputType_range: BooleanInput;\r\n\r\n  constructor(\r\n    private calendarService: CalendarService\r\n  ) {\r\n    this.calendarStateSubscribe();\r\n  }\r\n\r\n  /**\r\n   * Default date of the component\r\n   * @type  (Date | string)\r\n   */\r\n  @Input()\r\n  set calendarDate(value: Date | string | number | undefined) {\r\n    const _value = new Date(tryDate((value ?? this.startDate ?? new Date()), 'calendarDate'));\r\n    if (this._calendarDate.getTime() !== _value.getTime()) {\r\n      this._calendarDate = new Date(_value.setDate(1));\r\n      this.calendarDateChange.emit(_value);\r\n      this.calendarService.update({ calendarDate: _value });\r\n    }\r\n  }\r\n  get calendarDate(): Date {\r\n    return this._calendarDate;\r\n  }\r\n  private _calendarDate: Date = tryDate(new Date());\r\n\r\n  /**\r\n   * The number of calendars that render on desktop devices.\r\n   * @type number\r\n   * default 1\r\n   */\r\n  @Input()\r\n  set calendars(value: number) {\r\n    this._calendars = coerceNumberProperty(value);\r\n  }\r\n  get calendars(): number {\r\n    return this._calendars;\r\n  }\r\n  private _calendars: number = 1;\r\n\r\n  get calendarsArray() {\r\n    return Array.from({ length: this.calendars });\r\n  }\r\n\r\n  /**\r\n   * Set the format of day name.\r\n   * @default 'numeric'\r\n   * @type DayFormatType\r\n   */\r\n  @Input()\r\n  set dayFormat(value: DayFormatType) {\r\n    this._dayFormat = value;\r\n    this.calendarService.update({ dayFormat: this._dayFormat });\r\n  }\r\n  get dayFormat() {\r\n    return this._dayFormat;\r\n  }\r\n  private _dayFormat: DayFormatType = 'numeric';\r\n\r\n  /**\r\n   * Specify the list of dates that cannot be selected.\r\n   * @type  (Date[] | Date[][])\r\n   */\r\n  @Input()\r\n  set disabledDates(value: Date[] | Date[][]) {\r\n    this._disabledDates = value;\r\n    this.calendarService.update({ disabledDates: this._disabledDates });\r\n  }\r\n  get disabledDates(): Date[] | Date[][] {\r\n    return this._disabledDates;\r\n  }\r\n  private _disabledDates: (Date[] | Date[][]) = [];\r\n\r\n  /**\r\n   * Initial selected date.\r\n   * @type  (Date | null)\r\n   */\r\n  @Input()\r\n  set startDate(value: Date | number | string | null | undefined) {\r\n    this._startDate = !!value ? tryDate(value, 'startDate') : null;\r\n    this.calendarService.update({ startDate: this._startDate });\r\n  }\r\n  get startDate() {\r\n    return this._startDate;\r\n  }\r\n  _startDate: Date | null = null;\r\n\r\n  /**\r\n   * Initial selected to date (range).\r\n   * @type  (Date | null)\r\n   */\r\n  @Input()\r\n  set endDate(value: Date | number | string | null | undefined) {\r\n    this._endDate = !!value ? tryDate(value, 'endDate') : null;\r\n    this.calendarService.update({ endDate: this._endDate });\r\n  }\r\n  get endDate() {\r\n    return this._endDate;\r\n  }\r\n  _endDate: (Date | null) = null;\r\n\r\n  /**\r\n   * Sets the day of start week.\r\n   * - 0 - Sunday,\r\n   * - 1 - Monday,\r\n   * - 2 - Tuesday,\r\n   * - 3 - Wednesday,\r\n   * - 4 - Thursday,\r\n   * - 5 - Friday,\r\n   * - 6 - Saturday,\r\n   *\r\n   * @type number\r\n   * @default 1\r\n   */\r\n  @Input()\r\n  set firstDayOfWeek(value: number) {\r\n    this._firstDayOfWeek = coerceNumberProperty(value);\r\n  }\r\n  get firstDayOfWeek(): number {\r\n    return this._firstDayOfWeek;\r\n  }\r\n  private _firstDayOfWeek: number = 1;\r\n\r\n  /**\r\n   * Sets the default locale for components. If not set, it is inherited from the browser.\r\n   * @default 'default'\r\n   */\r\n  @Input()\r\n  set locale(value: string) {\r\n    this._locale = value;\r\n    this.calendarService.update({ locale: value });\r\n  }\r\n  get locale() {\r\n    return this._locale;\r\n  }\r\n  private _locale: string = 'default';\r\n\r\n  /**\r\n   * Max selectable date.\r\n   */\r\n  @Input()\r\n  set maxDate(value: Date | string | null | undefined) {\r\n    this._maxDate = !!value ? tryDate(value, 'maxDate') : null;\r\n    this.calendarService.update({ maxDate: this._maxDate });\r\n  }\r\n  get maxDate() {\r\n    return this._maxDate;\r\n  }\r\n  private _maxDate: Date | null = null;\r\n\r\n  /**\r\n   * Min selectable date.\r\n   */\r\n  @Input()\r\n  set minDate(value: Date | string | null | undefined) {\r\n    this._minDate = value ? tryDate(value, 'minDate') : null;\r\n    this.calendarService.update({ minDate: this._minDate });\r\n  }\r\n  get minDate() {\r\n    return this._minDate;\r\n  }\r\n  private _minDate: Date | null = null;\r\n\r\n  /**\r\n   * Show navigation.\r\n   * @type boolean\r\n   */\r\n  @Input()\r\n  set navigation(value: boolean) {\r\n    this._navigation = coerceBooleanProperty(value);\r\n  }\r\n  get navigation(): boolean {\r\n    return this._navigation;\r\n  }\r\n  private _navigation: boolean = true;\r\n\r\n  /**\r\n   * Reorder year-month navigation, and render year first.\r\n   * @type boolean\r\n   * @default false\r\n   */\r\n  @Input()\r\n  set navYearFirst(value: boolean) {\r\n    this._navYearFirst = coerceBooleanProperty(value);\r\n    this.calendarService.update({ navYearFirst: this._navYearFirst });\r\n  }\r\n  get navYearFirst() {\r\n    return this._navYearFirst;\r\n  }\r\n\r\n  private _navYearFirst: boolean = false;\r\n\r\n  /**\r\n   * Allow range selection.\r\n   * @type boolean\r\n   * @default false\r\n   */\r\n  @Input()\r\n  set range(value: boolean) {\r\n    this._range = coerceBooleanProperty(value);\r\n    this.calendarService.update({ range: this._range });\r\n  }\r\n  get range(): boolean {\r\n    return this._range;\r\n  }\r\n  private _range: boolean = false;\r\n\r\n  /**\r\n   * Set calendar view.\r\n   * @type 'days' | 'months' | 'years'\r\n   * @default 'days'\r\n   */\r\n  @Input()\r\n  set view(value) {\r\n    this._view = value;\r\n    this.calendarService.update({ view: value });\r\n  }\r\n  get view() {\r\n    return this._view;\r\n  }\r\n  private _view: 'days' | 'months' | 'years' = 'days';\r\n\r\n  /**\r\n   * Set length or format of day name.\r\n   * @type number | 'long' | 'narrow' | 'short'\r\n   * @default 'short'\r\n   */\r\n  @Input()\r\n  set weekdayFormat(value: WeekdayFormatType) {\r\n    this._weekdayFormat = value;\r\n    this.calendarService.update({ weekdayFormat: this._weekdayFormat });\r\n  }\r\n  get weekdayFormat() {\r\n    return this._weekdayFormat;\r\n  }\r\n  private _weekdayFormat: WeekdayFormatType = 'short';\r\n\r\n  @Input()\r\n  set dateFilter(value: DateFilterType | undefined) {\r\n    this.calendarService.update({ dateFilter: value });\r\n  }\r\n\r\n  @Output() calendarCellHover: EventEmitter<Date | null> = new EventEmitter<Date | null>();\r\n  @Output() calendarDateChange: EventEmitter<Date> = new EventEmitter<Date>();\r\n  @Output() endDateChange: EventEmitter<Date | null> = new EventEmitter<Date | null>();\r\n  @Output() startDateChange: EventEmitter<Date | null> = new EventEmitter<Date | null>();\r\n  @Output() viewChange: EventEmitter<string> = new EventEmitter<string>();\r\n\r\n  // used with calendarService\r\n  set hoverDate(value: Date | null) {\r\n    this._hoverDate = value;\r\n    this.calendarCellHover.emit(value);\r\n  }\r\n  get hoverDate(): Date | null {\r\n    return this._hoverDate;\r\n  }\r\n  private _hoverDate: Date | null = null;\r\n\r\n  private calendarStateSubscription!: Subscription;\r\n\r\n  @HostBinding('class')\r\n  get hostClasses(): any {\r\n    return {\r\n      'calendars': true\r\n    };\r\n  }\r\n\r\n  @ViewChildren(CalendarMonthComponent) calendarMonths!: QueryList<CalendarMonthComponent>;\r\n\r\n  ngOnDestroy(): void {\r\n    this.calendarStateSubscribe(false);\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.calendarService.update({ locale: this.locale, view: this.view, range: this.range });\r\n  }\r\n\r\n  calendarStateSubscribe(subscribe: boolean = true): void {\r\n    if (subscribe) {\r\n      this.calendarStateSubscription =\r\n        this.calendarService.calendarState$.subscribe(state => {\r\n          const keys = Object.keys(state);\r\n          for (const key of keys) {\r\n            if (key in this) {\r\n              // @ts-ignore\r\n              this[key] = state[key];\r\n              if (key === 'startDate') {\r\n                setTimeout(() => {\r\n                  this.startDateChange.emit(this._startDate);\r\n                });\r\n                continue;\r\n              }\r\n              if (key === 'endDate') {\r\n                setTimeout(() => {\r\n                  this.endDateChange.emit(this._endDate);\r\n                });\r\n              }\r\n            }\r\n          }\r\n        });\r\n      return;\r\n    }\r\n    this.calendarStateSubscription.unsubscribe();\r\n  }\r\n\r\n  setCalendarPage(years: number, months = 0, setMonth?: number) {\r\n    const year = this.calendarDate.getFullYear();\r\n    const month = this.calendarDate.getMonth();\r\n    const d = new Date(year, month, 1);\r\n\r\n    years && d.setFullYear(d.getFullYear() + years);\r\n    months && d.setMonth(d.getMonth() + months);\r\n    typeof setMonth === 'number' && d.setMonth(setMonth);\r\n\r\n    this.calendarDate = d;\r\n  }\r\n\r\n  handleNavigationClick(direction: 'prev' | 'next', years = false) {\r\n    if (direction === 'prev') {\r\n      if (years) {\r\n        this.setCalendarPage(this.view === 'years' ? -10 : -1);\r\n        return;\r\n      }\r\n\r\n      if (this.view !== 'days') {\r\n        this.setCalendarPage(-1);\r\n        return;\r\n      }\r\n\r\n      this.setCalendarPage(0, -1);\r\n      return;\r\n    }\r\n    if (direction === 'next') {\r\n      if (years) {\r\n        this.setCalendarPage(this.view === 'years' ? 10 : 1);\r\n        return;\r\n      }\r\n\r\n      if (this.view !== 'days') {\r\n        this.setCalendarPage(1);\r\n        return;\r\n      }\r\n\r\n      this.setCalendarPage(0, 1);\r\n      return;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Clear startDate and endDate\r\n   * @type void\r\n   */\r\n  public clearDates() {\r\n    this.calendarService.update({ startDate: null, endDate: null });\r\n  }\r\n}\r\n","<ng-container *ngFor=\"let calendar of calendarsArray; let i=index;\">\r\n  <div [ngClass]=\"view | calendarClassView\">\r\n    <c-calendar-navigation\r\n      [addMonths]=\"i\"\r\n      [navigation]=\"navigation\"\r\n      (navigationClick)=\"handleNavigationClick($event.direction, $event.years)\"\r\n    ></c-calendar-navigation>\r\n\r\n    <c-calendar-month\r\n      [addMonths]=\"i\"\r\n      [firstDayOfWeek]=\"firstDayOfWeek\"\r\n      [weekdayFormat]=\"weekdayFormat\"\r\n    ></c-calendar-month>\r\n  </div>\r\n</ng-container>\r\n"]}

package/esm2020/lib/calendar/calendar-month/calendar-class-day.pipe.mjs

@@ -0,0 +1,28 @@
+import { Pipe } from '@angular/core';
+import { isDateDisabled, isLastDayOfMonth, isToday } from '../calendar.utils';
+import * as i0 from "@angular/core";
+export class CalendarClassDayPipe {
+    transform(dateObj, datesConfig) {
+        const { date, month } = { ...dateObj };
+        const { minDate, maxDate, disabledDates, dateFilter } = { ...datesConfig };
+        // @ts-ignore
+        const disabled = isDateDisabled(date, minDate, maxDate, disabledDates) || (dateFilter ? !dateFilter(date) : false);
+        return {
+            'calendar-cell': true,
+            today: isToday(date),
+            disabled: disabled,
+            next: month === 'next',
+            previous: month === 'previous',
+            last: isLastDayOfMonth(date)
+        };
+    }
+}
+CalendarClassDayPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarClassDayPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+CalendarClassDayPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarClassDayPipe, name: "calendarClassDay" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarClassDayPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'calendarClassDay'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/calendar/calendar-month/calendar-class-month.pipe.mjs

@@ -0,0 +1,21 @@
+import { Pipe } from '@angular/core';
+import { isThisMonth } from '../calendar.utils';
+import * as i0 from "@angular/core";
+export class CalendarClassMonthPipe {
+    transform(calendarDate, monthIndex) {
+        return {
+            'calendar-cell': true,
+            month: true,
+            today: isThisMonth(calendarDate, monthIndex)
+        };
+    }
+}
+CalendarClassMonthPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarClassMonthPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+CalendarClassMonthPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarClassMonthPipe, name: "calendarClassMonth" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarClassMonthPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'calendarClassMonth'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsZW5kYXItY2xhc3MtbW9udGgucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmV1aS1hbmd1bGFyL3NyYy9saWIvY2FsZW5kYXIvY2FsZW5kYXItbW9udGgvY2FsZW5kYXItY2xhc3MtbW9udGgucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUNwRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7O0FBS2hELE1BQU0sT0FBTyxzQkFBc0I7SUFFakMsU0FBUyxDQUFDLFlBQWtCLEVBQUUsVUFBa0I7UUFFOUMsT0FBTztZQUNMLGVBQWUsRUFBRSxJQUFJO1lBQ3JCLEtBQUssRUFBRSxJQUFJO1lBQ1gsS0FBSyxFQUFFLFdBQVcsQ0FBQyxZQUFZLEVBQUUsVUFBVSxDQUFDO1NBQzdDLENBQUM7SUFDSixDQUFDOztvSEFUVSxzQkFBc0I7a0hBQXRCLHNCQUFzQjs0RkFBdEIsc0JBQXNCO2tCQUhsQyxJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxvQkFBb0I7aUJBQzNCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBpc1RoaXNNb250aCB9IGZyb20gJy4uL2NhbGVuZGFyLnV0aWxzJztcclxuXHJcbkBQaXBlKHtcclxuICBuYW1lOiAnY2FsZW5kYXJDbGFzc01vbnRoJ1xyXG59KVxyXG5leHBvcnQgY2xhc3MgQ2FsZW5kYXJDbGFzc01vbnRoUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xyXG5cclxuICB0cmFuc2Zvcm0oY2FsZW5kYXJEYXRlOiBEYXRlLCBtb250aEluZGV4OiBudW1iZXIpOiBhbnkge1xyXG5cclxuICAgIHJldHVybiB7XHJcbiAgICAgICdjYWxlbmRhci1jZWxsJzogdHJ1ZSxcclxuICAgICAgbW9udGg6IHRydWUsXHJcbiAgICAgIHRvZGF5OiBpc1RoaXNNb250aChjYWxlbmRhckRhdGUsIG1vbnRoSW5kZXgpXHJcbiAgICB9O1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2020/lib/calendar/calendar-month/calendar-class-year.pipe.mjs

@@ -0,0 +1,21 @@
+import { Pipe } from '@angular/core';
+import { isThisYear } from '../calendar.utils';
+import * as i0 from "@angular/core";
+export class CalendarClassYearPipe {
+    transform(year, args) {
+        return {
+            'calendar-cell': true,
+            year: true,
+            today: isThisYear(year)
+        };
+    }
+}
+CalendarClassYearPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarClassYearPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+CalendarClassYearPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarClassYearPipe, name: "calendarClassYear" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarClassYearPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'calendarClassYear'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsZW5kYXItY2xhc3MteWVhci5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29yZXVpLWFuZ3VsYXIvc3JjL2xpYi9jYWxlbmRhci9jYWxlbmRhci1tb250aC9jYWxlbmRhci1jbGFzcy15ZWFyLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7QUFDcEQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLG1CQUFtQixDQUFDOztBQUsvQyxNQUFNLE9BQU8scUJBQXFCO0lBRWhDLFNBQVMsQ0FBQyxJQUFZLEVBQUUsSUFBVTtRQUNoQyxPQUFPO1lBQ0wsZUFBZSxFQUFFLElBQUk7WUFDckIsSUFBSSxFQUFFLElBQUk7WUFDVixLQUFLLEVBQUUsVUFBVSxDQUFDLElBQUksQ0FBQztTQUN4QixDQUFDO0lBQ0osQ0FBQzs7bUhBUlUscUJBQXFCO2lIQUFyQixxQkFBcUI7NEZBQXJCLHFCQUFxQjtrQkFIakMsSUFBSTttQkFBQztvQkFDSixJQUFJLEVBQUUsbUJBQW1CO2lCQUMxQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgaXNUaGlzWWVhciB9IGZyb20gJy4uL2NhbGVuZGFyLnV0aWxzJztcclxuXHJcbkBQaXBlKHtcclxuICBuYW1lOiAnY2FsZW5kYXJDbGFzc1llYXInXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBDYWxlbmRhckNsYXNzWWVhclBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcclxuXHJcbiAgdHJhbnNmb3JtKHllYXI6IG51bWJlciwgYXJncz86IGFueSk6IGFueSB7XHJcbiAgICByZXR1cm4ge1xyXG4gICAgICAnY2FsZW5kYXItY2VsbCc6IHRydWUsXHJcbiAgICAgIHllYXI6IHRydWUsXHJcbiAgICAgIHRvZGF5OiBpc1RoaXNZZWFyKHllYXIpXHJcbiAgICB9O1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2020/lib/calendar/calendar-month/calendar-day.directive.mjs

@@ -0,0 +1,81 @@
+import { Directive, HostBinding, Input } from '@angular/core';
+import { isDateDisabled, isDateInRange, isDateInRangeDisabled, isDateSelected, isEndDate, isStartDate } from '../calendar.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../calendar.service";
+export class CalendarDayDirective {
+    constructor(calendarService) {
+        this.calendarService = calendarService;
+        this.date = null;
+        this.startDate = null;
+        this.endDate = null;
+        this.hoverDate = null;
+        this.maxDate = null;
+        this.minDate = null;
+        this.range = false;
+        this.calendarStateSubscribe();
+    }
+    set dateObj(value) {
+        this._dateObj = value;
+        this.date = value.date;
+        this.month = value.month;
+    }
+    get selectEndDate() {
+        return (this.range && !!this.startDate && !this.endDate);
+    }
+    get hostClasses() {
+        if (!this.date)
+            return;
+        const rangeHover = this.month === 'current' && this.selectEndDate && isDateInRange(this.date, this.startDate, this.hoverDate);
+        const inRange = this.month === 'current' && isDateInRange(this.date, this.startDate, this.endDate);
+        const selected = isDateSelected(this.date, this.startDate, this.endDate);
+        const start = isStartDate(this.date, this.startDate, this.endDate);
+        const end = isEndDate(this.date, this.startDate, this.endDate);
+        const disabledRange = isDateInRangeDisabled(this.startDate, this.date, this.disabledDates);
+        const disabledDate = isDateDisabled(this.date, this.minDate, this.maxDate, this.disabledDates);
+        const disabledByFilter = this.dateFilter ? !this.dateFilter(this.date) : false;
+        return {
+            'range-hover': rangeHover && (!disabledRange || !disabledByFilter),
+            selected: !!selected,
+            range: !!inRange,
+            start: !!start,
+            end: !!end,
+            disabled: disabledDate || disabledByFilter
+        };
+    }
+    ngOnDestroy() {
+        this.calendarStateSubscribe(false);
+    }
+    calendarStateSubscribe(subscribe = true) {
+        if (subscribe) {
+            this.calendarStateSubscription =
+                this.calendarService.calendarState$.subscribe(state => {
+                    const { startDate = this.startDate, endDate = this.endDate, hoverDate = this.hoverDate, range = this.range, maxDate = this.maxDate, minDate = this.minDate, disabledDates = this.disabledDates, dateFilter = this.dateFilter } = { ...state };
+                    this.startDate = startDate;
+                    this.endDate = endDate;
+                    this.range = range;
+                    this.hoverDate = hoverDate;
+                    this.maxDate = maxDate;
+                    this.minDate = minDate;
+                    this.disabledDates = disabledDates;
+                    this.dateFilter = dateFilter;
+                });
+            return;
+        }
+        this.calendarStateSubscription.unsubscribe();
+    }
+}
+CalendarDayDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarDayDirective, deps: [{ token: i1.CalendarService }], target: i0.ɵɵFactoryTarget.Directive });
+CalendarDayDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: CalendarDayDirective, selector: "[cCalendarDay]", inputs: { dateObj: ["cCalendarDay", "dateObj"] }, host: { properties: { "class": "this.hostClasses" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarDayDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cCalendarDay]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CalendarService }]; }, propDecorators: { dateObj: [{
+                type: Input,
+                args: ['cCalendarDay']
+            }], hostClasses: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calendar-day.directive.js","sourceRoot":"","sources":["../../../../../../projects/coreui-angular/src/lib/calendar/calendar-month/calendar-day.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, HostBinding, Input, OnDestroy } from '@angular/core';\r\nimport { Subscription } from 'rxjs';\r\nimport {\r\n  isDateDisabled,\r\n  isDateInRange,\r\n  isDateInRangeDisabled,\r\n  isDateSelected,\r\n  isEndDate,\r\n  isStartDate\r\n} from '../calendar.utils';\r\nimport { CalendarService, DateFilterType } from '../calendar.service';\r\n\r\n@Directive({\r\n  selector: '[cCalendarDay]'\r\n})\r\nexport class CalendarDayDirective implements OnDestroy {\r\n\r\n  constructor(\r\n    private calendarService: CalendarService\r\n  ) {\r\n    this.calendarStateSubscribe();\r\n  }\r\n\r\n  private date: Date | null = null;\r\n  private month?: string;\r\n  private startDate: Date | null = null;\r\n  private endDate: Date | null = null;\r\n  private hoverDate: Date | null = null;\r\n  private maxDate: Date | null = null;\r\n  private minDate: Date | null = null;\r\n  private range: boolean = false;\r\n  private disabledDates!: Date[] | Date[][];\r\n  private calendarStateSubscription!: Subscription;\r\n  private dateFilter!: DateFilterType;\r\n\r\n  private _dateObj?: { date: Date; month: string; };\r\n\r\n  @Input('cCalendarDay')\r\n  set dateObj(value: { date: Date; month: string }) {\r\n    this._dateObj = value;\r\n    this.date = value.date;\r\n    this.month = value.month;\r\n  }\r\n\r\n  get selectEndDate(): boolean {\r\n    return (this.range && !!this.startDate && !this.endDate);\r\n  }\r\n\r\n  @HostBinding('class')\r\n  get hostClasses(): any {\r\n\r\n    if (!this.date) return;\r\n\r\n    const rangeHover = this.month === 'current' && this.selectEndDate && isDateInRange(this.date, this.startDate, this.hoverDate);\r\n    const inRange = this.month === 'current' && isDateInRange(this.date, this.startDate, this.endDate);\r\n    const selected = isDateSelected(this.date, this.startDate, this.endDate);\r\n    const start = isStartDate(this.date, this.startDate, this.endDate);\r\n    const end = isEndDate(this.date, this.startDate, this.endDate);\r\n    const disabledRange = isDateInRangeDisabled(this.startDate, this.date, this.disabledDates);\r\n    const disabledDate = isDateDisabled(this.date, this.minDate, this.maxDate, this.disabledDates);\r\n    const disabledByFilter = this.dateFilter ? !this.dateFilter(this.date) : false;\r\n\r\n    return {\r\n      'range-hover': rangeHover && (!disabledRange || !disabledByFilter),\r\n      selected: !!selected,\r\n      range: !!inRange,\r\n      start: !!start,\r\n      end: !!end,\r\n      disabled: disabledDate || disabledByFilter\r\n    };\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.calendarStateSubscribe(false);\r\n  }\r\n\r\n  calendarStateSubscribe(subscribe: boolean = true): void {\r\n    if (subscribe) {\r\n      this.calendarStateSubscription =\r\n        this.calendarService.calendarState$.subscribe(state => {\r\n          const {\r\n            startDate = this.startDate,\r\n            endDate = this.endDate,\r\n            hoverDate = this.hoverDate,\r\n            range = this.range,\r\n            maxDate = this.maxDate,\r\n            minDate = this.minDate,\r\n            disabledDates = this.disabledDates,\r\n            dateFilter = this.dateFilter\r\n          } = { ...state };\r\n          this.startDate = startDate;\r\n          this.endDate = endDate;\r\n          this.range = range;\r\n          this.hoverDate = hoverDate;\r\n          this.maxDate = maxDate;\r\n          this.minDate = minDate;\r\n          this.disabledDates = disabledDates;\r\n          this.dateFilter = dateFilter;\r\n        });\r\n      return;\r\n    }\r\n    this.calendarStateSubscription.unsubscribe();\r\n  }\r\n}\r\n"]}

package/esm2020/lib/calendar/calendar-month/calendar-day.pipe.mjs

@@ -0,0 +1,18 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CalendarDayPipe {
+    transform(date, dayFormat = 'numeric', locale = 'default') {
+        return typeof dayFormat === 'function' ?
+            dayFormat(date) :
+            date.toLocaleDateString(locale, { day: dayFormat });
+    }
+}
+CalendarDayPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarDayPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+CalendarDayPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarDayPipe, name: "calendarDay" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: CalendarDayPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'calendarDay'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsZW5kYXItZGF5LnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JldWktYW5ndWxhci9zcmMvbGliL2NhbGVuZGFyL2NhbGVuZGFyLW1vbnRoL2NhbGVuZGFyLWRheS5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDOztBQU1wRCxNQUFNLE9BQU8sZUFBZTtJQUUxQixTQUFTLENBQUMsSUFBVSxFQUFFLFlBQTJCLFNBQVMsRUFBRSxTQUFpQixTQUFTO1FBQ3BGLE9BQU8sT0FBTyxTQUFTLEtBQUssVUFBVSxDQUFDLENBQUM7WUFDdEMsU0FBUyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7WUFDakIsSUFBSSxDQUFDLGtCQUFrQixDQUFDLE1BQU0sRUFBRSxFQUFFLEdBQUcsRUFBRSxTQUFTLEVBQUUsQ0FBQyxDQUFDO0lBQ3hELENBQUM7OzZHQU5VLGVBQWU7MkdBQWYsZUFBZTs0RkFBZixlQUFlO2tCQUgzQixJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxhQUFhO2lCQUNwQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgRGF5Rm9ybWF0VHlwZSB9IGZyb20gJy4uL2NhbGVuZGFyLnNlcnZpY2UnO1xyXG5cclxuQFBpcGUoe1xyXG4gIG5hbWU6ICdjYWxlbmRhckRheSdcclxufSlcclxuZXhwb3J0IGNsYXNzIENhbGVuZGFyRGF5UGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xyXG5cclxuICB0cmFuc2Zvcm0oZGF0ZTogRGF0ZSwgZGF5Rm9ybWF0OiBEYXlGb3JtYXRUeXBlID0gJ251bWVyaWMnLCBsb2NhbGU6IHN0cmluZyA9ICdkZWZhdWx0Jyk6IChzdHJpbmcgfCBudW1iZXIpIHtcclxuICAgIHJldHVybiB0eXBlb2YgZGF5Rm9ybWF0ID09PSAnZnVuY3Rpb24nID9cclxuICAgICAgZGF5Rm9ybWF0KGRhdGUpIDpcclxuICAgICAgZGF0ZS50b0xvY2FsZURhdGVTdHJpbmcobG9jYWxlLCB7IGRheTogZGF5Rm9ybWF0IH0pO1xyXG4gIH1cclxufVxyXG4iXX0=