flowbite-angular 1.0.0-alpha.2 → 1.0.0-alpha.3

package/esm2022/modal/modal-footer.component.mjs

@@ -0,0 +1,36 @@
+import { ModalFooterThemeService } from './modal-footer.theme.service';
+import { ModalComponent } from './modal.component';
+import { BaseComponent } from 'flowbite-angular';
+import { NgClass } from '@angular/common';
+import { ChangeDetectionStrategy, Component, inject, model, ViewEncapsulation, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ModalFooterComponent extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        this.themeService = inject(ModalFooterThemeService);
+        this.modalComponent = inject(ModalComponent);
+        //#region properties
+        this.customStyle = model({});
+    }
+    //#endregion
+    //#region BaseComponent implementation
+    fetchClass() {
+        return this.themeService.getClasses({
+            customStyle: this.customStyle(),
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: ModalFooterComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.0.0", type: ModalFooterComponent, isStandalone: true, selector: "flowbite-modal-footer", inputs: { customStyle: { classPropertyName: "customStyle", publicName: "customStyle", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { customStyle: "customStyleChange" }, usesInheritance: true, ngImport: i0, template: `<ng-content />`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: ModalFooterComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    imports: [NgClass],
+                    selector: 'flowbite-modal-footer',
+                    template: `<ng-content />`,
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/modal/modal-footer.theme.mjs

@@ -0,0 +1,7 @@
+import { createTheme } from 'flowbite-angular/utils';
+export const modalFooterTheme = createTheme({
+    root: {
+        base: 'flex items-center p-6 space-x-2 border-t border-gray-200 rounded-b dark:border-gray-600',
+    },
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwtZm9vdGVyLnRoZW1lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9mbG93Yml0ZS1hbmd1bGFyL21vZGFsL21vZGFsLWZvb3Rlci50aGVtZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFZckQsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQXFCLFdBQVcsQ0FBQztJQUM1RCxJQUFJLEVBQUU7UUFDSixJQUFJLEVBQUUseUZBQXlGO0tBQ2hHO0NBQ0YsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBEZWVwUGFydGlhbCwgRmxvd2JpdGVDbGFzcyB9IGZyb20gJ2Zsb3diaXRlLWFuZ3VsYXInO1xuaW1wb3J0IHsgY3JlYXRlVGhlbWUgfSBmcm9tICdmbG93Yml0ZS1hbmd1bGFyL3V0aWxzJztcblxuZXhwb3J0IGludGVyZmFjZSBNb2RhbEZvb3RlclByb3BlcnRpZXMge1xuICBjdXN0b21TdHlsZTogRGVlcFBhcnRpYWw8TW9kYWxGb290ZXJUaGVtZT47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgTW9kYWxGb290ZXJUaGVtZSB7XG4gIHJvb3Q6IHtcbiAgICBiYXNlOiBzdHJpbmc7XG4gIH07XG59XG5cbmV4cG9ydCBjb25zdCBtb2RhbEZvb3RlclRoZW1lOiBNb2RhbEZvb3RlclRoZW1lID0gY3JlYXRlVGhlbWUoe1xuICByb290OiB7XG4gICAgYmFzZTogJ2ZsZXggaXRlbXMtY2VudGVyIHAtNiBzcGFjZS14LTIgYm9yZGVyLXQgYm9yZGVyLWdyYXktMjAwIHJvdW5kZWQtYiBkYXJrOmJvcmRlci1ncmF5LTYwMCcsXG4gIH0sXG59KTtcblxuZXhwb3J0IHR5cGUgTW9kYWxGb290ZXJDbGFzcyA9IEZsb3diaXRlQ2xhc3M7XG4iXX0=

package/esm2022/modal/modal-footer.theme.service.mjs

@@ -0,0 +1,17 @@
+import { mergeTheme } from 'flowbite-angular/utils';
+import { inject, InjectionToken } from '@angular/core';
+import { twMerge } from 'tailwind-merge';
+export const FLOWBITE_MODAL_FOOTER_THEME_TOKEN = new InjectionToken('FLOWBITE_MODAL_FOOTER_THEME_TOKEN');
+export class ModalFooterThemeService {
+    constructor() {
+        this.baseTheme = inject(FLOWBITE_MODAL_FOOTER_THEME_TOKEN);
+    }
+    getClasses(properties) {
+        const theme = mergeTheme(this.baseTheme, properties.customStyle);
+        const output = {
+            rootClass: twMerge(theme.root.base),
+        };
+        return output;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/modal/modal-header.component.mjs

@@ -0,0 +1,68 @@
+import { ModalHeaderThemeService } from './modal-header.theme.service';
+import { ModalComponent } from './modal.component';
+import { BaseComponent } from 'flowbite-angular';
+import { IconComponent, IconRegistry } from 'flowbite-angular/icon';
+import { CLOSE_SVG_ICON } from 'flowbite-angular/utils';
+import { NgClass } from '@angular/common';
+import { ChangeDetectionStrategy, Component, inject, model, ViewEncapsulation, } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export class ModalHeaderComponent extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        this.stateService = inject(ModalHeaderThemeService);
+        this.modalComponent = inject(ModalComponent);
+        this.iconRegistry = inject(IconRegistry);
+        this.domSanitizer = inject(DomSanitizer);
+        //#region properties
+        this.customStyle = model({});
+    }
+    //#endregion
+    //#region BaseComponent implementation
+    fetchClass() {
+        return this.stateService.getClasses({
+            customStyle: this.customStyle(),
+        });
+    }
+    init() {
+        this.iconRegistry.addRawSvgIconInNamepsace('flowbite-angular', 'close', this.domSanitizer.bypassSecurityTrustHtml(CLOSE_SVG_ICON));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: ModalHeaderComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.0.0", type: ModalHeaderComponent, isStandalone: true, selector: "flowbite-modal-header", inputs: { customStyle: { classPropertyName: "customStyle", publicName: "customStyle", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { customStyle: "customStyleChange" }, usesInheritance: true, ngImport: i0, template: `
+    <h3 [ngClass]="contentClasses().modalHeaderTitleClass">
+      <ng-content />
+    </h3>
+    <button
+      type="button"
+      [ngClass]="contentClasses().modalHeaderButtonClass"
+      data-modal-hide="medium-modal"
+      (click)="modalComponent.close()">
+      <flowbite-icon svgIcon="flowbite-angular:close" class="w-5 h-5" />
+      <span class="sr-only">Close modal</span>
+    </button>
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "component", type: IconComponent, selector: "flowbite-icon", inputs: ["svgIcon"], outputs: ["svgIconChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: ModalHeaderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    imports: [NgClass, IconComponent],
+                    selector: 'flowbite-modal-header',
+                    template: `
+    <h3 [ngClass]="contentClasses().modalHeaderTitleClass">
+      <ng-content />
+    </h3>
+    <button
+      type="button"
+      [ngClass]="contentClasses().modalHeaderButtonClass"
+      data-modal-hide="medium-modal"
+      (click)="modalComponent.close()">
+      <flowbite-icon svgIcon="flowbite-angular:close" class="w-5 h-5" />
+      <span class="sr-only">Close modal</span>
+    </button>
+  `,
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/modal/modal-header.theme.mjs

@@ -0,0 +1,13 @@
+import { createTheme } from 'flowbite-angular/utils';
+export const modalHeaderTheme = createTheme({
+    root: {
+        base: 'flex items-center justify-between p-5 border-b rounded-t dark:border-gray-600',
+    },
+    title: {
+        base: 'text-xl font-medium text-gray-900 dark:text-white',
+    },
+    button: {
+        base: 'text-gray-400 bg-transparent hover:bg-gray-200 hover:text-gray-900 rounded-lg text-sm p-1.5 ml-auto inline-flex items-center dark:hover:bg-gray-600 dark:hover:text-white',
+    },
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwtaGVhZGVyLnRoZW1lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9mbG93Yml0ZS1hbmd1bGFyL21vZGFsL21vZGFsLWhlYWRlci50aGVtZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFrQnJELE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFxQixXQUFXLENBQUM7SUFDNUQsSUFBSSxFQUFFO1FBQ0osSUFBSSxFQUFFLCtFQUErRTtLQUN0RjtJQUNELEtBQUssRUFBRTtRQUNMLElBQUksRUFBRSxtREFBbUQ7S0FDMUQ7SUFDRCxNQUFNLEVBQUU7UUFDTixJQUFJLEVBQUUsMktBQTJLO0tBQ2xMO0NBQ0YsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBEZWVwUGFydGlhbCwgRmxvd2JpdGVDbGFzcyB9IGZyb20gJ2Zsb3diaXRlLWFuZ3VsYXInO1xuaW1wb3J0IHsgY3JlYXRlVGhlbWUgfSBmcm9tICdmbG93Yml0ZS1hbmd1bGFyL3V0aWxzJztcblxuZXhwb3J0IGludGVyZmFjZSBNb2RhbEhlYWRlclByb3BlcnRpZXMge1xuICBjdXN0b21TdHlsZTogRGVlcFBhcnRpYWw8TW9kYWxIZWFkZXJUaGVtZT47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgTW9kYWxIZWFkZXJUaGVtZSB7XG4gIHJvb3Q6IHtcbiAgICBiYXNlOiBzdHJpbmc7XG4gIH07XG4gIHRpdGxlOiB7XG4gICAgYmFzZTogc3RyaW5nO1xuICB9O1xuICBidXR0b246IHtcbiAgICBiYXNlOiBzdHJpbmc7XG4gIH07XG59XG5cbmV4cG9ydCBjb25zdCBtb2RhbEhlYWRlclRoZW1lOiBNb2RhbEhlYWRlclRoZW1lID0gY3JlYXRlVGhlbWUoe1xuICByb290OiB7XG4gICAgYmFzZTogJ2ZsZXggaXRlbXMtY2VudGVyIGp1c3RpZnktYmV0d2VlbiBwLTUgYm9yZGVyLWIgcm91bmRlZC10IGRhcms6Ym9yZGVyLWdyYXktNjAwJyxcbiAgfSxcbiAgdGl0bGU6IHtcbiAgICBiYXNlOiAndGV4dC14bCBmb250LW1lZGl1bSB0ZXh0LWdyYXktOTAwIGRhcms6dGV4dC13aGl0ZScsXG4gIH0sXG4gIGJ1dHRvbjoge1xuICAgIGJhc2U6ICd0ZXh0LWdyYXktNDAwIGJnLXRyYW5zcGFyZW50IGhvdmVyOmJnLWdyYXktMjAwIGhvdmVyOnRleHQtZ3JheS05MDAgcm91bmRlZC1sZyB0ZXh0LXNtIHAtMS41IG1sLWF1dG8gaW5saW5lLWZsZXggaXRlbXMtY2VudGVyIGRhcms6aG92ZXI6YmctZ3JheS02MDAgZGFyazpob3Zlcjp0ZXh0LXdoaXRlJyxcbiAgfSxcbn0pO1xuXG5leHBvcnQgaW50ZXJmYWNlIE1vZGFsSGVhZGVyQ2xhc3MgZXh0ZW5kcyBGbG93Yml0ZUNsYXNzIHtcbiAgbW9kYWxIZWFkZXJUaXRsZUNsYXNzOiBzdHJpbmc7XG4gIG1vZGFsSGVhZGVyQnV0dG9uQ2xhc3M6IHN0cmluZztcbn1cbiJdfQ==

package/esm2022/modal/modal-header.theme.service.mjs

@@ -0,0 +1,19 @@
+import { mergeTheme } from 'flowbite-angular/utils';
+import { inject, InjectionToken } from '@angular/core';
+import { twMerge } from 'tailwind-merge';
+export const FLOWBITE_MODAL_HEADER_THEME_TOKEN = new InjectionToken('FLOWBITE_MODAL_HEADER_THEME_TOKEN');
+export class ModalHeaderThemeService {
+    constructor() {
+        this.baseTheme = inject(FLOWBITE_MODAL_HEADER_THEME_TOKEN);
+    }
+    getClasses(properties) {
+        const theme = mergeTheme(this.baseTheme, properties.customStyle);
+        const output = {
+            rootClass: twMerge(theme.root.base),
+            modalHeaderTitleClass: twMerge(theme.title.base),
+            modalHeaderButtonClass: twMerge(theme.button.base),
+        };
+        return output;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/modal/modal.component.mjs

@@ -0,0 +1,143 @@
+import { ModalBodyComponent } from './modal-body.component';
+import { ModalFooterComponent } from './modal-footer.component';
+import { ModalHeaderComponent } from './modal-header.component';
+import { ModalThemeService } from './modal.theme.service';
+import { BaseComponent, booleanToFlowbiteBoolean } from 'flowbite-angular';
+import { NgClass } from '@angular/common';
+import { ChangeDetectionStrategy, Component, contentChild, inject, model, TemplateRef, viewChild, ViewContainerRef, ViewEncapsulation, } from '@angular/core';
+import { NavigationStart, Router } from '@angular/router';
+import { filter, Subject, takeUntil } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * @see https://flowbite.com/docs/components/modal/
+ */
+export class ModalComponent extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        this.destroyed = new Subject();
+        this.themeService = inject(ModalThemeService);
+        this.modalHeaderChild = contentChild(ModalHeaderComponent);
+        this.modalBodyChild = contentChild(ModalBodyComponent);
+        this.modalFooterChild = contentChild(ModalFooterComponent);
+        //#region template properties
+        this.template = viewChild.required('modal', { read: TemplateRef });
+        this.viewContainer = inject(ViewContainerRef);
+        this.router = inject(Router);
+        //#endregion
+        //#region properties
+        this.size = model('md');
+        this.position = model('center');
+        this.isDismissable = model(false);
+        this.isOpen = model(false);
+        this.customStyle = model({});
+    }
+    //#endregion
+    //#region BaseComponent implementation
+    fetchClass() {
+        return this.themeService.getClasses({
+            isOpen: booleanToFlowbiteBoolean(this.isOpen()),
+            size: this.size(),
+            position: this.position(),
+            customStyle: this.customStyle(),
+        });
+    }
+    init() {
+        // close modal if it's not destroyed on route change
+        this.router.events
+            .pipe(takeUntil(this.destroyed), filter(() => this.isOpen()), filter((event) => event instanceof NavigationStart))
+            .subscribe(() => this.close());
+    }
+    verify() {
+        if (this.modalBodyChild() === undefined) {
+            throw new Error('No ModalBodyComponent available');
+        }
+    }
+    //#endregion
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.complete();
+    }
+    open() {
+        this.isOpen.set(true);
+        this.changeBackdrop();
+    }
+    close() {
+        this.isOpen.set(false);
+        this.changeBackdrop();
+    }
+    toggle() {
+        this.isOpen.set(!this.isOpen());
+        this.changeBackdrop();
+    }
+    // If isOpen changes, add or remove template
+    changeBackdrop() {
+        if (this.isOpen()) {
+            this.createTemplate();
+        }
+        else {
+            this.destroyTemplate();
+        }
+    }
+    createTemplate() {
+        if (this.embeddedView) {
+            this.destroyTemplate();
+        }
+        this.embeddedView = this.viewContainer.createEmbeddedView(this.template());
+    }
+    destroyTemplate() {
+        this.embeddedView?.destroy();
+    }
+    onKeydownHandler(event) {
+        console.log('hello');
+        if (event.key === 'Escape') {
+            this.close();
+        }
+    }
+    onBackdropClick(event) {
+        if (event.target == event.currentTarget && this.isDismissable()) {
+            this.close();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: ModalComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.0.0", type: ModalComponent, isStandalone: true, selector: "flowbite-modal", inputs: { size: { classPropertyName: "size", publicName: "size", isSignal: true, isRequired: false, transformFunction: null }, position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: false, transformFunction: null }, isDismissable: { classPropertyName: "isDismissable", publicName: "isDismissable", isSignal: true, isRequired: false, transformFunction: null }, isOpen: { classPropertyName: "isOpen", publicName: "isOpen", isSignal: true, isRequired: false, transformFunction: null }, customStyle: { classPropertyName: "customStyle", publicName: "customStyle", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { size: "sizeChange", position: "positionChange", isDismissable: "isDismissableChange", isOpen: "isOpenChange", customStyle: "customStyleChange" }, host: { attributes: { "tabindex": "-1" }, listeners: { "document:keydown": "onKeydownHandler($event)" } }, queries: [{ propertyName: "modalHeaderChild", first: true, predicate: ModalHeaderComponent, descendants: true, isSignal: true }, { propertyName: "modalBodyChild", first: true, predicate: ModalBodyComponent, descendants: true, isSignal: true }, { propertyName: "modalFooterChild", first: true, predicate: ModalFooterComponent, descendants: true, isSignal: true }], viewQueries: [{ propertyName: "template", first: true, predicate: ["modal"], descendants: true, read: TemplateRef, isSignal: true }], usesInheritance: true, ngImport: i0, template: `
+    <ng-template #modal>
+      <div class="bg-gray-900 bg-opacity-50 dark:bg-opacity-80 fixed inset-0 z-[99]"></div>
+
+      <div [ngClass]="contentClasses().modalWrapperClass" (click)="onBackdropClick($event)">
+        <div [ngClass]="contentClasses().modalContainerClass">
+          <div [ngClass]="contentClasses().modalContentClass">
+            <ng-content />
+          </div>
+        </div>
+      </div>
+    </ng-template>
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: ModalComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    imports: [NgClass],
+                    selector: 'flowbite-modal',
+                    template: `
+    <ng-template #modal>
+      <div class="bg-gray-900 bg-opacity-50 dark:bg-opacity-80 fixed inset-0 z-[99]"></div>
+
+      <div [ngClass]="contentClasses().modalWrapperClass" (click)="onBackdropClick($event)">
+        <div [ngClass]="contentClasses().modalContainerClass">
+          <div [ngClass]="contentClasses().modalContentClass">
+            <ng-content />
+          </div>
+        </div>
+      </div>
+    </ng-template>
+  `,
+                    host: {
+                        tabindex: '-1',
+                        '(document:keydown)': 'onKeydownHandler($event)',
+                    },
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal.component.js","sourceRoot":"","sources":["../../../../../libs/flowbite-angular/modal/modal.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { ModalBodyComponent } from './modal-body.component';\nimport { ModalFooterComponent } from './modal-footer.component';\nimport { ModalHeaderComponent } from './modal-header.component';\nimport type { ModalClass, ModalPositions, ModalSizes, ModalTheme } from './modal.theme';\nimport { ModalThemeService } from './modal.theme.service';\n\nimport type { DeepPartial } from 'flowbite-angular';\nimport { BaseComponent, booleanToFlowbiteBoolean } from 'flowbite-angular';\n\nimport { NgClass } from '@angular/common';\nimport type { EmbeddedViewRef, OnDestroy } from '@angular/core';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  contentChild,\n  inject,\n  model,\n  TemplateRef,\n  viewChild,\n  ViewContainerRef,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { NavigationStart, Router } from '@angular/router';\nimport { filter, Subject, takeUntil } from 'rxjs';\n\n/**\n * @see https://flowbite.com/docs/components/modal/\n */\n@Component({\n  standalone: true,\n  imports: [NgClass],\n  selector: 'flowbite-modal',\n  template: `\n    <ng-template #modal>\n      <div class=\"bg-gray-900 bg-opacity-50 dark:bg-opacity-80 fixed inset-0 z-[99]\"></div>\n\n      <div [ngClass]=\"contentClasses().modalWrapperClass\" (click)=\"onBackdropClick($event)\">\n        <div [ngClass]=\"contentClasses().modalContainerClass\">\n          <div [ngClass]=\"contentClasses().modalContentClass\">\n            <ng-content />\n          </div>\n        </div>\n      </div>\n    </ng-template>\n  `,\n  host: {\n    tabindex: '-1',\n    '(document:keydown)': 'onKeydownHandler($event)',\n  },\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ModalComponent extends BaseComponent<ModalClass> implements OnDestroy {\n  private readonly destroyed = new Subject<void>();\n\n  public readonly themeService = inject(ModalThemeService);\n  public readonly modalHeaderChild = contentChild(ModalHeaderComponent);\n  public readonly modalBodyChild = contentChild(ModalBodyComponent);\n  public readonly modalFooterChild = contentChild(ModalFooterComponent);\n\n  //#region template properties\n  private readonly template = viewChild.required('modal', { read: TemplateRef });\n\n  private readonly viewContainer = inject(ViewContainerRef);\n  private readonly router = inject(Router);\n\n  private embeddedView?: EmbeddedViewRef<unknown>;\n  //#endregion\n\n  //#region properties\n  public size = model<keyof ModalSizes>('md');\n  public position = model<keyof ModalPositions>('center');\n  public isDismissable = model<boolean>(false);\n  public isOpen = model<boolean>(false);\n  public customStyle = model<DeepPartial<ModalTheme>>({});\n  //#endregion\n\n  //#region BaseComponent implementation\n  public override fetchClass(): ModalClass {\n    return this.themeService.getClasses({\n      isOpen: booleanToFlowbiteBoolean(this.isOpen()),\n      size: this.size(),\n      position: this.position(),\n      customStyle: this.customStyle(),\n    });\n  }\n\n  public override init(): void {\n    // close modal if it's not destroyed on route change\n    this.router.events\n      .pipe(\n        takeUntil(this.destroyed),\n        filter(() => this.isOpen()),\n        filter((event) => event instanceof NavigationStart)\n      )\n      .subscribe(() => this.close());\n  }\n\n  public override verify(): void {\n    if (this.modalBodyChild() === undefined) {\n      throw new Error('No ModalBodyComponent available');\n    }\n  }\n  //#endregion\n\n  ngOnDestroy(): void {\n    this.destroyed.next();\n    this.destroyed.complete();\n  }\n\n  open() {\n    this.isOpen.set(true);\n    this.changeBackdrop();\n  }\n\n  close() {\n    this.isOpen.set(false);\n    this.changeBackdrop();\n  }\n\n  toggle() {\n    this.isOpen.set(!this.isOpen());\n    this.changeBackdrop();\n  }\n\n  // If isOpen changes, add or remove template\n  changeBackdrop() {\n    if (this.isOpen()) {\n      this.createTemplate();\n    } else {\n      this.destroyTemplate();\n    }\n  }\n\n  private createTemplate() {\n    if (this.embeddedView) {\n      this.destroyTemplate();\n    }\n\n    this.embeddedView = this.viewContainer.createEmbeddedView(this.template());\n  }\n\n  private destroyTemplate() {\n    this.embeddedView?.destroy();\n  }\n\n  onKeydownHandler(event: KeyboardEvent) {\n    console.log('hello');\n    if (event.key === 'Escape') {\n      this.close();\n    }\n  }\n\n  onBackdropClick(event: MouseEvent) {\n    if (event.target == event.currentTarget && this.isDismissable()) {\n      this.close();\n    }\n  }\n}\n"]}

package/esm2022/modal/modal.theme.mjs

@@ -0,0 +1,33 @@
+import { createTheme } from 'flowbite-angular/utils';
+export const modalTheme = createTheme({
+    root: {
+        base: '',
+    },
+    wrapper: {
+        base: 'fixed top-0 left-0 right-0 z-[100] w-full p-4 overflow-x-hidden overflow-y-auto md:inset-0 h-[calc(100%-1rem)] md:h-full flex',
+        position: {
+            'top-left': 'items-start justify-start',
+            'top-center': 'items-start justify-center',
+            'top-right': 'items-start justify-end',
+            'center-left': 'items-center justify-start',
+            center: 'items-center justify-center',
+            'center-right': 'items-center justify-end',
+            'bottom-left': 'items-end justify-start',
+            'bottom-center': 'items-end justify-center',
+            'bottom-right': 'items-end justify-end',
+        },
+    },
+    container: {
+        base: 'relative w-full h-full md:h-auto',
+        size: {
+            sm: 'max-w-md',
+            md: 'max-w-lg',
+            lg: 'max-w-4xl',
+            xl: 'max-w-7xl',
+        },
+    },
+    content: {
+        base: 'relative bg-white rounded-lg shadow dark:bg-gray-700',
+    },
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/modal/modal.theme.service.mjs

@@ -0,0 +1,20 @@
+import { mergeTheme } from 'flowbite-angular/utils';
+import { inject, InjectionToken } from '@angular/core';
+import { twMerge } from 'tailwind-merge';
+export const FLOWBITE_MODAL_THEME_TOKEN = new InjectionToken('FLOWBITE_MODAL_THEME_TOKEN');
+export class ModalThemeService {
+    constructor() {
+        this.baseTheme = inject(FLOWBITE_MODAL_THEME_TOKEN);
+    }
+    getClasses(properties) {
+        const theme = mergeTheme(this.baseTheme, properties.customStyle);
+        const output = {
+            rootClass: twMerge(theme.root.base),
+            modalWrapperClass: twMerge(theme.wrapper.base, theme.wrapper.position[properties.position]),
+            modalContainerClass: twMerge(theme.container.base, theme.container.size[properties.size]),
+            modalContentClass: twMerge(theme.content.base),
+        };
+        return output;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/navbar/flowbite-angular-navbar.mjs

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

package/esm2022/navbar/index.mjs

@@ -0,0 +1,19 @@
+export { NavbarComponent } from './navbar.component';
+export { navbarTheme } from './navbar.theme';
+export { FLOWBITE_NAVBAR_THEME_TOKEN, NavbarThemeService } from './navbar.theme.service';
+export { NavbarBrandComponent } from './navbar-brand.component';
+export { navbarBrandTheme } from './navbar-brand.theme';
+export { FLOWBITE_NAVBAR_BRAND_THEME_TOKEN, NavbarBrandThemeService, } from './navbar-brand.theme.service';
+export { NavbarContentComponent } from './navbar-content.component';
+export { navbarContentTheme } from './navbar-content.theme';
+export { FLOWBITE_NAVBAR_CONTENT_THEME_TOKEN, NavbarContentThemeService, } from './navbar-content.theme.service';
+export { NavbarItemComponent } from './navbar-item.component';
+export { navbarItemTheme } from './navbar-item.theme';
+export { FLOWBITE_NAVBAR_ITEM_THEME_TOKEN, NavbarItemThemeService, } from './navbar-item.theme.service';
+export { NavbarToggleComponent } from './navbar-toggle.component';
+export { navbarToogleTheme } from './navbar-toggle.theme';
+export { FLOWBITE_NAVBAR_TOGGLE_THEME_TOKEN, NavbarToggleThemeService, } from './navbar-toggle.theme.service';
+export { NavbarIconButtonComponent } from './navbar-icon-button.component';
+export { navbarIconButtonTheme } from './navbar-icon-button.theme';
+export { FLOWBITE_NAVBAR_ICON_BUTTON_THEME_TOKEN, NavbarIconButtonThemeService, } from './navbar-icon-button.theme.service';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/navbar/navbar-brand.component.mjs

@@ -0,0 +1,36 @@
+import { NavbarBrandThemeService } from './navbar-brand.theme.service';
+import { NavbarComponent } from './navbar.component';
+import { BaseComponent } from 'flowbite-angular';
+import { NgClass } from '@angular/common';
+import { ChangeDetectionStrategy, Component, inject, model, ViewEncapsulation, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NavbarBrandComponent extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        this.themeService = inject(NavbarBrandThemeService);
+        this.navbarComponent = inject(NavbarComponent);
+        //#region properties
+        this.customStyle = model({});
+    }
+    //#endregion
+    //#region BaseComponent implementation
+    fetchClass() {
+        return this.themeService.getClasses({
+            customStyle: this.customStyle(),
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: NavbarBrandComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.0.0", type: NavbarBrandComponent, isStandalone: true, selector: "flowbite-navbar-brand", inputs: { customStyle: { classPropertyName: "customStyle", publicName: "customStyle", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { customStyle: "customStyleChange" }, usesInheritance: true, ngImport: i0, template: `<ng-content />`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: NavbarBrandComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'flowbite-navbar-brand',
+                    standalone: true,
+                    imports: [NgClass],
+                    template: `<ng-content />`,
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/navbar/navbar-brand.theme.mjs

@@ -0,0 +1,7 @@
+import { createTheme } from 'flowbite-angular/utils';
+export const navbarBrandTheme = createTheme({
+    root: {
+        base: 'cursor-pointer flex items-center space-x-3 rtl:space-x-reverse',
+    },
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2YmFyLWJyYW5kLnRoZW1lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9mbG93Yml0ZS1hbmd1bGFyL25hdmJhci9uYXZiYXItYnJhbmQudGhlbWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBWXJELE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFxQixXQUFXLENBQUM7SUFDNUQsSUFBSSxFQUFFO1FBQ0osSUFBSSxFQUFFLGdFQUFnRTtLQUN2RTtDQUNGLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRGVlcFBhcnRpYWwsIEZsb3diaXRlQ2xhc3MgfSBmcm9tICdmbG93Yml0ZS1hbmd1bGFyJztcbmltcG9ydCB7IGNyZWF0ZVRoZW1lIH0gZnJvbSAnZmxvd2JpdGUtYW5ndWxhci91dGlscyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTmF2YmFyQnJhbmRQcm9wZXJ0aWVzIHtcbiAgY3VzdG9tU3R5bGU6IERlZXBQYXJ0aWFsPE5hdmJhckJyYW5kVGhlbWU+O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIE5hdmJhckJyYW5kVGhlbWUge1xuICByb290OiB7XG4gICAgYmFzZTogc3RyaW5nO1xuICB9O1xufVxuXG5leHBvcnQgY29uc3QgbmF2YmFyQnJhbmRUaGVtZTogTmF2YmFyQnJhbmRUaGVtZSA9IGNyZWF0ZVRoZW1lKHtcbiAgcm9vdDoge1xuICAgIGJhc2U6ICdjdXJzb3ItcG9pbnRlciBmbGV4IGl0ZW1zLWNlbnRlciBzcGFjZS14LTMgcnRsOnNwYWNlLXgtcmV2ZXJzZScsXG4gIH0sXG59KTtcblxuZXhwb3J0IHR5cGUgTmF2YmFyQnJhbmRDbGFzcyA9IEZsb3diaXRlQ2xhc3M7XG4iXX0=

package/esm2022/navbar/navbar-brand.theme.service.mjs

@@ -0,0 +1,17 @@
+import { mergeTheme } from 'flowbite-angular/utils';
+import { inject, InjectionToken } from '@angular/core';
+import { twMerge } from 'tailwind-merge';
+export const FLOWBITE_NAVBAR_BRAND_THEME_TOKEN = new InjectionToken('FLOWBITE_NAVBAR_BRAND_THEME_TOKEN');
+export class NavbarBrandThemeService {
+    constructor() {
+        this.baseTheme = inject(FLOWBITE_NAVBAR_BRAND_THEME_TOKEN);
+    }
+    getClasses(properties) {
+        const theme = mergeTheme(this.baseTheme, properties.customStyle);
+        const output = {
+            rootClass: twMerge(theme.root.base),
+        };
+        return output;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2YmFyLWJyYW5kLnRoZW1lLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2Zsb3diaXRlLWFuZ3VsYXIvbmF2YmFyL25hdmJhci1icmFuZC50aGVtZS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU9BLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUVwRCxPQUFPLEVBQUUsTUFBTSxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN2RCxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFekMsTUFBTSxDQUFDLE1BQU0saUNBQWlDLEdBQUcsSUFBSSxjQUFjLENBQ2pFLG1DQUFtQyxDQUNwQyxDQUFDO0FBRUYsTUFBTSxPQUFPLHVCQUF1QjtJQUFwQztRQUNtQixjQUFTLEdBQUcsTUFBTSxDQUFDLGlDQUFpQyxDQUFDLENBQUM7SUFXekUsQ0FBQztJQVRRLFVBQVUsQ0FBQyxVQUFpQztRQUNqRCxNQUFNLEtBQUssR0FBcUIsVUFBVSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsVUFBVSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBRW5GLE1BQU0sTUFBTSxHQUFxQjtZQUMvQixTQUFTLEVBQUUsT0FBTyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDO1NBQ3BDLENBQUM7UUFFRixPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7XG4gIE5hdmJhckJyYW5kQ2xhc3MsXG4gIE5hdmJhckJyYW5kUHJvcGVydGllcyxcbiAgTmF2YmFyQnJhbmRUaGVtZSxcbn0gZnJvbSAnLi9uYXZiYXItYnJhbmQudGhlbWUnO1xuXG5pbXBvcnQgdHlwZSB7IEZsb3diaXRlVGhlbWVTZXJ2aWNlIH0gZnJvbSAnZmxvd2JpdGUtYW5ndWxhcic7XG5pbXBvcnQgeyBtZXJnZVRoZW1lIH0gZnJvbSAnZmxvd2JpdGUtYW5ndWxhci91dGlscyc7XG5cbmltcG9ydCB7IGluamVjdCwgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IHR3TWVyZ2UgfSBmcm9tICd0YWlsd2luZC1tZXJnZSc7XG5cbmV4cG9ydCBjb25zdCBGTE9XQklURV9OQVZCQVJfQlJBTkRfVEhFTUVfVE9LRU4gPSBuZXcgSW5qZWN0aW9uVG9rZW48TmF2YmFyQnJhbmRUaGVtZT4oXG4gICdGTE9XQklURV9OQVZCQVJfQlJBTkRfVEhFTUVfVE9LRU4nXG4pO1xuXG5leHBvcnQgY2xhc3MgTmF2YmFyQnJhbmRUaGVtZVNlcnZpY2UgaW1wbGVtZW50cyBGbG93Yml0ZVRoZW1lU2VydmljZTxOYXZiYXJCcmFuZFByb3BlcnRpZXM+IHtcbiAgcHJpdmF0ZSByZWFkb25seSBiYXNlVGhlbWUgPSBpbmplY3QoRkxPV0JJVEVfTkFWQkFSX0JSQU5EX1RIRU1FX1RPS0VOKTtcblxuICBwdWJsaWMgZ2V0Q2xhc3Nlcyhwcm9wZXJ0aWVzOiBOYXZiYXJCcmFuZFByb3BlcnRpZXMpOiBOYXZiYXJCcmFuZENsYXNzIHtcbiAgICBjb25zdCB0aGVtZTogTmF2YmFyQnJhbmRUaGVtZSA9IG1lcmdlVGhlbWUodGhpcy5iYXNlVGhlbWUsIHByb3BlcnRpZXMuY3VzdG9tU3R5bGUpO1xuXG4gICAgY29uc3Qgb3V0cHV0OiBOYXZiYXJCcmFuZENsYXNzID0ge1xuICAgICAgcm9vdENsYXNzOiB0d01lcmdlKHRoZW1lLnJvb3QuYmFzZSksXG4gICAgfTtcblxuICAgIHJldHVybiBvdXRwdXQ7XG4gIH1cbn1cbiJdfQ==

package/esm2022/navbar/navbar-content.component.mjs

@@ -0,0 +1,46 @@
+import { NavbarContentThemeService } from './navbar-content.theme.service';
+import { NavbarComponent } from './navbar.component';
+import { BaseComponent, booleanToFlowbiteBoolean } from 'flowbite-angular';
+import { NgClass } from '@angular/common';
+import { ChangeDetectionStrategy, Component, inject, model, ViewEncapsulation, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NavbarContentComponent extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        this.themeService = inject(NavbarContentThemeService);
+        this.navbarComponent = model(inject(NavbarComponent));
+        //#region properties
+        this.color = model(this.navbarComponent().color());
+        this.customStyle = model({});
+    }
+    //#endregion
+    //#region BaseComponent implementation
+    fetchClass() {
+        return this.themeService.getClasses({
+            isOpen: booleanToFlowbiteBoolean(this.navbarComponent().isOpen()),
+            customStyle: this.customStyle(),
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: NavbarContentComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.0.0", type: NavbarContentComponent, isStandalone: true, selector: "flowbite-navbar-content", inputs: { navbarComponent: { classPropertyName: "navbarComponent", publicName: "navbarComponent", isSignal: true, isRequired: false, transformFunction: null }, color: { classPropertyName: "color", publicName: "color", isSignal: true, isRequired: false, transformFunction: null }, customStyle: { classPropertyName: "customStyle", publicName: "customStyle", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { navbarComponent: "navbarComponentChange", color: "colorChange", customStyle: "customStyleChange" }, usesInheritance: true, ngImport: i0, template: `
+    <div [ngClass]="contentClasses().navbarContentListClass">
+      <ng-content />
+    </div>
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: NavbarContentComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'flowbite-navbar-content',
+                    standalone: true,
+                    imports: [NgClass],
+                    template: `
+    <div [ngClass]="contentClasses().navbarContentListClass">
+      <ng-content />
+    </div>
+  `,
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/navbar/navbar-content.theme.mjs

@@ -0,0 +1,14 @@
+import { createTheme } from 'flowbite-angular/utils';
+export const navbarContentTheme = createTheme({
+    root: {
+        base: 'w-full md:block md:w-auto order-last md:order-none',
+        isOpen: {
+            enabled: '',
+            disabled: 'hidden',
+        },
+    },
+    list: {
+        base: 'font-medium flex flex-col p-4 md:p-0 mt-4 items-center border border-gray-100 rounded-lg bg-gray-50 md:flex-row md:space-x-8 rtl:space-x-reverse md:mt-0 md:border-0 md:bg-white dark:bg-gray-900 md:dark:bg-gray-800 dark:border-gray-700',
+    },
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2YmFyLWNvbnRlbnQudGhlbWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2Zsb3diaXRlLWFuZ3VsYXIvbmF2YmFyL25hdmJhci1jb250ZW50LnRoZW1lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQWlCckQsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQXVCLFdBQVcsQ0FBQztJQUNoRSxJQUFJLEVBQUU7UUFDSixJQUFJLEVBQUUsb0RBQW9EO1FBQzFELE1BQU0sRUFBRTtZQUNOLE9BQU8sRUFBRSxFQUFFO1lBQ1gsUUFBUSxFQUFFLFFBQVE7U0FDbkI7S0FDRjtJQUNELElBQUksRUFBRTtRQUNKLElBQUksRUFBRSw0T0FBNE87S0FDblA7Q0FDRixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IERlZXBQYXJ0aWFsLCBGbG93Yml0ZUJvb2xlYW4sIEZsb3diaXRlQ2xhc3MgfSBmcm9tICdmbG93Yml0ZS1hbmd1bGFyJztcbmltcG9ydCB7IGNyZWF0ZVRoZW1lIH0gZnJvbSAnZmxvd2JpdGUtYW5ndWxhci91dGlscyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTmF2YmFyQ29udGVudFByb3BlcnRpZXMge1xuICBpc09wZW46IGtleW9mIEZsb3diaXRlQm9vbGVhbjtcbiAgY3VzdG9tU3R5bGU6IERlZXBQYXJ0aWFsPE5hdmJhckNvbnRlbnRUaGVtZT47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgTmF2YmFyQ29udGVudFRoZW1lIHtcbiAgcm9vdDoge1xuICAgIGJhc2U6IHN0cmluZztcbiAgICBpc09wZW46IEZsb3diaXRlQm9vbGVhbjtcbiAgfTtcbiAgbGlzdDoge1xuICAgIGJhc2U6IHN0cmluZztcbiAgfTtcbn1cblxuZXhwb3J0IGNvbnN0IG5hdmJhckNvbnRlbnRUaGVtZTogTmF2YmFyQ29udGVudFRoZW1lID0gY3JlYXRlVGhlbWUoe1xuICByb290OiB7XG4gICAgYmFzZTogJ3ctZnVsbCBtZDpibG9jayBtZDp3LWF1dG8gb3JkZXItbGFzdCBtZDpvcmRlci1ub25lJyxcbiAgICBpc09wZW46IHtcbiAgICAgIGVuYWJsZWQ6ICcnLFxuICAgICAgZGlzYWJsZWQ6ICdoaWRkZW4nLFxuICAgIH0sXG4gIH0sXG4gIGxpc3Q6IHtcbiAgICBiYXNlOiAnZm9udC1tZWRpdW0gZmxleCBmbGV4LWNvbCBwLTQgbWQ6cC0wIG10LTQgaXRlbXMtY2VudGVyIGJvcmRlciBib3JkZXItZ3JheS0xMDAgcm91bmRlZC1sZyBiZy1ncmF5LTUwIG1kOmZsZXgtcm93IG1kOnNwYWNlLXgtOCBydGw6c3BhY2UteC1yZXZlcnNlIG1kOm10LTAgbWQ6Ym9yZGVyLTAgbWQ6Ymctd2hpdGUgZGFyazpiZy1ncmF5LTkwMCBtZDpkYXJrOmJnLWdyYXktODAwIGRhcms6Ym9yZGVyLWdyYXktNzAwJyxcbiAgfSxcbn0pO1xuXG5leHBvcnQgaW50ZXJmYWNlIE5hdmJhckNvbnRlbnRDbGFzcyBleHRlbmRzIEZsb3diaXRlQ2xhc3Mge1xuICBuYXZiYXJDb250ZW50TGlzdENsYXNzOiBzdHJpbmc7XG59XG4iXX0=