@coreui/angular 3.0.0-alpha.9 → 4.0.0-alpha.3

package/esm2020/lib/table/table-color.directive.mjs

@@ -0,0 +1,24 @@
+import { Directive, HostBinding, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TableColorDirective {
+    get hostClasses() {
+        return {
+            [`table-${this.color}`]: !!this.color,
+        };
+    }
+}
+TableColorDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TableColorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+TableColorDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: TableColorDirective, selector: "[cTableColor]", inputs: { color: ["cTableColor", "color"] }, host: { properties: { "class": "this.hostClasses" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TableColorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cTableColor]'
+                }]
+        }], propDecorators: { color: [{
+                type: Input,
+                args: ['cTableColor']
+            }], hostClasses: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUtY29sb3IuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29yZXVpLWFuZ3VsYXIvc3JjL2xpYi90YWJsZS90YWJsZS1jb2xvci5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxXQUFXLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQU05RCxNQUFNLE9BQU8sbUJBQW1CO0lBUTlCLElBQ0ksV0FBVztRQUNiLE9BQU87WUFDTCxDQUFDLFNBQVMsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLO1NBQ3RDLENBQUM7SUFDSixDQUFDOztnSEFiVSxtQkFBbUI7b0dBQW5CLG1CQUFtQjsyRkFBbkIsbUJBQW1CO2tCQUgvQixTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxlQUFlO2lCQUMxQjs4QkFPdUIsS0FBSztzQkFBMUIsS0FBSzt1QkFBQyxhQUFhO2dCQUdoQixXQUFXO3NCQURkLFdBQVc7dUJBQUMsT0FBTyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSG9zdEJpbmRpbmcsIElucHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb2xvcnMgfSBmcm9tICcuLi9jb3JldWkudHlwZXMnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbY1RhYmxlQ29sb3JdJ1xufSlcbmV4cG9ydCBjbGFzcyBUYWJsZUNvbG9yRGlyZWN0aXZlIHtcblxuICAvKipcbiAgICogVXNlIGNvbnRleHR1YWwgY29sb3IgZm9yIHRhYmxlcywgdGFibGUgcm93cyBvciBpbmRpdmlkdWFsIGNlbGxzLlxuICAgKiBAdHlwZSBDb2xvcnNcbiAgICovXG4gIEBJbnB1dCgnY1RhYmxlQ29sb3InKSBjb2xvcj86IENvbG9ycztcblxuICBASG9zdEJpbmRpbmcoJ2NsYXNzJylcbiAgZ2V0IGhvc3RDbGFzc2VzKCk6IGFueSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIFtgdGFibGUtJHt0aGlzLmNvbG9yfWBdOiAhIXRoaXMuY29sb3IsXG4gICAgfTtcbiAgfVxufVxuIl19

package/esm2020/lib/table/table.directive.mjs

@@ -0,0 +1,131 @@
+import { Directive, HostBinding, Input } from '@angular/core';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+export class TableDirective {
+    constructor(renderer, hostElement) {
+        this.renderer = renderer;
+        this.hostElement = hostElement;
+        this._bordered = false;
+        this._borderless = false;
+        this._hover = false;
+        this._small = false;
+        this._striped = false;
+    }
+    /**
+     * Add borders on all sides of the table and cells.
+     * @type boolean
+     */
+    set bordered(value) {
+        this._bordered = coerceBooleanProperty(value);
+    }
+    ;
+    get bordered() {
+        return this._bordered;
+    }
+    /**
+     * Remove borders on all sides of the table and cells.
+     * @type boolean
+     */
+    set borderless(value) {
+        this._borderless = coerceBooleanProperty(value);
+    }
+    ;
+    get borderless() {
+        return this._borderless;
+    }
+    /**
+     * Enable a hover state on table rows within table body.
+     * @type boolean
+     */
+    set hover(value) {
+        this._hover = coerceBooleanProperty(value);
+    }
+    ;
+    get hover() {
+        return this._hover;
+    }
+    /**
+     * Make table more compact by cutting all cell `padding` in half.
+     * @type boolean
+     */
+    set small(value) {
+        this._small = coerceBooleanProperty(value);
+    }
+    ;
+    get small() {
+        return this._small;
+    }
+    /**
+     * Add zebra-striping to any table row within the table body`.
+     * @type boolean
+     */
+    set striped(value) {
+        this._striped = coerceBooleanProperty(value);
+    }
+    ;
+    get striped() {
+        return this._striped;
+    }
+    get hostClasses() {
+        return {
+            table: true,
+            [`align-${this.align}`]: !!this.align,
+            [`caption-${this.caption}`]: !!this.caption,
+            [`border-${this.borderColor}`]: !!this.borderColor,
+            'table-bordered': this.bordered,
+            'table-borderless': this.borderless,
+            [`table-${this.color}`]: !!this.color,
+            'table-hover': this.hover,
+            'table-sm': this.small,
+            'table-striped': this.striped
+        };
+    }
+    ngOnInit() {
+        this.setResponsiveWrapper();
+    }
+    // todo
+    setResponsiveWrapper() {
+        if (!!this.responsive) {
+            const nativeElement = this.hostElement.nativeElement;
+            const wrapper = this.renderer.createElement('div');
+            const className = this.responsive === true ? 'table-responsive' : `table-responsive-${this.responsive}`;
+            this.renderer.addClass(wrapper, className);
+            const parentNode = this.renderer.parentNode(nativeElement);
+            this.renderer.appendChild(parentNode, wrapper);
+            this.renderer.insertBefore(parentNode, wrapper, nativeElement);
+            this.renderer.appendChild(wrapper, nativeElement);
+        }
+    }
+}
+TableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TableDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+TableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: TableDirective, selector: "[cTable]", inputs: { align: "align", borderColor: "borderColor", bordered: "bordered", borderless: "borderless", caption: "caption", color: "color", hover: "hover", responsive: "responsive", small: "small", striped: "striped" }, host: { properties: { "class": "this.hostClasses" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cTable]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }]; }, propDecorators: { align: [{
+                type: Input
+            }], borderColor: [{
+                type: Input
+            }], bordered: [{
+                type: Input
+            }], borderless: [{
+                type: Input
+            }], caption: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], hover: [{
+                type: Input
+            }], responsive: [{
+                type: Input
+            }], small: [{
+                type: Input
+            }], striped: [{
+                type: Input
+            }], hostClasses: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.directive.js","sourceRoot":"","sources":["../../../../../projects/coreui-angular/src/lib/table/table.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, HostBinding, Input, OnInit, Renderer2 } from '@angular/core';\nimport { Breakpoints, Colors } from '../coreui.types';\nimport { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\n\n@Directive({\n  selector: '[cTable]'\n})\nexport class TableDirective implements OnInit {\n  static ngAcceptInputType_bordered: BooleanInput;\n  static ngAcceptInputType_borderless: BooleanInput;\n  static ngAcceptInputType_hover: BooleanInput;\n  static ngAcceptInputType_small: BooleanInput;\n  static ngAcceptInputType_striped: BooleanInput;\n\n  /**\n   * Set the vertical alignment.\n   * @type string\n   * @values 'bottom' | 'middle' | 'top'\n   */\n  @Input() align?: 'bottom' | 'middle' | 'top';\n  /**\n   * Sets the border color of the component to one of CoreUI’s themed colors.\n   * @type Colors\n   */\n  @Input() borderColor?: Colors;\n  /**\n   * Add borders on all sides of the table and cells.\n   * @type boolean\n   */\n  @Input()\n  set bordered(value: boolean) {\n    this._bordered = coerceBooleanProperty(value);\n  };\n  get bordered() {\n    return this._bordered;\n  }\n  private _bordered = false;\n  /**\n   * Remove borders on all sides of the table and cells.\n   * @type boolean\n   */\n  @Input()\n  set borderless(value: boolean) {\n    this._borderless = coerceBooleanProperty(value);\n  };\n  get borderless() {\n    return this._borderless;\n  }\n  private _borderless = false;\n  /**\n   * Put the `<caption>` on the top of the table.\n   * @values 'top'\n   */\n  @Input() caption?: 'top';\n  /**\n   * Sets the color context of the component to one of CoreUI’s themed colors.\n   * @type Colors\n   */\n  @Input() color?: Colors;\n  /**\n   * Enable a hover state on table rows within table body.\n   * @type boolean\n   */\n  @Input()\n  set hover(value: boolean) {\n    this._hover = coerceBooleanProperty(value);\n  };\n  get hover() {\n    return this._hover;\n  }\n  private _hover = false;\n  /**\n   * Make table responsive across all viewports or pick a maximum breakpoint with which to have a responsive table up to.\n   * @type: {boolean | 'sm' | 'md' | 'lg' | 'xl' | 'xxl'}\n   */\n  @Input() responsive?: boolean | Omit<Breakpoints, 'xs'>;\n  /**\n   * Make table more compact by cutting all cell `padding` in half.\n   * @type boolean\n   */\n  @Input()\n  set small(value: boolean) {\n    this._small = coerceBooleanProperty(value);\n  };\n  get small() {\n    return this._small;\n  }\n  private _small = false;\n  /**\n   * Add zebra-striping to any table row within the table body`.\n   * @type boolean\n   */\n  @Input()\n  set striped(value: boolean) {\n    this._striped = coerceBooleanProperty(value);\n  };\n  get striped() {\n    return this._striped;\n  }\n  private _striped = false;\n\n  constructor(\n    private renderer: Renderer2,\n    private hostElement: ElementRef\n  ) { }\n\n  @HostBinding('class')\n  get hostClasses(): any {\n    return {\n      table: true,\n      [`align-${this.align}`]: !!this.align,\n      [`caption-${this.caption}`]: !!this.caption,\n      [`border-${this.borderColor}`]: !!this.borderColor,\n      'table-bordered': this.bordered,\n      'table-borderless': this.borderless,\n      [`table-${this.color}`]: !!this.color,\n      'table-hover': this.hover,\n      'table-sm': this.small,\n      'table-striped': this.striped\n    };\n  }\n\n  ngOnInit(): void {\n    this.setResponsiveWrapper();\n  }\n\n  // todo\n  setResponsiveWrapper(): void {\n    if (!!this.responsive) {\n      const nativeElement: HTMLElement = this.hostElement.nativeElement;\n      const wrapper = this.renderer.createElement('div');\n      const className = this.responsive === true ? 'table-responsive' : `table-responsive-${this.responsive}`;\n      this.renderer.addClass(wrapper, className);\n      const parentNode = this.renderer.parentNode(nativeElement);\n      this.renderer.appendChild(parentNode, wrapper);\n      this.renderer.insertBefore(parentNode, wrapper, nativeElement);\n      this.renderer.appendChild(wrapper, nativeElement);\n    }\n  }\n}\n"]}

package/esm2020/lib/table/table.module.mjs

@@ -0,0 +1,36 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { TableDirective } from './table.directive';
+import { TableColorDirective } from './table-color.directive';
+import { TableActiveDirective } from './table-active.directive';
+import * as i0 from "@angular/core";
+export class TableModule {
+}
+TableModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TableModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TableModule, declarations: [TableDirective,
+        TableColorDirective,
+        TableActiveDirective], imports: [CommonModule], exports: [TableDirective,
+        TableColorDirective,
+        TableActiveDirective] });
+TableModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TableModule, imports: [[
+            CommonModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        TableDirective,
+                        TableColorDirective,
+                        TableActiveDirective
+                    ],
+                    exports: [
+                        TableDirective,
+                        TableColorDirective,
+                        TableActiveDirective
+                    ],
+                    imports: [
+                        CommonModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29yZXVpLWFuZ3VsYXIvc3JjL2xpYi90YWJsZS90YWJsZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzlELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDOztBQWlCaEUsTUFBTSxPQUFPLFdBQVc7O3dHQUFYLFdBQVc7eUdBQVgsV0FBVyxpQkFicEIsY0FBYztRQUNkLG1CQUFtQjtRQUNuQixvQkFBb0IsYUFRcEIsWUFBWSxhQUxaLGNBQWM7UUFDZCxtQkFBbUI7UUFDbkIsb0JBQW9CO3lHQU1YLFdBQVcsWUFKYjtZQUNQLFlBQVk7U0FDYjsyRkFFVSxXQUFXO2tCQWZ2QixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRTt3QkFDWixjQUFjO3dCQUNkLG1CQUFtQjt3QkFDbkIsb0JBQW9CO3FCQUNyQjtvQkFDRCxPQUFPLEVBQUU7d0JBQ1AsY0FBYzt3QkFDZCxtQkFBbUI7d0JBQ25CLG9CQUFvQjtxQkFDckI7b0JBQ0QsT0FBTyxFQUFFO3dCQUNQLFlBQVk7cUJBQ2I7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IFRhYmxlRGlyZWN0aXZlIH0gZnJvbSAnLi90YWJsZS5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgVGFibGVDb2xvckRpcmVjdGl2ZSB9IGZyb20gJy4vdGFibGUtY29sb3IuZGlyZWN0aXZlJztcbmltcG9ydCB7IFRhYmxlQWN0aXZlRGlyZWN0aXZlIH0gZnJvbSAnLi90YWJsZS1hY3RpdmUuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgVGFibGVEaXJlY3RpdmUsXG4gICAgVGFibGVDb2xvckRpcmVjdGl2ZSxcbiAgICBUYWJsZUFjdGl2ZURpcmVjdGl2ZVxuICBdLFxuICBleHBvcnRzOiBbXG4gICAgVGFibGVEaXJlY3RpdmUsXG4gICAgVGFibGVDb2xvckRpcmVjdGl2ZSxcbiAgICBUYWJsZUFjdGl2ZURpcmVjdGl2ZVxuICBdLFxuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlXG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgVGFibGVNb2R1bGUgeyB9XG4iXX0=

package/esm2020/lib/tabs/index.mjs

@@ -0,0 +1,2 @@
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JldWktYW5ndWxhci9zcmMvbGliL3RhYnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3B1YmxpY19hcGknO1xuIl19

package/esm2020/lib/tabs/public_api.mjs

@@ -0,0 +1,6 @@
+export { TabPaneComponent } from './tab-pane/tab-pane.component';
+export { TabContentComponent } from './tab-content/tab-content.component';
+export { TabContentRefDirective } from './tab-content-ref.directive';
+export { TabService } from './tab.service';
+export { TabsModule } from './tabs.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmV1aS1hbmd1bGFyL3NyYy9saWIvdGFicy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ2pFLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQzFFLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ3JFLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IFRhYlBhbmVDb21wb25lbnQgfSBmcm9tICcuL3RhYi1wYW5lL3RhYi1wYW5lLmNvbXBvbmVudCc7XG5leHBvcnQgeyBUYWJDb250ZW50Q29tcG9uZW50IH0gZnJvbSAnLi90YWItY29udGVudC90YWItY29udGVudC5jb21wb25lbnQnO1xuZXhwb3J0IHsgVGFiQ29udGVudFJlZkRpcmVjdGl2ZSB9IGZyb20gJy4vdGFiLWNvbnRlbnQtcmVmLmRpcmVjdGl2ZSc7XG5leHBvcnQgeyBUYWJTZXJ2aWNlIH0gZnJvbSAnLi90YWIuc2VydmljZSc7XG5leHBvcnQgeyBUYWJzTW9kdWxlIH0gZnJvbSAnLi90YWJzLm1vZHVsZSc7XG4iXX0=

package/esm2020/lib/tabs/tab-content/tab-content.component.mjs

@@ -0,0 +1,92 @@
+import { ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, HostBinding, Input, Output } from '@angular/core';
+import { coerceNumberProperty } from '@angular/cdk/coercion';
+import { TabPaneComponent } from '../tab-pane/tab-pane.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../tab.service";
+export class TabContentComponent {
+    constructor(changeDetectorRef, tabService) {
+        this.changeDetectorRef = changeDetectorRef;
+        this.tabService = tabService;
+        this._activeTabPaneIdx = -1;
+        /**
+         * Event emited on the active tab pane index change.
+         */
+        this.activeTabPaneIdxChange = new EventEmitter();
+    }
+    /**
+     * Set active tabPane index
+     * @type number
+     */
+    set activeTabPaneIdx(value) {
+        const newValue = coerceNumberProperty(value);
+        if (this._activeTabPaneIdx != newValue) {
+            this._activeTabPaneIdx = newValue;
+            this.activeTabPaneIdxChange.emit(newValue);
+            this.changeDetectorRef.markForCheck();
+            this.changeDetectorRef.detectChanges();
+        }
+    }
+    ;
+    get activeTabPaneIdx() {
+        return this._activeTabPaneIdx;
+    }
+    get hostClasses() {
+        return {
+            'tab-content': true
+        };
+    }
+    ngAfterContentInit() {
+        this.subscribeTabService();
+    }
+    ngAfterContentChecked() {
+        this.panes?.forEach((tabPane, index) => {
+            tabPane.tabContent = this;
+            tabPane.tabPaneIdx = index;
+        });
+        this.refreshTabPaneActive(this.activeTabPaneIdx);
+        this.tabService.setActiveTabIdx({ tabContent: this, activeIdx: this.activeTabPaneIdx });
+    }
+    ngOnChanges(changes) {
+        if (changes['activeTabPaneIdx']?.currentValue) {
+            this.tabService.setActiveTabIdx({ tabContent: this, activeIdx: changes['activeTabPaneIdx'].currentValue });
+        }
+    }
+    ngOnDestroy() {
+        this.subscribeTabService(false);
+    }
+    subscribeTabService(subscribe = true) {
+        if (subscribe) {
+            this.tabServiceSubscription = this.tabService.activeTabPaneIdx$.subscribe((tabContentState) => {
+                if (this === tabContentState.tabContent) {
+                    this.activeTabPaneIdx = tabContentState.activeIdx;
+                }
+            });
+        }
+        else {
+            this.tabServiceSubscription.unsubscribe();
+        }
+    }
+    refreshTabPaneActive(idx) {
+        // hack for active state pane refresh todo?
+        this.panes?.forEach((tabPane, index) => {
+            tabPane.active = idx === index;
+        });
+    }
+}
+TabContentComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TabContentComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.TabService }], target: i0.ɵɵFactoryTarget.Component });
+TabContentComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.3", type: TabContentComponent, selector: "c-tab-content", inputs: { activeTabPaneIdx: "activeTabPaneIdx" }, outputs: { activeTabPaneIdxChange: "activeTabPaneIdxChange" }, host: { properties: { "class": "this.hostClasses" } }, queries: [{ propertyName: "panes", predicate: TabPaneComponent }], exportAs: ["cTabContent"], usesOnChanges: true, ngImport: i0, template: "<ng-content></ng-content>\n", styles: [":host{display:block}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TabContentComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'c-tab-content', changeDetection: ChangeDetectionStrategy.OnPush, exportAs: 'cTabContent', template: "<ng-content></ng-content>\n", styles: [":host{display:block}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.TabService }]; }, propDecorators: { activeTabPaneIdx: [{
+                type: Input
+            }], activeTabPaneIdxChange: [{
+                type: Output
+            }], panes: [{
+                type: ContentChildren,
+                args: [TabPaneComponent]
+            }], hostClasses: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/tabs/tab-content-ref.directive.mjs

@@ -0,0 +1,128 @@
+import { Directive, HostBinding, HostListener, Input } from '@angular/core';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+import * as i1 from "./tab.service";
+export class TabContentRefDirective {
+    constructor(changeDetectorRef, tabService) {
+        this.changeDetectorRef = changeDetectorRef;
+        this.tabService = tabService;
+        this._active = false;
+        this._disabled = false;
+        /**
+         * c-tab-pane index respectively
+         * @type number
+         */
+        this.tabPaneIdx = -1;
+    }
+    /**
+     * Set active state of tab content
+     * @type boolean
+     */
+    set active(value) {
+        const newValue = coerceBooleanProperty(value);
+        if (this._active !== newValue) {
+            this._active = newValue;
+            this.changeDetectorRef.detectChanges();
+        }
+    }
+    get active() {
+        return this._active;
+    }
+    /**
+     * Set disabled state of tab content
+     * @type boolean
+     */
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+    }
+    get disabled() {
+        return this._disabled || this.tabPaneIdx >= this.tabContentRef?.panes?.length;
+    }
+    get hostClasses() {
+        return {
+            active: this.active,
+            disabled: this.disabled
+        };
+    }
+    get isDisabled() {
+        return this.disabled || null;
+    }
+    get attrDisabled() {
+        return this.disabled ? '' : null;
+    }
+    ;
+    get getTabindex() {
+        return this.disabled ? '-1' : null;
+    }
+    ngOnChanges(changes) {
+        if (changes['active']?.currentValue) {
+            this.setActiveTabPane();
+        }
+    }
+    toggleOpen($event) {
+        $event.preventDefault();
+        this.setActiveTabPane();
+    }
+    setActiveTabPane() {
+        setTimeout(() => {
+            if (this.tabPaneIdx < this.tabContentRef.panes.length) {
+                this.active = true;
+                this.tabService.setActiveTabIdx({ tabContent: this.tabContentRef, activeIdx: this.tabPaneIdx });
+            }
+            else {
+                this.active = false;
+            }
+        });
+    }
+    ngOnInit() {
+        this.subscribeTabService();
+    }
+    ngOnDestroy() {
+        this.subscribeTabService(false);
+    }
+    subscribeTabService(subscribe = true) {
+        if (subscribe) {
+            this.tabServiceSubscription = this.tabService.activeTabPaneIdx$.subscribe((tabContentState) => {
+                if (tabContentState.tabContent === this.tabContentRef) {
+                    this.active = (tabContentState.activeIdx === this.tabPaneIdx);
+                }
+            });
+        }
+        else {
+            this.tabServiceSubscription.unsubscribe();
+        }
+    }
+}
+TabContentRefDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TabContentRefDirective, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.TabService }], target: i0.ɵɵFactoryTarget.Directive });
+TabContentRefDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.3", type: TabContentRefDirective, selector: "[cTabContent]", inputs: { tabContentRef: ["cTabContent", "tabContentRef"], active: "active", disabled: "disabled", tabPaneIdx: "tabPaneIdx" }, host: { listeners: { "click": "toggleOpen($event)" }, properties: { "class": "this.hostClasses", "attr.aria-disabled": "this.isDisabled", "attr.disabled": "this.attrDisabled", "attr.tabindex": "this.getTabindex" } }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TabContentRefDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cTabContent]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.TabService }]; }, propDecorators: { tabContentRef: [{
+                type: Input,
+                args: ['cTabContent']
+            }], active: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], tabPaneIdx: [{
+                type: Input
+            }], hostClasses: [{
+                type: HostBinding,
+                args: ['class']
+            }], isDisabled: [{
+                type: HostBinding,
+                args: ['attr.aria-disabled']
+            }], attrDisabled: [{
+                type: HostBinding,
+                args: ['attr.disabled']
+            }], getTabindex: [{
+                type: HostBinding,
+                args: ['attr.tabindex']
+            }], toggleOpen: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-content-ref.directive.js","sourceRoot":"","sources":["../../../../../projects/coreui-angular/src/lib/tabs/tab-content-ref.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ChangeDetectorRef,\r\n  Directive,\r\n  HostBinding,\r\n  HostListener,\r\n  Input,\r\n  OnChanges,\r\n  OnDestroy,\r\n  OnInit,\r\n  SimpleChanges\r\n} from '@angular/core';\r\nimport { Subscription } from 'rxjs';\r\nimport { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\r\n\r\nimport { TabService } from './tab.service';\r\n\r\n@Directive({\r\n  selector: '[cTabContent]',\r\n})\r\nexport class TabContentRefDirective implements OnChanges, OnDestroy, OnInit {\r\n\r\n  constructor(\r\n    private changeDetectorRef: ChangeDetectorRef,\r\n    private tabService: TabService\r\n  ) { }\r\n\r\n  static ngAcceptInputType_disabled: BooleanInput;\r\n  private tabServiceSubscription!: Subscription;\r\n\r\n  /**\r\n   * Template Ref\r\n   * @type TemplateRef\r\n   */\r\n  @Input('cTabContent') tabContentRef!: any;\r\n\r\n  /**\r\n   * Set active state of tab content\r\n   * @type boolean\r\n   */\r\n  @Input()\r\n  set active(value: boolean) {\r\n    const newValue = coerceBooleanProperty(value);\r\n    if (this._active !== newValue) {\r\n      this._active = newValue;\r\n      this.changeDetectorRef.detectChanges();\r\n    }\r\n  }\r\n  get active() {\r\n    return this._active;\r\n  }\r\n  private _active = false;\r\n\r\n  /**\r\n   * Set disabled state of tab content\r\n   * @type boolean\r\n   */\r\n  @Input()\r\n  set disabled(value: boolean) {\r\n    this._disabled = coerceBooleanProperty(value);\r\n  }\r\n  get disabled(): boolean {\r\n    return this._disabled || this.tabPaneIdx >= this.tabContentRef?.panes?.length;\r\n  }\r\n  private _disabled = false;\r\n\r\n  /**\r\n   * c-tab-pane index respectively\r\n   * @type number\r\n   */\r\n  @Input() tabPaneIdx = -1;\r\n\r\n  @HostBinding('class')\r\n  get hostClasses() {\r\n    return {\r\n      active: this.active,\r\n      disabled: this.disabled\r\n    };\r\n  }\r\n\r\n  @HostBinding('attr.aria-disabled')\r\n  get isDisabled(): boolean | null {\r\n    return this.disabled || null;\r\n  }\r\n\r\n  @HostBinding('attr.disabled')\r\n  get attrDisabled() {\r\n    return this.disabled ? '' : null;\r\n  };\r\n\r\n  @HostBinding('attr.tabindex')\r\n  get getTabindex(): string | null {\r\n    return this.disabled ? '-1' : null;\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes['active']?.currentValue) {\r\n      this.setActiveTabPane();\r\n    }\r\n  }\r\n\r\n  @HostListener('click', ['$event'])\r\n  toggleOpen($event: any): void {\r\n    $event.preventDefault();\r\n    this.setActiveTabPane();\r\n  }\r\n\r\n  setActiveTabPane() {\r\n    setTimeout(() => {\r\n      if (this.tabPaneIdx < this.tabContentRef.panes.length) {\r\n        this.active = true;\r\n        this.tabService.setActiveTabIdx({ tabContent: this.tabContentRef, activeIdx: this.tabPaneIdx });\r\n      } else {\r\n        this.active = false;\r\n      }\r\n    });\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.subscribeTabService();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this.subscribeTabService(false);\r\n  }\r\n\r\n  subscribeTabService(subscribe: boolean = true) {\r\n    if (subscribe) {\r\n      this.tabServiceSubscription = this.tabService.activeTabPaneIdx$.subscribe((tabContentState) => {\r\n        if (tabContentState.tabContent === this.tabContentRef) {\r\n          this.active = (tabContentState.activeIdx === this.tabPaneIdx);\r\n        }\r\n      });\r\n    } else {\r\n      this.tabServiceSubscription.unsubscribe();\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2020/lib/tabs/tab-pane/tab-pane.component.mjs

@@ -0,0 +1,57 @@
+import { Component, HostBinding } from '@angular/core';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+import * as i1 from "../tab.service";
+export class TabPaneComponent {
+    constructor(changeDetectorRef, tabService) {
+        this.changeDetectorRef = changeDetectorRef;
+        this.tabService = tabService;
+        this._active = false;
+    }
+    set active(value) {
+        const newValue = coerceBooleanProperty(value);
+        if (this._active !== newValue) {
+            this._active = newValue;
+            this.changeDetectorRef.markForCheck();
+        }
+    }
+    get active() {
+        return this._active;
+    }
+    get hostClasses() {
+        return {
+            'tab-pane': true,
+            fade: true,
+            show: this.active,
+            active: this.active
+        };
+    }
+    ngOnInit() {
+        this.subscribeTabService();
+    }
+    ngOnDestroy() {
+        this.subscribeTabService(false);
+    }
+    subscribeTabService(subscribe = true) {
+        if (subscribe) {
+            this.tabServiceSubscription = this.tabService.activeTabPaneIdx$.subscribe((tabContentState) => {
+                if (tabContentState.tabContent === this.tabContent) {
+                    this.active = (tabContentState.activeIdx === this.tabPaneIdx);
+                }
+            });
+        }
+        else {
+            this.tabServiceSubscription.unsubscribe();
+        }
+    }
+}
+TabPaneComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TabPaneComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.TabService }], target: i0.ɵɵFactoryTarget.Component });
+TabPaneComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.3", type: TabPaneComponent, selector: "c-tab-pane", host: { properties: { "class": "this.hostClasses" } }, exportAs: ["cTabPane"], ngImport: i0, template: "<ng-content></ng-content>\n", styles: [":host{display:block}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TabPaneComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'c-tab-pane', exportAs: 'cTabPane', template: "<ng-content></ng-content>\n", styles: [":host{display:block}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.TabService }]; }, propDecorators: { hostClasses: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/tabs/tab.service.mjs

@@ -0,0 +1,21 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class TabService {
+    constructor() {
+        this.activeTabPaneIdx = new Subject();
+        this.activeTabPaneIdx$ = this.activeTabPaneIdx.asObservable();
+    }
+    setActiveTabIdx(tabContentState) {
+        this.activeTabPaneIdx.next(tabContentState);
+    }
+}
+TabService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TabService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TabService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TabService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TabService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFiLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JldWktYW5ndWxhci9zcmMvbGliL3RhYnMvdGFiLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sTUFBTSxDQUFDOztBQVcvQixNQUFNLE9BQU8sVUFBVTtJQUtyQjtRQUhRLHFCQUFnQixHQUFHLElBQUksT0FBTyxFQUFvQixDQUFDO1FBQzNELHNCQUFpQixHQUFHLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUV6QyxDQUFDO0lBRWpCLGVBQWUsQ0FBQyxlQUFpQztRQUMvQyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxDQUFDLGVBQWUsQ0FBQyxDQUFDO0lBQzlDLENBQUM7O3VHQVRVLFVBQVU7MkdBQVYsVUFBVSxjQUZULE1BQU07MkZBRVAsVUFBVTtrQkFIdEIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBUYWJDb250ZW50Q29tcG9uZW50IH0gZnJvbSAnLi90YWItY29udGVudC90YWItY29udGVudC5jb21wb25lbnQnO1xuXG5leHBvcnQgaW50ZXJmYWNlIElUYWJDb250ZW50U3RhdGUge1xuICBhY3RpdmVJZHg6IG51bWJlcixcbiAgdGFiQ29udGVudDogVGFiQ29udGVudENvbXBvbmVudFxufVxuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBUYWJTZXJ2aWNlIHtcblxuICBwcml2YXRlIGFjdGl2ZVRhYlBhbmVJZHggPSBuZXcgU3ViamVjdDxJVGFiQ29udGVudFN0YXRlPigpO1xuICBhY3RpdmVUYWJQYW5lSWR4JCA9IHRoaXMuYWN0aXZlVGFiUGFuZUlkeC5hc09ic2VydmFibGUoKTtcblxuICBjb25zdHJ1Y3RvcigpIHsgfVxuXG4gIHNldEFjdGl2ZVRhYklkeCh0YWJDb250ZW50U3RhdGU6IElUYWJDb250ZW50U3RhdGUpIHtcbiAgICB0aGlzLmFjdGl2ZVRhYlBhbmVJZHgubmV4dCh0YWJDb250ZW50U3RhdGUpO1xuICB9XG59XG4iXX0=

package/esm2020/lib/tabs/tabs.module.mjs

@@ -0,0 +1,42 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { TabContentComponent } from './tab-content/tab-content.component';
+import { TabPaneComponent } from './tab-pane/tab-pane.component';
+import { TabService } from './tab.service';
+import { TabContentRefDirective } from './tab-content-ref.directive';
+import * as i0 from "@angular/core";
+export class TabsModule {
+}
+TabsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TabsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TabsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TabsModule, declarations: [TabContentComponent,
+        TabPaneComponent,
+        TabContentRefDirective], imports: [CommonModule], exports: [TabContentComponent,
+        TabPaneComponent,
+        TabContentRefDirective] });
+TabsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TabsModule, providers: [
+        TabService
+    ], imports: [[
+            CommonModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: TabsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        TabContentComponent,
+                        TabPaneComponent,
+                        TabContentRefDirective
+                    ],
+                    imports: [
+                        CommonModule
+                    ],
+                    exports: [
+                        TabContentComponent,
+                        TabPaneComponent,
+                        TabContentRefDirective
+                    ],
+                    providers: [
+                        TabService
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/toast/index.mjs

@@ -0,0 +1,2 @@
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JldWktYW5ndWxhci9zcmMvbGliL3RvYXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wdWJsaWNfYXBpJztcbiJdfQ==

package/esm2020/lib/toast/public_api.mjs

@@ -0,0 +1,9 @@
+export { ToastComponent } from './toast/toast.component';
+export { ToastBodyComponent } from './toast-body/toast-body.component';
+export { ToastHeaderComponent } from './toast-header/toast-header.component';
+export { ToasterComponent, ToasterPlacement } from './toaster/toaster.component';
+export { ToasterService } from './toaster/toaster.service';
+export { ToasterHostDirective } from './toaster/toaster-host.directive';
+export { ToastCloseDirective } from './toast-close.directive';
+export { ToastModule } from './toast.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmV1aS1hbmd1bGFyL3NyYy9saWIvdG9hc3QvcHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDekQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFDdkUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFDN0UsT0FBTyxFQUFFLGdCQUFnQixFQUFxQixnQkFBZ0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ3BHLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUMzRCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUN4RSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM5RCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBUb2FzdENvbXBvbmVudCB9IGZyb20gJy4vdG9hc3QvdG9hc3QuY29tcG9uZW50JztcbmV4cG9ydCB7IFRvYXN0Qm9keUNvbXBvbmVudCB9IGZyb20gJy4vdG9hc3QtYm9keS90b2FzdC1ib2R5LmNvbXBvbmVudCc7XG5leHBvcnQgeyBUb2FzdEhlYWRlckNvbXBvbmVudCB9IGZyb20gJy4vdG9hc3QtaGVhZGVyL3RvYXN0LWhlYWRlci5jb21wb25lbnQnO1xuZXhwb3J0IHsgVG9hc3RlckNvbXBvbmVudCwgVFRvYXN0ZXJQbGFjZW1lbnQsIFRvYXN0ZXJQbGFjZW1lbnQgfSBmcm9tICcuL3RvYXN0ZXIvdG9hc3Rlci5jb21wb25lbnQnO1xuZXhwb3J0IHsgVG9hc3RlclNlcnZpY2UgfSBmcm9tICcuL3RvYXN0ZXIvdG9hc3Rlci5zZXJ2aWNlJztcbmV4cG9ydCB7IFRvYXN0ZXJIb3N0RGlyZWN0aXZlIH0gZnJvbSAnLi90b2FzdGVyL3RvYXN0ZXItaG9zdC5kaXJlY3RpdmUnO1xuZXhwb3J0IHsgVG9hc3RDbG9zZURpcmVjdGl2ZSB9IGZyb20gJy4vdG9hc3QtY2xvc2UuZGlyZWN0aXZlJztcbmV4cG9ydCB7IFRvYXN0TW9kdWxlIH0gZnJvbSAnLi90b2FzdC5tb2R1bGUnO1xuIl19