@cute-widgets/base 20.0.1

package/fesm2022/cute-widgets-base-core.mjs

@@ -0,0 +1,1600 @@
+import { MediaMatcher } from '@angular/cdk/layout';
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, ANIMATION_MODULE_TYPE, Directive, NgModule, signal, computed, HostListener, Input, APP_ID, Injectable, LOCALE_ID, isDevMode, Pipe, SecurityContext, DOCUMENT } from '@angular/core';
+import { startWith, take } from 'rxjs/operators';
+import { CommonModule } from '@angular/common';
+import { firstValueFrom, fromEvent, Subject } from 'rxjs';
+import { DomSanitizer } from '@angular/platform-browser';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+
+/** Injection token used to configure the animations in CuteWidgets. */
+const CUTE_WIDGETS_ANIMATIONS = new InjectionToken('CUTE_WIDGETS_ANIMATIONS');
+/**
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ * @docs-private
+ */
+class AnimationCurves {
+    static { this.STANDARD_CURVE = 'cubic-bezier(0.4,0.0,0.2,1)'; }
+    static { this.DECELERATION_CURVE = 'cubic-bezier(0.0,0.0,0.2,1)'; }
+    static { this.ACCELERATION_CURVE = 'cubic-bezier(0.4,0.0,1,1)'; }
+    static { this.SHARP_CURVE = 'cubic-bezier(0.4,0.0,0.6,1)'; }
+}
+/**
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ * @docs-private
+ */
+class AnimationDurations {
+    static { this.COMPLEX = '375ms'; }
+    static { this.ENTERING = '225ms'; }
+    static { this.EXITING = '195ms'; }
+}
+let reducedMotion = null;
+/**
+ * Gets the configured animations state.
+ * @docs-private
+ */
+function _getAnimationsState() {
+    if (inject(CUTE_WIDGETS_ANIMATIONS, { optional: true })?.animationsDisabled ||
+        inject(ANIMATION_MODULE_TYPE, { optional: true }) === 'NoopAnimations') {
+        return 'di-disabled';
+    }
+    reducedMotion ??= inject(MediaMatcher).matchMedia('(prefers-reduced-motion)').matches;
+    return reducedMotion ? 'reduced-motion' : 'enabled';
+}
+/**
+ * Returns whether animations have been disabled by DI. Must be called in a DI context.
+ * @docs-private
+ */
+function _animationsDisabled() {
+    return _getAnimationsState() !== 'enabled';
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * Bootstrap media-queries, or `breakpoints`.
+ * PascalCase is being used as Breakpoints is used like an enum.
+ */
+const bsBreakpoints = {
+    SmallAndDown: '(max-width: 575.98px)',
+    MediumAndDown: '(max-width: 767.98px)',
+    LargeAndDown: '(max-width: 991.98px)',
+    XLargeAndDown: '(max-width: 1199.98px)',
+    XXLargeAndDown: '(max-width: 1399.98px)',
+    XSmall: '(max-width: 575.98px)',
+    Small: '(min-width: 576px) and (max-width: 767.98px)',
+    Medium: '(min-width: 768px) and (max-width: 991.98px)',
+    Large: '(min-width: 992px) and (max-width: 1199.98px)',
+    XLarge: '(min-width: 1200px) and (max-width: 1399.98px)',
+    XXLarge: '(min-width: 1400px)',
+    get grid() {
+        return { xs: 0, sm: 576, md: 768, lg: 992, xl: 1200, xxl: 1400 };
+    },
+    get xs() { return this.XSmall; },
+    get sm() { return this.Small; },
+    get md() { return this.Medium; },
+    get lg() { return this.Large; },
+    get xl() { return this.XLarge; },
+    get xxl() { return this.XXLarge; },
+    /**
+     * Gets the object's property name of the media-query by its value
+     * @param query The media-query text
+     * @returns The property name of the media-query or _undefined_ if it was not found
+     */
+    getQueryName(query) {
+        let res;
+        if (query) {
+            for (const key in this) {
+                if (this[key] === query) {
+                    res = key;
+                    break;
+                }
+            }
+        }
+        return res;
+    },
+    /**
+     * Gets the breakpoint label by Bootstrap's breakpoint abbreviation
+     * @param code Bootstrap's breakpoint abbreviation
+     * @returns More descriptive text of the abbreviation
+     */
+    getLabel(code) {
+        switch (code) {
+            case "xs": return "XSmall";
+            case "sm": return "Small";
+            case "md": return "Medium";
+            case "lg": return "Large";
+            case "xl": return "XLarge";
+            case "xxl": return "XXLarge";
+        }
+        return "";
+    }
+};
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/**
+ * Shared directive to count lines inside a text area, such as a list item.
+ * Line elements can be extracted with a @ContentChildren(CuteLine) query, then
+ * counted by checking the query list's length.
+ */
+class CuteLine {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteLine, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.15", type: CuteLine, isStandalone: true, selector: "[cute-line], [cuteLine]", host: { classAttribute: "cute-line" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteLine, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cute-line], [cuteLine]',
+                    host: { 'class': 'cute-line' },
+                    standalone: true,
+                }]
+        }] });
+/**
+ * Helper that takes a query list of lines and sets the correct class on the host.
+ */
+function setLines(lines, element, prefix = 'cute') {
+    // Note: doesn't need to unsubscribe, because `changes`
+    // gets completed by Angular when the view is destroyed.
+    lines.changes.pipe(startWith(lines)).subscribe(({ length }) => {
+        setClass(element, `${prefix}-2-line`, false);
+        setClass(element, `${prefix}-3-line`, false);
+        setClass(element, `${prefix}-multi-line`, false);
+        if (length === 2 || length === 3) {
+            setClass(element, `${prefix}-${length}-line`, true);
+        }
+        else if (length > 3) {
+            setClass(element, `${prefix}-multi-line`, true);
+        }
+    });
+}
+/** Adds or removes a class from an element. */
+function setClass(element, className, isAdd) {
+    element.nativeElement.classList.toggle(className, isAdd);
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+const TYPES = [
+    CuteLine
+];
+class CuteLineModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteLineModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.15", ngImport: i0, type: CuteLineModule, imports: [CommonModule, CuteLine], exports: [CuteLine] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteLineModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteLineModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, ...TYPES],
+                    exports: TYPES,
+                    declarations: [],
+                }]
+        }] });
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+const RIPPLE_CLASS_NAME = "cute-ripple-element";
+class Ripple {
+    constructor(target) {
+        this._active = signal(false, ...(ngDevMode ? [{ debugName: "_active" }] : []));
+        this._disabled = false;
+        this.isActive = computed(() => this._active(), ...(ngDevMode ? [{ debugName: "isActive" }] : []));
+        this._target = target;
+    }
+    get disabled() { return this._disabled; }
+    set disabled(v) { this._disabled = v; }
+    stop() {
+        if (this._target) {
+            const existingRipple = this._target.getElementsByClassName(RIPPLE_CLASS_NAME)[0];
+            if (existingRipple) {
+                existingRipple.parentElement?.remove();
+            }
+        }
+        this._active.set(false);
+    }
+    launch(event, options) {
+        if (this.disabled) {
+            return;
+        }
+        if (this.isActive()) {
+            this.stop();
+        }
+        if (this._target && event) {
+            const rect = this._target.getBoundingClientRect();
+            const parent = document.createElement("div");
+            parent.style.position = "absolute";
+            parent.style.top = "0";
+            parent.style.right = "0";
+            parent.style.bottom = "0";
+            parent.style.left = "0";
+            parent.style.overflow = "hidden";
+            parent.style.borderRadius = "inherit";
+            parent.style.transform = "perspective(0)";
+            parent.ariaHidden = "true";
+            parent.classList.add("cute-ripple");
+            const circle = document.createElement("span");
+            const diameter = Math.max(rect.width, rect.height);
+            const radius = diameter / 2;
+            circle.style.width = circle.style.height = `${diameter}px`;
+            if (options?.centered) {
+                circle.style.left = `${rect.width / 2 - radius}px`;
+                circle.style.top = `${rect.height / 2 - radius}px`;
+            }
+            else {
+                circle.style.left = `${event.clientX - rect.left - radius}px`;
+                circle.style.top = `${event.clientY - rect.top - radius}px`;
+            }
+            if (options?.color) {
+                circle.style.setProperty("--cute-ripple-bg-color", options.color);
+            }
+            if (options?.duration) {
+                circle.style.setProperty("--cute-ripple-duration", String(options.duration));
+            }
+            circle.classList.add(RIPPLE_CLASS_NAME);
+            parent.appendChild(circle);
+            this._target.appendChild(parent);
+            this._active.set(true);
+            Promise.any([
+                firstValueFrom(fromEvent(circle, "animationend").pipe(take(1))),
+                firstValueFrom(fromEvent(circle, "animationcancel").pipe(take(1))),
+                //firstValueFrom(fromEvent(document, "mouseup").pipe(take(1))),
+            ]).then(() => {
+                circle.parentElement?.remove();
+                this._active.set(false);
+            });
+        }
+    }
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+class RippleManager {
+    static { this._ripples = new WeakMap(); }
+    static getInstance(target) {
+        return RippleManager.createRipple(target);
+    }
+    static createRipple(target) {
+        if (!target) {
+            throw new Error("'target' is required when instantiating a Ripple object");
+        }
+        let ripple = this._ripples.get(target);
+        if (!ripple) {
+            ripple = new RippleImpl(target);
+            this._ripples.set(target, ripple);
+        }
+        return ripple;
+    }
+    static removeRipple(target) {
+        if (target) {
+            let ripple = this._ripples.get(target);
+            if (ripple) {
+                ripple.stop();
+            }
+            this._ripples.delete(target);
+        }
+    }
+}
+class RippleImpl extends Ripple {
+    constructor(target) {
+        super(target);
+    }
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+class CuteRipple /* extends ... */ {
+    onMouseDown(event) {
+        if (this._ripple) {
+            this._ripple.launch(event, this.rippleOptions);
+        }
+    }
+    constructor(_elemRef) {
+        this._elemRef = _elemRef;
+        this._ripple = RippleManager.createRipple(_elemRef.nativeElement);
+    }
+    ngOnDestroy() {
+        RippleManager.removeRipple(this._elemRef.nativeElement);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteRipple /* extends ... */, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.15", type: CuteRipple /* extends ... */, isStandalone: true, selector: "[cuteRipple]", inputs: { rippleOptions: ["cuteRipple", "rippleOptions"] }, host: { listeners: { "mousedown": "onMouseDown($event)" } }, exportAs: ["cuteRipple"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteRipple /* extends ... */, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cuteRipple]',
+                    exportAs: 'cuteRipple',
+                    host: {},
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { rippleOptions: [{
+                type: Input,
+                args: ["cuteRipple"]
+            }], onMouseDown: [{
+                type: HostListener,
+                args: ["mousedown", ['$event']]
+            }] } });
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * Gets transition duration total value
+ * @param element Source HTML element
+ * @returns Duration with delay time in milliseconds
+ */
+function getOverallTransitionDuration(element) {
+    return getTransitionDelay(element) + getTransitionDuration(element);
+}
+/**
+ * Gets transition duration value
+ * @param element Source HTML element
+ * @returns Duration time in milliseconds
+ */
+function getTransitionDuration(element) {
+    const { transitionDuration } = window.getComputedStyle(element);
+    const durationInMilliseconds = transitionDuration.toLowerCase().endsWith("ms");
+    const transitionDurationMs = parseFloat(transitionDuration) * (durationInMilliseconds ? 1 : 1000);
+    return (transitionDurationMs);
+}
+/**
+ * Gets duration to wait before starting transition
+ * @param element Source HTML element
+ * @returns Delay time in milliseconds
+ */
+function getTransitionDelay(element) {
+    const { transitionDelay } = window.getComputedStyle(element);
+    const delayInMilliseconds = transitionDelay.toLowerCase().endsWith("ms");
+    const transitionDelayMs = parseFloat(transitionDelay) * (delayInMilliseconds ? 1 : 1000);
+    return (transitionDelayMs);
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+function createValueToken(value) {
+    return createFactoryToken(() => value);
+}
+function createFactoryToken(factory) {
+    return new InjectionToken(`createFactoryToken`, { factory });
+}
+
+/**
+ * Forcibly starts the process of downloading and saving the file.
+ * @param blobData Data to save
+ * @param filename File name to save. Default is `download`.
+ */
+function saveAs(blobData, filename) {
+    const link = document.createElement("a");
+    link.href = URL.createObjectURL(blobData);
+    link.download = filename || "download";
+    link.click();
+    URL.revokeObjectURL(link.href);
+}
+/**
+ * Exports data from HTML table to MS Excel format text
+ * @param tableIdOrElem HTML table's `id` value or `ElementRef` object
+ * @param options Export options
+ */
+function exportToExcel(tableIdOrElem, options = { filename: 'records.xls' }) {
+    let tableElem;
+    if (typeof tableIdOrElem === "string") {
+        tableElem = document.getElementById(tableIdOrElem);
+    }
+    else {
+        tableElem = tableIdOrElem.nativeElement;
+    }
+    if (tableElem && tableElem instanceof HTMLTableElement) {
+        //const tableHTML = encodeURIComponent(tableElem.outerHTML.replace(/ or .*?>/g, '>'));
+        const tableHTML = tableElem.outerHTML.replace(/ or .*?>/g, '>');
+        const blobData = new Blob([tableHTML], { type: '{type: application/vnd.ms-excel' });
+        saveAs(blobData, options?.filename);
+    }
+}
+/**
+ * Exports data from HTML table to CSV format text
+ * @param tableIdOrElem HTML table's `id` value or `ElementRef` object
+ * @param options Export options
+ */
+function exportToCSV(tableIdOrElem, options = { filename: 'records.csv' }) {
+    let tableElem;
+    if (typeof tableIdOrElem === "string") {
+        tableElem = document.getElementById(tableIdOrElem);
+    }
+    else {
+        tableElem = tableIdOrElem.nativeElement;
+    }
+    if (tableElem && tableElem instanceof HTMLTableElement) {
+        const rows = tableElem.querySelectorAll("tr");
+        let csv = [];
+        let keys = [];
+        if (rows.length > 0 && options && options.columns?.length) {
+            const headers = rows[0].querySelectorAll("th");
+            headers.forEach((header, key) => {
+                if (options.columns.findIndex((name) => {
+                    const loweredName = name.toLowerCase();
+                    return header.innerText.toLowerCase() == loweredName || header.classList.contains("cdk-column-" + loweredName);
+                }) >= 0) {
+                    keys.push(key);
+                }
+            });
+        }
+        const appendCells = (cells) => {
+            const rowText = Array.from(cells).map(cell => cell.innerText);
+            csv.push(rowText.join(options?.delimiter ?? ","));
+        };
+        if (keys.length > 0) {
+            rows.forEach((row) => {
+                const allCells = row.querySelectorAll("th,td");
+                let cells = [];
+                allCells.forEach((cell, key) => {
+                    if (keys.indexOf(key) >= 0) {
+                        cells.push(cell);
+                    }
+                });
+                appendCells(cells);
+            });
+        }
+        else {
+            rows.forEach((row) => {
+                appendCells(row.querySelectorAll("th,td"));
+            });
+        }
+        const blobData = new Blob([csv.join("\n")], { type: "text/csv;charset=utf-8;" });
+        saveAs(blobData, options?.filename);
+    }
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/**
+ * Keeps track of the ID count per prefix. This helps us make the IDs a bit more deterministic
+ * like they were before the service was introduced. Note that ideally we wouldn't have to do
+ * this, but there are some internal tests that rely on the IDs.
+ */
+const counters = {};
+/** Service that generates unique IDs for DOM nodes. */
+class IdGenerator {
+    constructor() {
+        this._appId = inject(APP_ID);
+    }
+    /**
+     * Generates a unique ID with a specific prefix.
+     * @param prefix Prefix to add to the ID.
+     */
+    getId(prefix) {
+        // Omit the app ID if it's the default `ng`. Since the vast majority of pages have one
+        // Angular app on them, we can reduce the number of breakages by not adding it.
+        if (this._appId !== 'ng') {
+            prefix += this._appId;
+        }
+        if (!counters.hasOwnProperty(prefix)) {
+            counters[prefix] = 0;
+        }
+        return `${prefix}${counters[prefix]++}`;
+    }
+    /**
+     * Generates UUID (ver.4) string using simple algorithm based on random value only
+     */
+    getUUID() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'
+            .replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: IdGenerator, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: IdGenerator, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: IdGenerator, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * A class with static methods specifically designed for scheduling tasks in the browser.
+ */
+class Scheduler {
+    /** Yielding to the main thread in the browser. */
+    static async yield() {
+        const globalScheduler = globalThis.scheduler;
+        if (globalScheduler?.yield) {
+            return globalScheduler.yield();
+        }
+        // Fall back to yielding with setTimeout.
+        return new Promise(resolve => {
+            setTimeout(resolve, 0);
+        });
+    }
+    /**
+     * Resolves a promise after the delay time in milliseconds
+     * @param ms Number of milliseconds to wait
+     *
+     * @see {@link delay}
+     */
+    static async wait(ms) {
+        const startNow = performance.now();
+        while ((performance.now() - startNow) < ms) {
+            await Scheduler.yield();
+        }
+    }
+    /**
+     * Adding a task to be scheduled according to their priority.
+     * @param callback Function to run
+     * @param options Scheduler options
+     *
+     * @see {@link async.post}
+     */
+    static async postTask(callback, options) {
+        const globalScheduler = globalThis.scheduler;
+        if (globalScheduler?.postTask) {
+            return globalScheduler.postTask(callback, options);
+        }
+        return new Promise((resolve) => {
+            setTimeout(() => resolve(callback()), options?.delay ?? 0);
+        });
+    }
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/** InjectionToken for datepicker that can be used to override default locale code. */
+const CUTE_DATE_LOCALE = new InjectionToken('CUTE_DATE_LOCALE', {
+    providedIn: 'root',
+    factory: CUTE_DATE_LOCALE_FACTORY,
+});
+/**
+ * @docs-private
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ */
+function CUTE_DATE_LOCALE_FACTORY() {
+    return inject(LOCALE_ID);
+}
+const NOT_IMPLEMENTED = 'Method not implemented';
+/** Adapts type `D` to be usable as a date by cdk-based components that work with dates. */
+class DateAdapter {
+    constructor() {
+        this._localeChanges = new Subject();
+        /** A stream that emits when the locale changes. */
+        this.localeChanges = this._localeChanges;
+    }
+    /**
+     * Sets the time of one date to the time of another.
+     * @param target Date whose time will be set.
+     * @param hours New hours to set on the date object.
+     * @param minutes New minutes to set on the date object.
+     * @param seconds New seconds to set on the date object.
+     */
+    setTime(target, hours, minutes, seconds) {
+        throw new Error(NOT_IMPLEMENTED);
+    }
+    /**
+     * Gets the hours component of the given date.
+     * @param date The date to extract the hours from.
+     */
+    getHours(date) {
+        throw new Error(NOT_IMPLEMENTED);
+    }
+    /**
+     * Gets the minutes component of the given date.
+     * @param date The date to extract the minutes from.
+     */
+    getMinutes(date) {
+        throw new Error(NOT_IMPLEMENTED);
+    }
+    /**
+     * Gets the seconds component of the given date.
+     * @param date The date to extract the seconds from.
+     */
+    getSeconds(date) {
+        throw new Error(NOT_IMPLEMENTED);
+    }
+    /**
+     * Parses a date with a specific time from a user-provided value.
+     * @param value The value to parse.
+     * @param parseFormat The expected format of the value being parsed
+     *     (type is implementation-dependent).
+     */
+    parseTime(value, parseFormat) {
+        throw new Error(NOT_IMPLEMENTED);
+    }
+    /**
+     * Adds an amount of seconds to the specified date.
+     * @param date Date to which to add the seconds.
+     * @param amount Amount of seconds to add to the date.
+     */
+    addSeconds(date, amount) {
+        throw new Error(NOT_IMPLEMENTED);
+    }
+    /**
+     * Given a potential date object, returns that same date object if it is
+     * a valid date, or `null` if it's not a valid date.
+     * @param obj The object to check.
+     * @returns A date or `null`.
+     */
+    getValidDateOrNull(obj) {
+        return this.isDateInstance(obj) && this.isValid(obj) ? obj : null;
+    }
+    /**
+     * Attempts to deserialize a value to a valid date object. This is different from parsing in that
+     * deserialize should only accept non-ambiguous, locale-independent formats (e.g. a ISO 8601
+     * string). The default implementation does not allow any deserialization, it simply checks that
+     * the given value is already a valid date object or null. The `<mat-datepicker>` will call this
+     * method on all of its `@Input()` properties that accept dates. It is therefore possible to
+     * support passing values from your backend directly to these properties by overriding this method
+     * to also deserialize the format used by your backend.
+     * @param value The value to be deserialized into a date object.
+     * @returns The deserialized date object, either a valid date, null if the value can be
+     *     deserialized into a null date (e.g. the empty string), or an invalid date.
+     */
+    deserialize(value) {
+        if (value == null || (this.isDateInstance(value) && this.isValid(value))) {
+            return value;
+        }
+        return this.invalid();
+    }
+    /**
+     * Sets the locale used for all dates.
+     * @param locale The new locale.
+     */
+    setLocale(locale) {
+        this.locale = locale;
+        this._localeChanges.next();
+    }
+    /**
+     * Compares two dates.
+     * @param first The first date to compare.
+     * @param second The second date to compare.
+     * @returns 0 if the dates are equal, a number less than 0 if the first date is earlier,
+     *     a number greater than 0 if the first date is later.
+     */
+    compareDate(first, second) {
+        return (this.getYear(first) - this.getYear(second) ||
+            this.getMonth(first) - this.getMonth(second) ||
+            this.getDate(first) - this.getDate(second));
+    }
+    /**
+     * Compares the time values of two dates.
+     * @param first First date to compare.
+     * @param second Second date to compare.
+     * @returns 0 if the times are equal, a number less than 0 if the first time is earlier,
+     *     a number greater than 0 if the first time is later.
+     */
+    compareTime(first, second) {
+        return (this.getHours(first) - this.getHours(second) ||
+            this.getMinutes(first) - this.getMinutes(second) ||
+            this.getSeconds(first) - this.getSeconds(second));
+    }
+    /**
+     * Checks if two dates are equal.
+     * @param first The first date to check.
+     * @param second The second date to check.
+     * @returns Whether the two dates are equal.
+     *     Null dates are considered equal to other null dates.
+     */
+    sameDate(first, second) {
+        if (first && second) {
+            let firstValid = this.isValid(first);
+            let secondValid = this.isValid(second);
+            if (firstValid && secondValid) {
+                return !this.compareDate(first, second);
+            }
+            return firstValid == secondValid;
+        }
+        return first == second;
+    }
+    /**
+     * Checks if the times of two dates are equal.
+     * @param first The first date to check.
+     * @param second The second date to check.
+     * @returns Whether the times of the two dates are equal.
+     *     Null dates are considered equal to other null dates.
+     */
+    sameTime(first, second) {
+        if (first && second) {
+            const firstValid = this.isValid(first);
+            const secondValid = this.isValid(second);
+            if (firstValid && secondValid) {
+                return !this.compareTime(first, second);
+            }
+            return firstValid == secondValid;
+        }
+        return first == second;
+    }
+    /**
+     * Clamp the given date between min and max dates.
+     * @param date The date to clamp.
+     * @param min The minimum value to allow. If null or omitted, no min is enforced.
+     * @param max The maximum value to allow. If null or omitted, no max is enforced.
+     * @returns `min` if `date` is less than `min`, `max` if date is greater than `max`,
+     *     otherwise `date`.
+     */
+    clampDate(date, min, max) {
+        if (min && this.compareDate(date, min) < 0) {
+            return min;
+        }
+        if (max && this.compareDate(date, max) > 0) {
+            return max;
+        }
+        return date;
+    }
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+const CUTE_DATE_FORMATS = new InjectionToken('cute-date-formats');
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/**
+ * Matches strings that have the form of a valid RFC 3339 string
+ * (https://tools.ietf.org/html/rfc3339). Note that the string may not actually be a valid date
+ * because the regex will match strings and without of bounds month, date, etc.
+ */
+const ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;
+/**
+ * Matches a time string. Supported formats:
+ * - {{hours}}:{{minutes}}
+ * - {{hours}}:{{minutes}}:{{seconds}}
+ * - {{hours}}:{{minutes}} AM/PM
+ * - {{hours}}:{{minutes}}:{{seconds}} AM/PM
+ * - {{hours}}.{{minutes}}
+ * - {{hours}}.{{minutes}}.{{seconds}}
+ * - {{hours}}.{{minutes}} AM/PM
+ * - {{hours}}.{{minutes}}.{{seconds}} AM/PM
+ */
+const TIME_REGEX = /^(\d?\d)[:.](\d?\d)(?:[:.](\d?\d))?\s*(AM|PM)?$/i;
+/** Creates an array and fills it with values. */
+function range(length, valueFunction) {
+    const valuesArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        valuesArray[i] = valueFunction(i);
+    }
+    return valuesArray;
+}
+/** Adapts the native JS Date for use with cdk-based components that work with dates. */
+class NativeDateAdapter extends DateAdapter {
+    constructor() {
+        super();
+        /** The injected locale. */
+        this._cuteDateLocale = inject(CUTE_DATE_LOCALE, { optional: true });
+        const cuteDateLocale = inject(CUTE_DATE_LOCALE, { optional: true });
+        if (cuteDateLocale !== undefined) {
+            this._cuteDateLocale = cuteDateLocale;
+        }
+        super.setLocale(this._cuteDateLocale);
+    }
+    getYear(date) { return date.getFullYear(); }
+    getMonth(date) { return date.getMonth(); }
+    getDate(date) { return date.getDate(); }
+    getDayOfWeek(date) { return date.getDay(); }
+    getMonthNames(style) {
+        const dtf = new Intl.DateTimeFormat(this.locale, { month: style, timeZone: 'utc' });
+        return range(12, i => this._format(dtf, new Date(2017, i, 1)));
+    }
+    getDateNames() {
+        const dtf = new Intl.DateTimeFormat(this.locale, { day: 'numeric', timeZone: 'utc' });
+        return range(31, i => this._format(dtf, new Date(2017, 0, i + 1)));
+    }
+    getDayOfWeekNames(style) {
+        const dtf = new Intl.DateTimeFormat(this.locale, { weekday: style, timeZone: 'utc' });
+        return range(7, i => this._format(dtf, new Date(2017, 0, i + 1)));
+    }
+    getYearName(date) {
+        const dtf = new Intl.DateTimeFormat(this.locale, { year: 'numeric', timeZone: 'utc' });
+        return this._format(dtf, date);
+    }
+    getFirstDayOfWeek() {
+        // At the time of writing `Intl.Locale` isn't available
+        // in the internal types, so we need to cast to `any`.
+        if (typeof Intl !== 'undefined' && Intl.Locale) {
+            const locale = new Intl.Locale(this.locale);
+            // Some browsers implement a `getWeekInfo` method while others have a `weekInfo` getter.
+            // Note that this isn't supported in all browsers, so we need to null check it.
+            const firstDay = (locale.getWeekInfo?.() || locale.weekInfo)?.firstDay ?? 0;
+            // `weekInfo.firstDay` is a number between 1 and 7 where, starting from Monday,
+            // whereas our representation is 0 to 6 where 0 is Sunday, so we need to normalize it.
+            return firstDay === 7 ? 0 : firstDay;
+        }
+        // Default to Sunday if the browser doesn't provide the week information.
+        return 0;
+    }
+    getNumDaysInMonth(date) {
+        return this.getDate(this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + 1, 0));
+    }
+    clone(date) {
+        return new Date(date.getTime());
+    }
+    createDate(year, month, date) {
+        if (isDevMode()) {
+            // Check for invalid month and date (except upper bound on date which we have to check after
+            // creating the Date).
+            if (month < 0 || month > 11) {
+                throw Error(`Invalid month index "${month}". Month index has to be between 0 and 11.`);
+            }
+            if (date < 1) {
+                throw Error(`Invalid date "${date}". Date has to be greater than 0.`);
+            }
+        }
+        let result = this._createDateWithOverflow(year, month, date);
+        // Check that the date wasn't above the upper bound for the month, causing the month to overflow
+        if (result.getMonth() != month && isDevMode()) {
+            throw Error(`Invalid date "${date}" for month with index "${month}".`);
+        }
+        return result;
+    }
+    today() {
+        return new Date();
+    }
+    parse(value, parseFormat) {
+        // We have no way using the native JS Date to set the parse format or locale, so we ignore these
+        // parameters.
+        if (typeof value == 'number') {
+            return new Date(value);
+        }
+        return value ? new Date(Date.parse(value)) : null;
+    }
+    format(date, displayFormat) {
+        if (!this.isValid(date)) {
+            throw Error('NativeDateAdapter: Cannot format invalid date.');
+        }
+        const dtf = new Intl.DateTimeFormat(this.locale, { ...displayFormat, timeZone: 'utc' });
+        return this._format(dtf, date);
+    }
+    addCalendarYears(date, years) {
+        return this.addCalendarMonths(date, years * 12);
+    }
+    addCalendarMonths(date, months) {
+        let newDate = this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + months, this.getDate(date));
+        // It's possible to wind up in the wrong month if the original month has more days than the new
+        // month. In this case we want to go to the last day of the desired month.
+        // Note: the additional + 12 % 12 ensures we end up with a positive number, since JS % doesn't
+        // guarantee this.
+        if (this.getMonth(newDate) != (((this.getMonth(date) + months) % 12) + 12) % 12) {
+            newDate = this._createDateWithOverflow(this.getYear(newDate), this.getMonth(newDate), 0);
+        }
+        return newDate;
+    }
+    addCalendarDays(date, days) {
+        return this._createDateWithOverflow(this.getYear(date), this.getMonth(date), this.getDate(date) + days);
+    }
+    toIso8601(date) {
+        return [
+            date.getUTCFullYear(),
+            this._2digit(date.getUTCMonth() + 1),
+            this._2digit(date.getUTCDate()),
+        ].join('-');
+    }
+    /**
+     * Returns the given value if given a valid Date or null. Deserializes valid ISO 8601 strings
+     * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into null. Returns an
+     * invalid date for all other values.
+     */
+    deserialize(value) {
+        if (typeof value === 'string') {
+            if (!value) {
+                return null;
+            }
+            // The `Date` constructor accepts formats other than ISO 8601, so we need to make sure the
+            // string is the right format first.
+            if (ISO_8601_REGEX.test(value)) {
+                let date = new Date(value);
+                if (this.isValid(date)) {
+                    return date;
+                }
+            }
+        }
+        return super.deserialize(value);
+    }
+    isDateInstance(obj) {
+        return obj instanceof Date;
+    }
+    isValid(date) {
+        return !isNaN(date.getTime());
+    }
+    invalid() {
+        return new Date(NaN);
+    }
+    setTime(target, hours, minutes, seconds) {
+        if (isDevMode()) {
+            if (!inRange(hours, 0, 23)) {
+                throw Error(`Invalid hours "${hours}". Hours value must be between 0 and 23.`);
+            }
+            if (!inRange(minutes, 0, 59)) {
+                throw Error(`Invalid minutes "${minutes}". Minutes value must be between 0 and 59.`);
+            }
+            if (!inRange(seconds, 0, 59)) {
+                throw Error(`Invalid seconds "${seconds}". Seconds value must be between 0 and 59.`);
+            }
+        }
+        const clone = this.clone(target);
+        clone.setHours(hours, minutes, seconds, 0);
+        return clone;
+    }
+    getHours(date) {
+        return date.getHours();
+    }
+    getMinutes(date) {
+        return date.getMinutes();
+    }
+    getSeconds(date) {
+        return date.getSeconds();
+    }
+    parseTime(userValue, parseFormat) {
+        if (typeof userValue !== 'string') {
+            return userValue instanceof Date ? new Date(userValue.getTime()) : null;
+        }
+        const value = userValue.trim();
+        if (value.length === 0) {
+            return null;
+        }
+        // Attempt to parse the value directly.
+        let result = this._parseTimeString(value);
+        // Some locales add extra characters around the time, but are otherwise parseable
+        // (e.g. `00:05 ч.` in bg-BG). Try replacing all non-number and non-colon characters.
+        if (result === null) {
+            const withoutExtras = value.replace(/[^0-9:(AM|PM)]/gi, '').trim();
+            if (withoutExtras.length > 0) {
+                result = this._parseTimeString(withoutExtras);
+            }
+        }
+        return result || this.invalid();
+    }
+    addSeconds(date, amount) {
+        return new Date(date.getTime() + amount * 1000);
+    }
+    /** Creates a date but allows the month and date to overflow. */
+    _createDateWithOverflow(year, month, date) {
+        // Passing the year to the constructor causes year numbers <100 to be converted to 19xx.
+        // To work around this, we use `setFullYear` and `setHours` instead.
+        const d = new Date();
+        d.setFullYear(year, month, date);
+        d.setHours(0, 0, 0, 0);
+        return d;
+    }
+    /**
+     * Pads a number to make it two digits.
+     * @param n The number to pad.
+     * @returns The padded number.
+     */
+    _2digit(n) {
+        return ('00' + n).slice(-2);
+    }
+    /**
+     * When converting a Date object to string, javascript built-in functions may return wrong
+     * results because it applies its internal DST rules. The DST rules around the world change
+     * very frequently, and the current valid rule is not always valid in previous years though.
+     * We work around this problem building a new Date object which has its internal UTC
+     * representation with the local date and time.
+     * @param dtf Intl.DateTimeFormat object, containing the desired string format. It must have
+     *    timeZone set to 'utc' to work fine.
+     * @param date Date from which we want to get the string representation according to dtf
+     * @returns A Date object with its UTC representation based on the passed in date info
+     */
+    _format(dtf, date) {
+        // Passing the year to the constructor causes year numbers <100 to be converted to 19xx.
+        // To work around this, we use `setUTCFullYear` and `setUTCHours` instead.
+        const d = new Date();
+        d.setUTCFullYear(date.getFullYear(), date.getMonth(), date.getDate());
+        d.setUTCHours(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+        return dtf.format(d);
+    }
+    /**
+     * Attempts to parse a time string into a date object. Returns null if it cannot be parsed.
+     * @param value Time string to parse.
+     */
+    _parseTimeString(value) {
+        // Note: we can technically rely on the browser for the time parsing by generating
+        // an ISO string and appending the string to the end of it. We don't do it, because
+        // browsers aren't consistent in what they support. Some examples:
+        // - Safari doesn't support AM/PM.
+        // - Firefox produces a valid date object if the time string has overflows (e.g. 12:75) while
+        //   other browsers produce an invalid date.
+        // - Safari doesn't allow padded numbers.
+        const parsed = value.toUpperCase().match(TIME_REGEX);
+        if (parsed) {
+            let hours = parseInt(parsed[1]);
+            const minutes = parseInt(parsed[2]);
+            let seconds = parsed[3] == null ? undefined : parseInt(parsed[3]);
+            const amPm = parsed[4];
+            if (hours === 12) {
+                hours = amPm === 'AM' ? 0 : hours;
+            }
+            else if (amPm === 'PM') {
+                hours += 12;
+            }
+            if (inRange(hours, 0, 23) &&
+                inRange(minutes, 0, 59) &&
+                (seconds == null || inRange(seconds, 0, 59))) {
+                return this.setTime(this.today(), hours, minutes, seconds || 0);
+            }
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: NativeDateAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: NativeDateAdapter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: NativeDateAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+/** Checks whether a number is within a certain range. */
+function inRange(value, min, max) {
+    return !isNaN(value) && value >= min && value <= max;
+}
+
+const CUTE_NATIVE_DATE_FORMATS = {
+    parse: {
+        dateInput: null,
+        timeInput: null,
+    },
+    display: {
+        dateInput: { year: 'numeric', month: 'numeric', day: 'numeric' },
+        timeInput: { hour: 'numeric', minute: 'numeric' },
+        monthYearLabel: { year: 'numeric', month: 'short' },
+        dateA11yLabel: { year: 'numeric', month: 'long', day: 'numeric' },
+        monthYearA11yLabel: { year: 'numeric', month: 'long' },
+        timeOptionLabel: { hour: 'numeric', minute: 'numeric' },
+    },
+};
+
+class NativeDateModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: NativeDateModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.15", ngImport: i0, type: NativeDateModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: NativeDateModule, providers: [{ provide: DateAdapter, useClass: NativeDateAdapter }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: NativeDateModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [{ provide: DateAdapter, useClass: NativeDateAdapter }],
+                }]
+        }] });
+class CuteNativeDateModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteNativeDateModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.15", ngImport: i0, type: CuteNativeDateModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteNativeDateModule, providers: [provideNativeDateAdapter()] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteNativeDateModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [provideNativeDateAdapter()],
+                }]
+        }] });
+function provideNativeDateAdapter(formats = CUTE_NATIVE_DATE_FORMATS) {
+    return [
+        { provide: DateAdapter, useClass: NativeDateAdapter },
+        { provide: CUTE_DATE_FORMATS, useValue: formats },
+    ];
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * Bypass security and trust the given value to be a safe resource.
+ * > WARNING: calling this method with untrusted user data exposes your application to XSS security risks!
+ * @example
+ * ```html
+ * <img [src]="item.source | safe:'url'" alt="Item image"/>
+ * ```
+ */
+class CuteSafePipe {
+    constructor() {
+        this.sanitizer = inject(DomSanitizer);
+    }
+    transform(value, type = "html") {
+        if (typeof value === "string") {
+            switch (type.toLowerCase()) {
+                case 'html': return this.sanitizer.bypassSecurityTrustHtml(value);
+                case 'style': return this.sanitizer.bypassSecurityTrustStyle(value);
+                case 'script': return this.sanitizer.bypassSecurityTrustScript(value);
+                case 'url': return this.sanitizer.bypassSecurityTrustUrl(value);
+                case 'resourceUrl': return this.sanitizer.bypassSecurityTrustResourceUrl(value);
+                default: throw new Error(`Invalid safe type specified: ${type}`);
+            }
+        }
+        return "";
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSafePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.15", ngImport: i0, type: CuteSafePipe, isStandalone: true, name: "safe" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSafePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'safe'
+                }]
+        }] });
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * Gets a safe value from either a known safe value or a value with unknown safety.
+ *
+ * @example
+ * ```html
+ * <div [innerHTML]="item.htmlContent | sanitize:'html'"></div>
+ * ```
+ */
+class CuteSanitizePipe {
+    constructor() {
+        this.sanitizer = inject(DomSanitizer);
+    }
+    transform(value, context = 'html') {
+        if (typeof value === "string") {
+            switch (context.toLowerCase()) {
+                case 'html': return this.sanitizer.sanitize(SecurityContext.HTML, value);
+                case 'style': return this.sanitizer.sanitize(SecurityContext.STYLE, value);
+                case 'script': return this.sanitizer.sanitize(SecurityContext.SCRIPT, value);
+                case 'url': return this.sanitizer.sanitize(SecurityContext.URL, value);
+                case 'resourceUrl': return this.sanitizer.sanitize(SecurityContext.RESOURCE_URL, value);
+                case 'none': return this.sanitizer.sanitize(SecurityContext.NONE, value);
+                default: throw new Error(`Invalid security context specified: ${context}`);
+            }
+        }
+        return "";
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSanitizePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.3.15", ngImport: i0, type: CuteSanitizePipe, isStandalone: true, name: "sanitize" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSanitizePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'sanitize'
+                }]
+        }] });
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * `CuteWidgets` supports standard Bootstrap 5 theme colors - `ThemeColor` type. But to account
+ * miscellaneous use cases of usage this colors in components CuteWidgets add extended definition of
+ * latter - `RichThemeColor`. Rich color is the standard color name plus "-emphasis" or "-contrast" suffix at the end.
+ * Depending on the context of applying color, the result CSS-class can be `.text-*`, `.text-bg-*` or ended with
+ * `-emphasis` or `-subtle` suffixes.
+ */
+/** Bootstrap theme colors */
+const Palette = ["primary", "secondary", "success", "danger", "warning", "info", "light", "dark", "link", "tertiary"];
+/**
+ * Whether a string is a valid theme color name
+ * @param str Text case-sensitive value
+ * @returns _true_ if `str` is a valid color name, otherwise _false_
+ */
+function isThemeColor(str) {
+    if (str) {
+        return Palette.indexOf(str) !== -1;
+    }
+    return false;
+}
+/**
+ * Whether a string is a valid rich or base theme color name.
+ * @param str Case-sensitive text value of the color name.
+ * @returns _true_ if `str` is a valid rich color name, otherwise _false_.
+ */
+function isRichThemeColor(str) {
+    if (str) {
+        if (isExtendedColor(str)) {
+            str = getBaseColor(str);
+        }
+        return isThemeColor(str);
+    }
+    return false;
+}
+/**
+ * Transforms a string to `ThemeColor` type.
+ * @param color Color value to transform
+ * @returns _ThemeColor_'s value or _undefined_, if the `color` has an invalid value.
+ */
+function toThemeColor(color) {
+    if (typeof color === "string") {
+        color = color.trim().toLowerCase();
+        if (isExtendedColor(color)) {
+            color = getBaseColor(color);
+        }
+        if (isThemeColor(color)) {
+            return color;
+        }
+    }
+    return undefined;
+}
+/**
+ * To `_RichThemeColor_` transformer function.
+ * @param color Color value to transform into rich color type.
+ * @returns _RichThemeColor_ value or _undefined_ if `color` is invalid.
+ */
+function toRichThemeColor(color) {
+    if (typeof color === "string") {
+        color = color.trim().toLowerCase();
+        if (isRichThemeColor(color)) {
+            return color;
+        }
+    }
+    return undefined;
+}
+/**
+ * Returns a valid Bootstrap's `.text-*` CSS class.
+ * @param color Color palette to transform into CSS-class.
+ */
+function toTextCssClass(color) {
+    const richThemeColor = toRichThemeColor(color);
+    if (richThemeColor) {
+        if (richThemeColor.startsWith("tertiary")) {
+            // Bootstrap 5 has no ".text-tertiary-*" classes, so we return following
+            return "text-body-tertiary";
+        }
+        let themeColor;
+        if (isExtendedColor(richThemeColor)) {
+            themeColor = getBaseColor(richThemeColor);
+            if (richThemeColor.endsWith("-emphasis")) {
+                return `text-${themeColor}-emphasis`;
+            }
+            // contrast
+            return `text-bg-${themeColor}`;
+        }
+        themeColor = richThemeColor;
+        return `text-${themeColor}`;
+    }
+    return "";
+}
+/**
+ * Returns a valid Bootstrap's `.bg-*` or `.text-bg-*` CSS class name.
+ * @param color Value to transform into CSS-class.
+ */
+function toBgCssClass(color) {
+    const richThemeColor = toRichThemeColor(color);
+    if (richThemeColor) {
+        if (richThemeColor.startsWith("tertiary")) {
+            // Bootstrap 5 has no 'tertiary-subtle'/'bg-tertiary' classes, so we return following
+            return "bg-body-tertiary";
+        }
+        let themeColor;
+        if (isExtendedColor(richThemeColor)) {
+            themeColor = getBaseColor(richThemeColor);
+            if (richThemeColor.endsWith("-emphasis")) {
+                return `bg-${themeColor}-subtle`;
+            }
+            // contrast
+            return `text-bg-${themeColor}`;
+        }
+        themeColor = richThemeColor;
+        // Simple background
+        return `bg-${themeColor}`;
+    }
+    return "";
+}
+/**
+ * Set a background color with contrasting foreground color.
+ * @param color Color palette to transform into CSS-class.
+ * @returns A valid Bootstrap's `.text-bg-*` CSS-class
+ */
+function toTextBgCssClass(color) {
+    const richThemeColor = toRichThemeColor(color);
+    if (richThemeColor) {
+        if (richThemeColor.startsWith("tertiary")) {
+            return "text-body-tertiary";
+        }
+        let themeColor;
+        if (isExtendedColor(richThemeColor)) {
+            themeColor = getBaseColor(richThemeColor);
+        }
+        else {
+            themeColor = richThemeColor;
+        }
+        return "text-bg-" + themeColor;
+    }
+    return "";
+}
+/**
+ * Returns a valid Bootstrap's `.text-*` or `.text-bg-*` CSS class.
+ * @param color Color value to transform into CSS-class.
+ */
+function toColorCssClass(color) {
+    if (color) {
+        if (color.endsWith("-contrast")) {
+            return toTextBgCssClass(color);
+        }
+        return toTextCssClass(color);
+    }
+    return "";
+}
+/**
+ * Extracts `ThemeColor` from the `RichThemeColor`.
+ * @param color Rich color
+ * @returns Base theme color.
+ * @internal
+ */
+function getBaseColor(color) {
+    let dashPos = color.indexOf("-");
+    if (dashPos >= 0) {
+        return color.slice(0, dashPos);
+    }
+    return color;
+}
+/** Whether the specified color is extended counterpart of the standard palette color. */
+function isExtendedColor(color) {
+    return color.endsWith("-emphasis") || color.endsWith("-contrast");
+}
+const CUTE_THEME_COLOR = new InjectionToken("CUTE_THEME_COLOR");
+class CuteThemeColor /* extends ... */ {
+    colorClass() {
+        return toColorCssClass(this.color);
+    }
+    bgClass() {
+        return toBgCssClass(this.color);
+    }
+    textBgClass() {
+        return toTextBgCssClass(this.color);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteThemeColor /* extends ... */, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.15", type: CuteThemeColor /* extends ... */, isStandalone: true, selector: "[cuteThemeColor]", inputs: { color: ["cuteThemeColor", "color"] }, providers: [{ provide: CUTE_THEME_COLOR, useExisting: CuteThemeColor }], exportAs: ["cuteThemeColor"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteThemeColor /* extends ... */, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cuteThemeColor]',
+                    exportAs: 'cuteThemeColor',
+                    host: {},
+                    providers: [{ provide: CUTE_THEME_COLOR, useExisting: CuteThemeColor }],
+                }]
+        }], propDecorators: { color: [{
+                type: Input,
+                args: ["cuteThemeColor"]
+            }] } });
+
+const PREFERS_COLOR_SCHEME = '(prefers-color-scheme: dark)';
+const THEME_ATTR_NAME = "data-bs-theme";
+class CuteThemeService {
+    constructor() {
+        this._document = inject(DOCUMENT);
+        this._mediaChange = new Subject();
+        /** Observable that can be used to receive `MediaMatcher`'s _change_ event. */
+        this.change = this._mediaChange.asObservable();
+        const mediaMatcher = inject(MediaMatcher);
+        this._mediaQueryList = mediaMatcher.matchMedia(PREFERS_COLOR_SCHEME);
+        fromEvent(this._mediaQueryList, "change")
+            .pipe(takeUntilDestroyed())
+            .subscribe(event => {
+            const storedTheme = this.getStoredTheme();
+            if (storedTheme !== 'light' && storedTheme !== 'dark') {
+                this.setTheme(this.getPreferredTheme(), false);
+            }
+            this._mediaChange.next(event);
+        });
+        fromEvent(window, "DOMContentLoaded")
+            .pipe(takeUntilDestroyed())
+            .subscribe(() => {
+            this.setTheme(this.getPreferredTheme());
+        });
+    }
+    getStoredTheme() {
+        const theme = localStorage.getItem('theme');
+        if (theme && ["light", "dark", "auto"].includes(theme)) {
+            return theme;
+        }
+        return null;
+    }
+    setStoredTheme(theme) {
+        return localStorage.setItem('theme', theme);
+    }
+    /** Returns the user's preferred color mode. */
+    getPreferredTheme() {
+        const storedTheme = this.getStoredTheme();
+        if (storedTheme) {
+            return storedTheme;
+        }
+        return this.getCurrentTheme();
+    }
+    /** Returns the browser's color theme. */
+    getCurrentTheme() {
+        return this._mediaQueryList.matches ? 'dark' : 'light';
+    }
+    /** Whether is the dark theme currently selected. */
+    isDarkTheme() {
+        return this.getTheme() == "dark";
+    }
+    /** Whether is the light theme currently selected. */
+    isLightTheme() {
+        return !this.isDarkTheme();
+    }
+    /** Returns the Bootstrap's color theme. */
+    getTheme() {
+        const docElem = this._document.documentElement;
+        let attrValue = docElem.getAttribute(THEME_ATTR_NAME);
+        if (attrValue == null) {
+            attrValue = this.getCurrentTheme();
+        }
+        return attrValue;
+    }
+    /**
+     * Changes the default color mode (theme) of all pages in the website with the opportunity of auto-detection.
+     * @param theme Desired color theme.
+     * @param emitEvent Emulate event emitting. Default is _true_.
+     */
+    setTheme(theme, emitEvent = true) {
+        const docElem = this._document.documentElement;
+        let matches;
+        if (theme === 'auto') {
+            matches = this._mediaQueryList.matches;
+            docElem.setAttribute(THEME_ATTR_NAME, (matches ? 'dark' : 'light'));
+        }
+        else {
+            matches = (theme === "dark");
+            docElem.setAttribute(THEME_ATTR_NAME, theme);
+        }
+        this.setStoredTheme(theme);
+        if (emitEvent) {
+            // dispatch artificial (not trusted) change event
+            this._mediaQueryList.dispatchEvent(new MediaQueryListEvent("change", { matches, media: this._mediaQueryList.media }));
+        }
+    }
+    ngOnDestroy() {
+        this._mediaChange.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteThemeService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }], ctorParameters: () => [] });
+
+/*
+ * Core API Surface of widgets
+ */
+//export * from './event-plugins';
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AnimationCurves, AnimationDurations, CUTE_DATE_FORMATS, CUTE_DATE_LOCALE, CUTE_DATE_LOCALE_FACTORY, CUTE_NATIVE_DATE_FORMATS, CUTE_THEME_COLOR, CUTE_WIDGETS_ANIMATIONS, CuteLine, CuteLineModule, CuteNativeDateModule, CuteRipple, CuteSafePipe, CuteSanitizePipe, CuteThemeColor, CuteThemeService, DateAdapter, IdGenerator, NativeDateAdapter, NativeDateModule, Ripple, RippleManager, Scheduler, _animationsDisabled, _getAnimationsState, bsBreakpoints, createFactoryToken, createValueToken, exportToCSV, exportToExcel, getOverallTransitionDuration, getTransitionDelay, getTransitionDuration, isRichThemeColor, isThemeColor, provideNativeDateAdapter, saveAs, setLines, toBgCssClass, toColorCssClass, toRichThemeColor, toTextBgCssClass, toTextCssClass, toThemeColor };
+//# sourceMappingURL=cute-widgets-base-core.mjs.map