cmat 0.0.3

package/esm2022/components/date-range/public-api.mjs

@@ -0,0 +1,2 @@
+export * from './date-range.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvY29tcG9uZW50cy9kYXRlLXJhbmdlL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGF0ZS1yYW5nZS5jb21wb25lbnQnO1xyXG4iXX0=

package/esm2022/components/drawer/cmat-components-drawer.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1jb21wb25lbnRzLWRyYXdlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvY29tcG9uZW50cy9kcmF3ZXIvY21hdC1jb21wb25lbnRzLWRyYXdlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/components/drawer/drawer.component.mjs

@@ -0,0 +1,301 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, HostBinding, HostListener, Input, Output, ViewEncapsulation } from '@angular/core';
+import { animate, style } from '@angular/animations';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/animations";
+import * as i2 from "./drawer.service";
+import * as i3 from "cmat/services/utils";
+export class CmatDrawerComponent {
+    constructor(_animationBuilder, _elementRef, _renderer2, _cmatDrawerService, _cmatUtilsService) {
+        this._animationBuilder = _animationBuilder;
+        this._elementRef = _elementRef;
+        this._renderer2 = _renderer2;
+        this._cmatDrawerService = _cmatDrawerService;
+        this._cmatUtilsService = _cmatUtilsService;
+        /* eslint-enable @typescript-eslint/naming-convention */
+        this.fixed = false;
+        this.mode = 'side';
+        this.name = this._cmatUtilsService.randomId();
+        this.opened = false;
+        this.position = 'left';
+        this.transparentOverlay = false;
+        this.fixedChanged = new EventEmitter();
+        this.modeChanged = new EventEmitter();
+        this.openedChanged = new EventEmitter();
+        this.positionChanged = new EventEmitter();
+        this._animationsEnabled = false;
+        this._hovered = false;
+    }
+    get classList() {
+        /* eslint-disable @typescript-eslint/naming-convention */
+        return {
+            'cmat-drawer-animations-enabled': this._animationsEnabled,
+            'cmat-drawer-fixed': this.fixed,
+            'cmat-drawer-hover': this._hovered,
+            [`cmat-drawer-mode-${this.mode}`]: true,
+            'cmat-drawer-opened': this.opened,
+            [`cmat-drawer-position-${this.position}`]: true
+        };
+    }
+    get styleList() {
+        return {
+            'visibility': this.opened ? 'visible' : 'hidden'
+        };
+    }
+    onMouseenter() {
+        // Enable the animations
+        this._enableAnimations();
+        // Set the hovered
+        this._hovered = true;
+    }
+    onMouseleave() {
+        // Enable the animations
+        this._enableAnimations();
+        // Set the hovered
+        this._hovered = false;
+    }
+    ngOnChanges(changes) {
+        // Fixed
+        if ('fixed' in changes) {
+            // Coerce the value to a boolean
+            this.fixed = coerceBooleanProperty(changes['fixed'].currentValue);
+            // Execute the observable
+            this.fixedChanged.next(this.fixed);
+        }
+        // Mode
+        if ('mode' in changes) {
+            // Get the previous and current values
+            const previousMode = changes['mode'].previousValue;
+            const currentMode = changes['mode'].currentValue;
+            // Disable the animations
+            this._disableAnimations();
+            // If the mode changes: 'over -> side'
+            if (previousMode === 'over' && currentMode === 'side') {
+                // Hide the overlay
+                this._hideOverlay();
+            }
+            // If the mode changes: 'side -> over'
+            if (previousMode === 'side' && currentMode === 'over') {
+                // If the drawer is opened
+                if (this.opened) {
+                    // Show the overlay
+                    this._showOverlay();
+                }
+            }
+            // Execute the observable
+            this.modeChanged.next(currentMode);
+            // Enable the animations after a delay
+            // The delay must be bigger than the current transition-duration
+            // to make sure nothing will be animated while the mode is changing
+            setTimeout(() => {
+                this._enableAnimations();
+            }, 500);
+        }
+        // Opened
+        if ('opened' in changes) {
+            // Coerce the value to a boolean
+            const open = coerceBooleanProperty(changes['opened'].currentValue);
+            // Open/close the drawer
+            this._toggleOpened(open);
+        }
+        // Position
+        if ('position' in changes) {
+            // Execute the observable
+            this.positionChanged.next(this.position);
+        }
+        // Transparent overlay
+        if ('transparentOverlay' in changes) {
+            // Coerce the value to a boolean
+            this.transparentOverlay = coerceBooleanProperty(changes['transparentOverlay'].currentValue);
+        }
+    }
+    ngOnInit() {
+        // Register the drawer
+        this._cmatDrawerService.registerComponent(this.name, this);
+    }
+    ngOnDestroy() {
+        // Deregister the drawer from the registry
+        this._cmatDrawerService.deregisterComponent(this.name);
+    }
+    open() {
+        // Return if the drawer has already opened
+        if (this.opened) {
+            return;
+        }
+        // Open the drawer
+        this._toggleOpened(true);
+    }
+    close() {
+        // Return if the drawer has already closed
+        if (!this.opened) {
+            return;
+        }
+        // Close the drawer
+        this._toggleOpened(false);
+    }
+    toggle() {
+        if (this.opened) {
+            this.close();
+        }
+        else {
+            this.open();
+        }
+    }
+    /**
+     * Enable the animations
+     *
+     * @private
+     */
+    _enableAnimations() {
+        // Return if the animations are already enabled
+        if (this._animationsEnabled) {
+            return;
+        }
+        // Enable the animations
+        this._animationsEnabled = true;
+    }
+    /**
+     * Disable the animations
+     *
+     * @private
+     */
+    _disableAnimations() {
+        // Return if the animations are already disabled
+        if (!this._animationsEnabled) {
+            return;
+        }
+        // Disable the animations
+        this._animationsEnabled = false;
+    }
+    /**
+     * Show the backdrop
+     *
+     * @private
+     */
+    _showOverlay() {
+        // Create the backdrop element
+        this._overlay = this._renderer2.createElement('div');
+        // Return if overlay couldn't be create for some reason
+        if (!this._overlay) {
+            return;
+        }
+        // Add a class to the backdrop element
+        this._overlay.classList.add('cmat-drawer-overlay');
+        // Add a class depending on the fixed option
+        if (this.fixed) {
+            this._overlay.classList.add('cmat-drawer-overlay-fixed');
+        }
+        // Add a class depending on the transparentOverlay option
+        if (this.transparentOverlay) {
+            this._overlay.classList.add('cmat-drawer-overlay-transparent');
+        }
+        // Append the backdrop to the parent of the drawer
+        this._renderer2.appendChild(this._elementRef.nativeElement.parentElement, this._overlay);
+        // Create the enter animation and attach it to the player
+        this._player = this._animationBuilder.build([
+            animate('300ms cubic-bezier(0.25, 0.8, 0.25, 1)', style({ opacity: 1 }))
+        ]).create(this._overlay);
+        // Once the animation is done...
+        this._player.onDone(() => {
+            // Destroy the player
+            this._player.destroy();
+        });
+        // Play the animation
+        this._player.play();
+        // Add an event listener to the overlay
+        this._overlay.addEventListener('click', () => {
+            this.close();
+        });
+    }
+    /**
+     * Hide the backdrop
+     *
+     * @private
+     */
+    _hideOverlay() {
+        if (!this._overlay) {
+            return;
+        }
+        // Create the leave animation and attach it to the player
+        this._player = this._animationBuilder.build([
+            animate('300ms cubic-bezier(0.25, 0.8, 0.25, 1)', style({ opacity: 0 }))
+        ]).create(this._overlay);
+        // Play the animation
+        this._player.play();
+        // Once the animation is done...
+        this._player.onDone(() => {
+            // Destroy the player
+            this._player.destroy();
+            // If the backdrop still exists...
+            if (this._overlay) {
+                // Remove the backdrop
+                this._overlay.parentNode?.removeChild(this._overlay);
+                this._overlay = null;
+            }
+        });
+    }
+    /**
+     * Open/close the drawer
+     *
+     * @param open
+     * @private
+     */
+    _toggleOpened(open) {
+        // Set the opened
+        this.opened = open;
+        // Enable the animations
+        this._enableAnimations();
+        // If the mode is 'over'
+        if (this.mode === 'over') {
+            // If the drawer opens, show the overlay
+            if (open) {
+                this._showOverlay();
+            }
+            // Otherwise, close the overlay
+            else {
+                this._hideOverlay();
+            }
+        }
+        // Execute the observable
+        this.openedChanged.next(open);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDrawerComponent, deps: [{ token: i1.AnimationBuilder }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i2.CmatDrawerService }, { token: i3.CmatUtilsService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.0", type: CmatDrawerComponent, isStandalone: true, selector: "cmat-drawer", inputs: { fixed: "fixed", mode: "mode", name: "name", opened: "opened", position: "position", transparentOverlay: "transparentOverlay" }, outputs: { fixedChanged: "fixedChanged", modeChanged: "modeChanged", openedChanged: "openedChanged", positionChanged: "positionChanged" }, host: { listeners: { "mouseenter": "onMouseenter()", "mouseleave": "onMouseleave()" }, properties: { "class": "this.classList", "style": "this.styleList" } }, exportAs: ["cmatDrawer"], usesOnChanges: true, ngImport: i0, template: "<div class=\"cmat-drawer-content\">\r\n    <ng-content></ng-content>\r\n</div>", styles: [":root{--cmat-drawer-width: 320px}cmat-drawer{position:relative;display:flex;flex-direction:column;flex:1 1 auto;width:var(--cmat-drawer-width);min-width:var(--cmat-drawer-width);max-width:var(--cmat-drawer-width);z-index:300;box-shadow:0 2px 8px #00000059;@apply bg-card;}cmat-drawer.cmat-drawer-animations-enabled{transition-duration:.4s;transition-timing-function:cubic-bezier(.25,.8,.25,1);transition-property:visibility,margin-left,margin-right,transform,width,max-width,min-width}cmat-drawer.cmat-drawer-animations-enabled .cmat-drawer-content{transition-duration:.4s;transition-timing-function:cubic-bezier(.25,.8,.25,1);transition-property:width,max-width,min-width}cmat-drawer.cmat-drawer-mode-over{position:absolute;top:0;bottom:0}cmat-drawer.cmat-drawer-mode-over.cmat-drawer-fixed{position:fixed}cmat-drawer.cmat-drawer-position-left.cmat-drawer-mode-side{margin-left:calc(var(--cmat-drawer-width) * -1)}cmat-drawer.cmat-drawer-position-left.cmat-drawer-mode-side.cmat-drawer-opened{margin-left:0}cmat-drawer.cmat-drawer-position-left.cmat-drawer-mode-over{left:0;transform:translate3d(-100%,0,0)}cmat-drawer.cmat-drawer-position-left.cmat-drawer-mode-over.cmat-drawer-opened{transform:translateZ(0)}cmat-drawer.cmat-drawer-position-left .cmat-drawer-content{left:0}cmat-drawer.cmat-drawer-position-right.cmat-drawer-mode-side{margin-right:calc(var(--cmat-drawer-width) * -1)}cmat-drawer.cmat-drawer-position-right.cmat-drawer-mode-side.cmat-drawer-opened{margin-right:0}cmat-drawer.cmat-drawer-position-right.cmat-drawer-mode-over{right:0;transform:translate3d(100%,0,0)}cmat-drawer.cmat-drawer-position-right.cmat-drawer-mode-over.cmat-drawer-opened{transform:translateZ(0)}cmat-drawer.cmat-drawer-position-right .cmat-drawer-content{right:0}cmat-drawer .cmat-drawer-content{position:absolute;display:flex;flex:1 1 auto;top:0;bottom:0;width:100%;height:100%;overflow:hidden;@apply bg-card;}.cmat-drawer-overlay{position:absolute;inset:0;z-index:299;opacity:1;background-color:#0009}.cmat-drawer-overlay.cmat-drawer-overlay-fixed{position:fixed}.cmat-drawer-overlay.cmat-drawer-overlay-transparent{background-color:transparent}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDrawerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cmat-drawer', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, exportAs: 'cmatDrawer', standalone: true, template: "<div class=\"cmat-drawer-content\">\r\n    <ng-content></ng-content>\r\n</div>", styles: [":root{--cmat-drawer-width: 320px}cmat-drawer{position:relative;display:flex;flex-direction:column;flex:1 1 auto;width:var(--cmat-drawer-width);min-width:var(--cmat-drawer-width);max-width:var(--cmat-drawer-width);z-index:300;box-shadow:0 2px 8px #00000059;@apply bg-card;}cmat-drawer.cmat-drawer-animations-enabled{transition-duration:.4s;transition-timing-function:cubic-bezier(.25,.8,.25,1);transition-property:visibility,margin-left,margin-right,transform,width,max-width,min-width}cmat-drawer.cmat-drawer-animations-enabled .cmat-drawer-content{transition-duration:.4s;transition-timing-function:cubic-bezier(.25,.8,.25,1);transition-property:width,max-width,min-width}cmat-drawer.cmat-drawer-mode-over{position:absolute;top:0;bottom:0}cmat-drawer.cmat-drawer-mode-over.cmat-drawer-fixed{position:fixed}cmat-drawer.cmat-drawer-position-left.cmat-drawer-mode-side{margin-left:calc(var(--cmat-drawer-width) * -1)}cmat-drawer.cmat-drawer-position-left.cmat-drawer-mode-side.cmat-drawer-opened{margin-left:0}cmat-drawer.cmat-drawer-position-left.cmat-drawer-mode-over{left:0;transform:translate3d(-100%,0,0)}cmat-drawer.cmat-drawer-position-left.cmat-drawer-mode-over.cmat-drawer-opened{transform:translateZ(0)}cmat-drawer.cmat-drawer-position-left .cmat-drawer-content{left:0}cmat-drawer.cmat-drawer-position-right.cmat-drawer-mode-side{margin-right:calc(var(--cmat-drawer-width) * -1)}cmat-drawer.cmat-drawer-position-right.cmat-drawer-mode-side.cmat-drawer-opened{margin-right:0}cmat-drawer.cmat-drawer-position-right.cmat-drawer-mode-over{right:0;transform:translate3d(100%,0,0)}cmat-drawer.cmat-drawer-position-right.cmat-drawer-mode-over.cmat-drawer-opened{transform:translateZ(0)}cmat-drawer.cmat-drawer-position-right .cmat-drawer-content{right:0}cmat-drawer .cmat-drawer-content{position:absolute;display:flex;flex:1 1 auto;top:0;bottom:0;width:100%;height:100%;overflow:hidden;@apply bg-card;}.cmat-drawer-overlay{position:absolute;inset:0;z-index:299;opacity:1;background-color:#0009}.cmat-drawer-overlay.cmat-drawer-overlay-fixed{position:fixed}.cmat-drawer-overlay.cmat-drawer-overlay-transparent{background-color:transparent}\n"] }]
+        }], ctorParameters: () => [{ type: i1.AnimationBuilder }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i2.CmatDrawerService }, { type: i3.CmatUtilsService }], propDecorators: { fixed: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], opened: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }], transparentOverlay: [{
+                type: Input
+            }], fixedChanged: [{
+                type: Output
+            }], modeChanged: [{
+                type: Output
+            }], openedChanged: [{
+                type: Output
+            }], positionChanged: [{
+                type: Output
+            }], classList: [{
+                type: HostBinding,
+                args: ['class']
+            }], styleList: [{
+                type: HostBinding,
+                args: ['style']
+            }], onMouseenter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], onMouseleave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drawer.component.js","sourceRoot":"","sources":["../../../../../projects/cmat/components/drawer/drawer.component.ts","../../../../../projects/cmat/components/drawer/drawer.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, ElementRef, EventEmitter, HostBinding, HostListener, Input, OnChanges, OnDestroy, OnInit, Output, Renderer2, SimpleChanges, ViewEncapsulation } from '@angular/core';\r\nimport { animate, AnimationBuilder, AnimationPlayer, style } from '@angular/animations';\r\n\r\nimport { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\r\nimport { CmatDrawerService } from './drawer.service';\r\nimport { CmatDrawerMode, CmatDrawerPosition } from './drawer.types';\r\nimport { CmatUtilsService } from 'cmat/services/utils';\r\n\r\n@Component({\r\n    selector: 'cmat-drawer',\r\n    templateUrl: './drawer.component.html',\r\n    styleUrls: ['./drawer.component.scss'],\r\n    encapsulation: ViewEncapsulation.None,\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n    exportAs: 'cmatDrawer',\r\n    standalone: true\r\n})\r\nexport class CmatDrawerComponent implements OnChanges, OnInit, OnDestroy {\r\n    /* eslint-disable @typescript-eslint/naming-convention */\r\n    static ngAcceptInputType_fixed: BooleanInput;\r\n    static ngAcceptInputType_opened: BooleanInput;\r\n    static ngAcceptInputType_transparentOverlay: BooleanInput;\r\n    /* eslint-enable @typescript-eslint/naming-convention */\r\n\r\n    @Input() fixed: boolean = false;\r\n    @Input() mode: CmatDrawerMode = 'side';\r\n    @Input() name: string = this._cmatUtilsService.randomId();\r\n    @Input() opened: boolean = false;\r\n    @Input() position: CmatDrawerPosition = 'left';\r\n    @Input() transparentOverlay: boolean = false;\r\n    @Output() readonly fixedChanged: EventEmitter<boolean> = new EventEmitter<boolean>();\r\n    @Output() readonly modeChanged: EventEmitter<CmatDrawerMode> = new EventEmitter<CmatDrawerMode>();\r\n    @Output() readonly openedChanged: EventEmitter<boolean> = new EventEmitter<boolean>();\r\n    @Output() readonly positionChanged: EventEmitter<CmatDrawerPosition> = new EventEmitter<CmatDrawerPosition>();\r\n\r\n    private _animationsEnabled: boolean = false;\r\n    private _hovered: boolean = false;\r\n    private _overlay: HTMLElement | null;\r\n    private _player: AnimationPlayer;\r\n\r\n    constructor(\r\n        private _animationBuilder: AnimationBuilder,\r\n        private _elementRef: ElementRef,\r\n        private _renderer2: Renderer2,\r\n        private _cmatDrawerService: CmatDrawerService,\r\n        private _cmatUtilsService: CmatUtilsService\r\n    ) {\r\n    }\r\n\r\n    @HostBinding('class') get classList(): any {\r\n        /* eslint-disable @typescript-eslint/naming-convention */\r\n        return {\r\n            'cmat-drawer-animations-enabled': this._animationsEnabled,\r\n            'cmat-drawer-fixed': this.fixed,\r\n            'cmat-drawer-hover': this._hovered,\r\n            [`cmat-drawer-mode-${this.mode}`]: true,\r\n            'cmat-drawer-opened': this.opened,\r\n            [`cmat-drawer-position-${this.position}`]: true\r\n        };\r\n    }\r\n\r\n    @HostBinding('style') get styleList(): any {\r\n        return {\r\n            'visibility': this.opened ? 'visible' : 'hidden'\r\n        };\r\n    }\r\n\r\n    @HostListener('mouseenter')\r\n    onMouseenter(): void {\r\n        // Enable the animations\r\n        this._enableAnimations();\r\n\r\n        // Set the hovered\r\n        this._hovered = true;\r\n    }\r\n\r\n    @HostListener('mouseleave')\r\n    onMouseleave(): void {\r\n        // Enable the animations\r\n        this._enableAnimations();\r\n\r\n        // Set the hovered\r\n        this._hovered = false;\r\n    }\r\n\r\n    ngOnChanges(changes: SimpleChanges): void {\r\n        // Fixed\r\n        if ('fixed' in changes) {\r\n            // Coerce the value to a boolean\r\n            this.fixed = coerceBooleanProperty(changes['fixed'].currentValue);\r\n\r\n            // Execute the observable\r\n            this.fixedChanged.next(this.fixed);\r\n        }\r\n\r\n        // Mode\r\n        if ('mode' in changes) {\r\n            // Get the previous and current values\r\n            const previousMode = changes['mode'].previousValue;\r\n            const currentMode = changes['mode'].currentValue;\r\n\r\n            // Disable the animations\r\n            this._disableAnimations();\r\n\r\n            // If the mode changes: 'over -> side'\r\n            if (previousMode === 'over' && currentMode === 'side') {\r\n                // Hide the overlay\r\n                this._hideOverlay();\r\n            }\r\n\r\n            // If the mode changes: 'side -> over'\r\n            if (previousMode === 'side' && currentMode === 'over') {\r\n                // If the drawer is opened\r\n                if (this.opened) {\r\n                    // Show the overlay\r\n                    this._showOverlay();\r\n                }\r\n            }\r\n\r\n            // Execute the observable\r\n            this.modeChanged.next(currentMode);\r\n\r\n            // Enable the animations after a delay\r\n            // The delay must be bigger than the current transition-duration\r\n            // to make sure nothing will be animated while the mode is changing\r\n            setTimeout(() => {\r\n                this._enableAnimations();\r\n            }, 500);\r\n        }\r\n\r\n        // Opened\r\n        if ('opened' in changes) {\r\n            // Coerce the value to a boolean\r\n            const open = coerceBooleanProperty(changes['opened'].currentValue);\r\n\r\n            // Open/close the drawer\r\n            this._toggleOpened(open);\r\n        }\r\n\r\n        // Position\r\n        if ('position' in changes) {\r\n            // Execute the observable\r\n            this.positionChanged.next(this.position);\r\n        }\r\n\r\n        // Transparent overlay\r\n        if ('transparentOverlay' in changes) {\r\n            // Coerce the value to a boolean\r\n            this.transparentOverlay = coerceBooleanProperty(changes['transparentOverlay'].currentValue);\r\n        }\r\n    }\r\n\r\n    ngOnInit(): void {\r\n        // Register the drawer\r\n        this._cmatDrawerService.registerComponent(this.name, this);\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        // Deregister the drawer from the registry\r\n        this._cmatDrawerService.deregisterComponent(this.name);\r\n    }\r\n\r\n    open(): void {\r\n        // Return if the drawer has already opened\r\n        if (this.opened) {\r\n            return;\r\n        }\r\n\r\n        // Open the drawer\r\n        this._toggleOpened(true);\r\n    }\r\n\r\n    close(): void {\r\n        // Return if the drawer has already closed\r\n        if (!this.opened) {\r\n            return;\r\n        }\r\n\r\n        // Close the drawer\r\n        this._toggleOpened(false);\r\n    }\r\n\r\n    toggle(): void {\r\n        if (this.opened) {\r\n            this.close();\r\n        }\r\n        else {\r\n            this.open();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Enable the animations\r\n     *\r\n     * @private\r\n     */\r\n    private _enableAnimations(): void {\r\n        // Return if the animations are already enabled\r\n        if (this._animationsEnabled) {\r\n            return;\r\n        }\r\n\r\n        // Enable the animations\r\n        this._animationsEnabled = true;\r\n    }\r\n\r\n    /**\r\n     * Disable the animations\r\n     *\r\n     * @private\r\n     */\r\n    private _disableAnimations(): void {\r\n        // Return if the animations are already disabled\r\n        if (!this._animationsEnabled) {\r\n            return;\r\n        }\r\n\r\n        // Disable the animations\r\n        this._animationsEnabled = false;\r\n    }\r\n\r\n    /**\r\n     * Show the backdrop\r\n     *\r\n     * @private\r\n     */\r\n    private _showOverlay(): void {\r\n        // Create the backdrop element\r\n        this._overlay = this._renderer2.createElement('div');\r\n\r\n        // Return if overlay couldn't be create for some reason\r\n        if (!this._overlay) {\r\n            return;\r\n        }\r\n\r\n        // Add a class to the backdrop element\r\n        this._overlay.classList.add('cmat-drawer-overlay');\r\n\r\n        // Add a class depending on the fixed option\r\n        if (this.fixed) {\r\n            this._overlay.classList.add('cmat-drawer-overlay-fixed');\r\n        }\r\n\r\n        // Add a class depending on the transparentOverlay option\r\n        if (this.transparentOverlay) {\r\n            this._overlay.classList.add('cmat-drawer-overlay-transparent');\r\n        }\r\n\r\n        // Append the backdrop to the parent of the drawer\r\n        this._renderer2.appendChild(this._elementRef.nativeElement.parentElement, this._overlay);\r\n\r\n        // Create the enter animation and attach it to the player\r\n        this._player = this._animationBuilder.build([\r\n            animate('300ms cubic-bezier(0.25, 0.8, 0.25, 1)', style({ opacity: 1 }))\r\n        ]).create(this._overlay);\r\n\r\n        // Once the animation is done...\r\n        this._player.onDone(() => {\r\n\r\n            // Destroy the player\r\n            this._player.destroy();\r\n        });\r\n\r\n        // Play the animation\r\n        this._player.play();\r\n\r\n        // Add an event listener to the overlay\r\n        this._overlay.addEventListener('click', () => {\r\n            this.close();\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Hide the backdrop\r\n     *\r\n     * @private\r\n     */\r\n    private _hideOverlay(): void {\r\n        if (!this._overlay) {\r\n            return;\r\n        }\r\n\r\n        // Create the leave animation and attach it to the player\r\n        this._player = this._animationBuilder.build([\r\n            animate('300ms cubic-bezier(0.25, 0.8, 0.25, 1)', style({ opacity: 0 }))\r\n        ]).create(this._overlay);\r\n\r\n        // Play the animation\r\n        this._player.play();\r\n\r\n        // Once the animation is done...\r\n        this._player.onDone(() => {\r\n\r\n            // Destroy the player\r\n            this._player.destroy();\r\n\r\n            // If the backdrop still exists...\r\n            if (this._overlay) {\r\n                // Remove the backdrop\r\n                this._overlay.parentNode?.removeChild(this._overlay);\r\n                this._overlay = null;\r\n            }\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Open/close the drawer\r\n     *\r\n     * @param open\r\n     * @private\r\n     */\r\n    private _toggleOpened(open: boolean): void {\r\n        // Set the opened\r\n        this.opened = open;\r\n\r\n        // Enable the animations\r\n        this._enableAnimations();\r\n\r\n        // If the mode is 'over'\r\n        if (this.mode === 'over') {\r\n            // If the drawer opens, show the overlay\r\n            if (open) {\r\n                this._showOverlay();\r\n            }\r\n            // Otherwise, close the overlay\r\n            else {\r\n                this._hideOverlay();\r\n            }\r\n        }\r\n\r\n        // Execute the observable\r\n        this.openedChanged.next(open);\r\n    }\r\n}\r\n","<div class=\"cmat-drawer-content\">\r\n    <ng-content></ng-content>\r\n</div>"]}

package/esm2022/components/drawer/drawer.service.mjs

@@ -0,0 +1,41 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CmatDrawerService {
+    constructor() {
+        this._componentRegistry = new Map();
+    }
+    /**
+     * Register drawer component
+     *
+     * @param name
+     * @param component
+     */
+    registerComponent(name, component) {
+        this._componentRegistry.set(name, component);
+    }
+    /**
+     * Deregister drawer component
+     *
+     * @param name
+     */
+    deregisterComponent(name) {
+        this._componentRegistry.delete(name);
+    }
+    /**
+     * Get drawer component from the registry
+     *
+     * @param name
+     */
+    getComponent(name) {
+        return this._componentRegistry.get(name);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDrawerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDrawerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatDrawerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/drawer/drawer.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhd2VyLnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY21hdC9jb21wb25lbnRzL2RyYXdlci9kcmF3ZXIudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIENtYXREcmF3ZXJNb2RlID1cclxuICAgIHwgJ292ZXInXHJcbiAgICB8ICdzaWRlJztcclxuXHJcbmV4cG9ydCB0eXBlIENtYXREcmF3ZXJQb3NpdGlvbiA9XHJcbiAgICB8ICdsZWZ0J1xyXG4gICAgfCAncmlnaHQnO1xyXG4iXX0=

package/esm2022/components/drawer/public-api.mjs

@@ -0,0 +1,4 @@
+export * from './drawer.component';
+export * from './drawer.service';
+export * from './drawer.types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvY29tcG9uZW50cy9kcmF3ZXIvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZHJhd2VyLmNvbXBvbmVudCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZHJhd2VyLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2RyYXdlci50eXBlcyc7XHJcbiJdfQ==

package/esm2022/components/fullscreen/cmat-components-fullscreen.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1jb21wb25lbnRzLWZ1bGxzY3JlZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jbWF0L2NvbXBvbmVudHMvZnVsbHNjcmVlbi9jbWF0LWNvbXBvbmVudHMtZnVsbHNjcmVlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/components/fullscreen/fullscreen.component.mjs

@@ -0,0 +1,101 @@
+import { ChangeDetectionStrategy, Component, Inject, Input, ViewEncapsulation } from '@angular/core';
+import { DOCUMENT, NgTemplateOutlet } from '@angular/common';
+import { MatIconModule } from '@angular/material/icon';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { MatButtonModule } from '@angular/material/button';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/button";
+import * as i2 from "@angular/material/tooltip";
+import * as i3 from "@angular/material/icon";
+export class CmatFullscreenComponent {
+    constructor(_document) {
+        this._document = _document;
+        this._isFullscreen = false;
+        this._fsDoc = _document;
+    }
+    ngOnInit() {
+        this._fsDocEl = document.documentElement;
+    }
+    toggleFullscreen() {
+        // Check if the fullscreen is open
+        this._isFullscreen = this._getBrowserFullscreenElement() !== null;
+        // Toggle the fullscreen
+        if (this._isFullscreen) {
+            this._closeFullscreen();
+        }
+        else {
+            this._openFullscreen();
+        }
+    }
+    _getBrowserFullscreenElement() {
+        if (typeof this._fsDoc.fullscreenElement !== 'undefined') {
+            return this._fsDoc.fullscreenElement;
+        }
+        if (typeof this._fsDoc.mozFullScreenElement !== 'undefined') {
+            return this._fsDoc.mozFullScreenElement;
+        }
+        if (typeof this._fsDoc.msFullscreenElement !== 'undefined') {
+            return this._fsDoc.msFullscreenElement;
+        }
+        if (typeof this._fsDoc.webkitFullscreenElement !== 'undefined') {
+            return this._fsDoc.webkitFullscreenElement;
+        }
+        throw new Error('Fullscreen mode is not supported by this browser');
+    }
+    _openFullscreen() {
+        if (this._fsDocEl.requestFullscreen) {
+            this._fsDocEl.requestFullscreen().then();
+            return;
+        }
+        // Firefox
+        if (this._fsDocEl.mozRequestFullScreen) {
+            this._fsDocEl.mozRequestFullScreen();
+            return;
+        }
+        // Chrome, Safari and Opera
+        if (this._fsDocEl.webkitRequestFullscreen) {
+            this._fsDocEl.webkitRequestFullscreen();
+            return;
+        }
+        // IE/Edge
+        if (this._fsDocEl.msRequestFullscreen) {
+            this._fsDocEl.msRequestFullscreen();
+            return;
+        }
+    }
+    _closeFullscreen() {
+        if (this._fsDoc.exitFullscreen) {
+            this._fsDoc.exitFullscreen().then();
+            return;
+        }
+        // Firefox
+        if (this._fsDoc.mozCancelFullScreen) {
+            this._fsDoc.mozCancelFullScreen();
+            return;
+        }
+        // Chrome, Safari and Opera
+        if (this._fsDoc.webkitExitFullscreen) {
+            this._fsDoc.webkitExitFullscreen();
+            return;
+        }
+        // IE/Edge
+        else if (this._fsDoc.msExitFullscreen) {
+            this._fsDoc.msExitFullscreen();
+            return;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatFullscreenComponent, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.0", type: CmatFullscreenComponent, isStandalone: true, selector: "cmat-fullscreen", inputs: { iconTpl: "iconTpl", tooltip: "tooltip" }, exportAs: ["cmatFullscreen"], ngImport: i0, template: "<!-- Button -->\r\n<button type=\"button\" mat-icon-button [matTooltip]=\"tooltip || '\u5207\u6362\u5168\u5C4F'\" (click)=\"toggleFullscreen()\">\r\n    <ng-container [ngTemplateOutlet]=\"iconTpl || defaultIconTpl\"></ng-container>\r\n</button>\r\n\r\n<!-- Default icon -->\r\n<ng-template #defaultIconTpl>\r\n    <mat-icon [svgIcon]=\"'heroicons_outline:arrows-pointing-out'\"></mat-icon>\r\n</ng-template>", dependencies: [{ kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i1.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i2.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.0", ngImport: i0, type: CmatFullscreenComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cmat-fullscreen', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, exportAs: 'cmatFullscreen', standalone: true, imports: [MatButtonModule, MatTooltipModule, NgTemplateOutlet, MatIconModule], template: "<!-- Button -->\r\n<button type=\"button\" mat-icon-button [matTooltip]=\"tooltip || '\u5207\u6362\u5168\u5C4F'\" (click)=\"toggleFullscreen()\">\r\n    <ng-container [ngTemplateOutlet]=\"iconTpl || defaultIconTpl\"></ng-container>\r\n</button>\r\n\r\n<!-- Default icon -->\r\n<ng-template #defaultIconTpl>\r\n    <mat-icon [svgIcon]=\"'heroicons_outline:arrows-pointing-out'\"></mat-icon>\r\n</ng-template>" }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }], propDecorators: { iconTpl: [{
+                type: Input
+            }], tooltip: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fullscreen.component.js","sourceRoot":"","sources":["../../../../../projects/cmat/components/fullscreen/fullscreen.component.ts","../../../../../projects/cmat/components/fullscreen/fullscreen.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, Inject, Input, OnInit, TemplateRef, ViewEncapsulation } from '@angular/core';\r\nimport { DOCUMENT, NgTemplateOutlet } from '@angular/common';\r\nimport { FSDocument, FSDocumentElement } from './fullscreen.types';\r\nimport { MatIconModule } from '@angular/material/icon';\r\nimport { MatTooltipModule } from '@angular/material/tooltip';\r\nimport { MatButtonModule } from '@angular/material/button';\r\n\r\n@Component({\r\n    selector: 'cmat-fullscreen',\r\n    templateUrl: './fullscreen.component.html',\r\n    encapsulation: ViewEncapsulation.None,\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n    exportAs: 'cmatFullscreen',\r\n    standalone: true,\r\n    imports: [MatButtonModule, MatTooltipModule, NgTemplateOutlet, MatIconModule]\r\n})\r\nexport class CmatFullscreenComponent implements OnInit {\r\n    @Input() iconTpl: TemplateRef<any>;\r\n    @Input() tooltip: string;\r\n    private _fsDoc: FSDocument;\r\n    private _fsDocEl: FSDocumentElement;\r\n    private _isFullscreen: boolean = false;\r\n\r\n    constructor(@Inject(DOCUMENT) private _document: Document) {\r\n        this._fsDoc = _document as FSDocument;\r\n    }\r\n\r\n    ngOnInit(): void {\r\n        this._fsDocEl = document.documentElement as FSDocumentElement;\r\n    }\r\n\r\n    toggleFullscreen(): void {\r\n        // Check if the fullscreen is open\r\n        this._isFullscreen = this._getBrowserFullscreenElement() !== null;\r\n\r\n        // Toggle the fullscreen\r\n        if (this._isFullscreen) {\r\n            this._closeFullscreen();\r\n        } else {\r\n            this._openFullscreen();\r\n        }\r\n    }\r\n\r\n    private _getBrowserFullscreenElement(): Element | null {\r\n        if (typeof this._fsDoc.fullscreenElement !== 'undefined') {\r\n            return this._fsDoc.fullscreenElement;\r\n        }\r\n\r\n        if (typeof this._fsDoc.mozFullScreenElement !== 'undefined') {\r\n            return this._fsDoc.mozFullScreenElement;\r\n        }\r\n\r\n        if (typeof this._fsDoc.msFullscreenElement !== 'undefined') {\r\n            return this._fsDoc.msFullscreenElement;\r\n        }\r\n\r\n        if (typeof this._fsDoc.webkitFullscreenElement !== 'undefined') {\r\n            return this._fsDoc.webkitFullscreenElement;\r\n        }\r\n\r\n        throw new Error('Fullscreen mode is not supported by this browser');\r\n    }\r\n\r\n    private _openFullscreen(): void {\r\n        if (this._fsDocEl.requestFullscreen) {\r\n            this._fsDocEl.requestFullscreen().then();\r\n            return;\r\n        }\r\n\r\n        // Firefox\r\n        if (this._fsDocEl.mozRequestFullScreen) {\r\n            this._fsDocEl.mozRequestFullScreen();\r\n            return;\r\n        }\r\n\r\n        // Chrome, Safari and Opera\r\n        if (this._fsDocEl.webkitRequestFullscreen) {\r\n            this._fsDocEl.webkitRequestFullscreen();\r\n            return;\r\n        }\r\n\r\n        // IE/Edge\r\n        if (this._fsDocEl.msRequestFullscreen) {\r\n            this._fsDocEl.msRequestFullscreen();\r\n            return;\r\n        }\r\n    }\r\n\r\n    private _closeFullscreen(): void {\r\n        if (this._fsDoc.exitFullscreen) {\r\n            this._fsDoc.exitFullscreen().then();\r\n            return;\r\n        }\r\n\r\n        // Firefox\r\n        if (this._fsDoc.mozCancelFullScreen) {\r\n            this._fsDoc.mozCancelFullScreen();\r\n            return;\r\n        }\r\n\r\n        // Chrome, Safari and Opera\r\n        if (this._fsDoc.webkitExitFullscreen) {\r\n            this._fsDoc.webkitExitFullscreen();\r\n            return;\r\n        }\r\n\r\n        // IE/Edge\r\n        else if (this._fsDoc.msExitFullscreen) {\r\n            this._fsDoc.msExitFullscreen();\r\n            return;\r\n        }\r\n    }\r\n}\r\n","<!-- Button -->\r\n<button type=\"button\" mat-icon-button [matTooltip]=\"tooltip || '切换全屏'\" (click)=\"toggleFullscreen()\">\r\n    <ng-container [ngTemplateOutlet]=\"iconTpl || defaultIconTpl\"></ng-container>\r\n</button>\r\n\r\n<!-- Default icon -->\r\n<ng-template #defaultIconTpl>\r\n    <mat-icon [svgIcon]=\"'heroicons_outline:arrows-pointing-out'\"></mat-icon>\r\n</ng-template>"]}

package/esm2022/components/fullscreen/fullscreen.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVsbHNjcmVlbi50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvY29tcG9uZW50cy9mdWxsc2NyZWVuL2Z1bGxzY3JlZW4udHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgRlNEb2N1bWVudCBleHRlbmRzIERvY3VtZW50IHtcclxuICAgIG1vekZ1bGxTY3JlZW5FbGVtZW50PzogRWxlbWVudDtcclxuICAgIG1vekNhbmNlbEZ1bGxTY3JlZW4/OiAoKSA9PiB2b2lkO1xyXG4gICAgbXNGdWxsc2NyZWVuRWxlbWVudD86IEVsZW1lbnQ7XHJcbiAgICBtc0V4aXRGdWxsc2NyZWVuPzogKCkgPT4gdm9pZDtcclxuICAgIHdlYmtpdEZ1bGxzY3JlZW5FbGVtZW50PzogRWxlbWVudDtcclxuICAgIHdlYmtpdEV4aXRGdWxsc2NyZWVuPzogKCkgPT4gdm9pZDtcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBGU0RvY3VtZW50RWxlbWVudCBleHRlbmRzIEhUTUxFbGVtZW50IHtcclxuICAgIG1velJlcXVlc3RGdWxsU2NyZWVuPzogKCkgPT4gdm9pZDtcclxuICAgIG1zUmVxdWVzdEZ1bGxzY3JlZW4/OiAoKSA9PiB2b2lkO1xyXG4gICAgd2Via2l0UmVxdWVzdEZ1bGxzY3JlZW4/OiAoKSA9PiB2b2lkO1xyXG59XHJcbiJdfQ==

package/esm2022/components/fullscreen/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './fullscreen.component';
+export * from './fullscreen.types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvY29tcG9uZW50cy9mdWxsc2NyZWVuL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mdWxsc2NyZWVuLmNvbXBvbmVudCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZnVsbHNjcmVlbi50eXBlcyc7XHJcbiJdfQ==

package/esm2022/components/highlight/cmat-components-highlight.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY21hdC1jb21wb25lbnRzLWhpZ2hsaWdodC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NtYXQvY29tcG9uZW50cy9oaWdobGlnaHQvY21hdC1jb21wb25lbnRzLWhpZ2hsaWdodC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19