@ardium-pl/devkit 8.3.2

package/fesm2022/ardium-pl-devkit.mjs

@@ -0,0 +1,3874 @@
+import * as i0 from '@angular/core';
+import { Injectable, inject, signal, computed, ElementRef, InjectionToken, output, Directive, HostListener, NgModule, Pipe, input, effect, model, untracked, Injector, runInInjectionContext, DestroyRef } from '@angular/core';
+import { isArray, isNumber, isNull, isAnyString, isFunction, isDefined } from 'simple-bool';
+import { HttpParams, HttpClient } from '@angular/common/http';
+import { Subject, map, filter, merge, throttleTime, debounceTime, BehaviorSubject, isObservable } from 'rxjs';
+import * as i1 from '@angular/platform-browser';
+import { CommonModule } from '@angular/common';
+import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
+import { Router, NavigationEnd } from '@angular/router';
+import { isFormControl, isFormArray, isFormGroup, isFormRecord, NgControl, ValueChangeEvent, TouchedChangeEvent, PristineChangeEvent, StatusChangeEvent, Validators } from '@angular/forms';
+import { diceCoefficient } from 'dice-coefficient';
+
+/**
+ * Enumeration of file system methods.
+ */
+const FileSystemMethod = {
+    /**
+     * Prefer using the File System Access API, or if not supported, use a cross-browser compatible method.
+     *
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_Access_API File System Access API}
+     */
+    PreferFileSystem: 'preferFileSystem',
+    /**
+     * Always use a cross-browser compatible method.
+     */
+    CrossBrowser: 'crossBrowser',
+};
+/**
+ * Enumeration of file system start directories.
+ */
+const FileSystemStartDirectory = {
+    /**
+     * Always start in the Desktop directory.
+     */
+    Desktop: 'desktop',
+    /**
+     * Always start in the Documents directory.
+     */
+    Documents: 'documents',
+    /**
+     * Always start in the Downloads directory.
+     */
+    Downloads: 'downloads',
+    /**
+     * Always start in the Music directory.
+     */
+    Music: 'music',
+    /**
+     * Always start in the Pictures directory.
+     */
+    Pictures: 'pictures',
+    /**
+     * Always start in the Videos directory.
+     */
+    Videos: 'videos',
+};
+
+const DEFAULT_SAVE_OPTIONS = {
+    fileName: 'download',
+    method: FileSystemMethod.PreferFileSystem,
+};
+const DEFAULT_REQUEST_OPTIONS = {
+    method: FileSystemMethod.PreferFileSystem,
+    multiple: false,
+};
+/**
+ * Service for handling file system operations, including saving, uploading, and reading files.
+ *
+ * This service leverages the File System Access API when available and falls back to traditional
+ * methods when necessary. It provides methods to check for API support, save files, request file uploads,
+ * and read file contents.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_Access_API File System Access API}
+ */
+class FileSystemService {
+    /**
+     * Checks if the File System Access API is supported for the specified method.
+     *
+     * @param method - The file system method to check ('showSaveFilePicker' or 'showOpenFilePicker').
+     * @returns True if the specified method is supported, otherwise false.
+     *
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_Access_API File System Access API}
+     */
+    isFileSystemAPISupported(method) {
+        try {
+            // isn't in an iframe && browser version is high enough
+            return window.self === window.top && method in window;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    //! saving files
+    /**
+     * Saves data as a file using the File System Access API or a fallback method.
+     *
+     * @param data - The data to be saved, either as a string or a Blob.
+     * @param options - Options for saving the file, such as file name and save method.
+     * @returns A promise that resolves to true if the file was saved successfully, otherwise false.
+     *
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_Access_API File System Access API}
+     */
+    async saveAs(data, options = {}) {
+        options = {
+            ...DEFAULT_SAVE_OPTIONS,
+            ...options,
+        };
+        // coerce string to blob if needed
+        if (typeof data == 'string') {
+            data = new Blob([data], {
+                type: 'text/plain',
+            });
+        }
+        // use the File System Access API if supported & preferred
+        if (options.method == FileSystemMethod.PreferFileSystem &&
+            this.isFileSystemAPISupported('showSaveFilePicker')) {
+            if (!options.types)
+                options.types = [];
+            // use the File System Access API
+            try {
+                const handle = await window.showSaveFilePicker({
+                    id: options.directoryId,
+                    startIn: options.startDirectory,
+                    suggestedName: options.fileName,
+                    types: options.types,
+                });
+                const writable = await handle.createWritable();
+                await writable.write(data);
+                await writable.close();
+                return true;
+            }
+            catch (err) {
+                // fail silently if the user has simply canceled the dialog.
+                const error = err;
+                if (error.name !== 'AbortError') {
+                    console.error(error.name, error.message);
+                }
+                return false;
+            }
+        }
+        // fallback if the File System Access API is not supported
+        // or the user doesn't want to use it
+        const blobURL = URL.createObjectURL(data);
+        const a = document.createElement('a');
+        a.href = blobURL;
+        a.download = options.fileName;
+        a.style.display = 'none';
+        document.body.appendChild(a);
+        a.click();
+        //remove the element from the DOM
+        return await new Promise((resolve) => setTimeout(() => {
+            URL.revokeObjectURL(blobURL);
+            document.body.removeChild(a);
+            resolve(true);
+        }, 1000));
+    }
+    //! opening files
+    /**
+     * Requests a file upload using the File System Access API or a fallback method.
+     *
+     * @param options - Options for requesting the file upload, such as accepted file types and method.
+     * @returns A promise that resolves to the selected file or files, or null if the operation was canceled.
+     *
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/File_System_Access_API File System Access API}
+     */
+    async requestFileUpload(options = {}) {
+        options = {
+            ...DEFAULT_REQUEST_OPTIONS,
+            ...options,
+        };
+        // use the File System Access API if supported & preferred
+        if (options.method == 'preferFileSystem' &&
+            this.isFileSystemAPISupported('showOpenFilePicker')) {
+            try {
+                // coerce the options.accept into a valid options.types object
+                if (options.accept) {
+                    if (typeof options.accept == 'string') {
+                        options.accept = options.accept.split(',');
+                    }
+                    for (const accept of options.accept) {
+                        if (!accept.match(/^\.[a-z0-9]+$/)) {
+                            throw new Error(`DKT-FT0010: "accept" property in FileSystemService must be a list of valid file extensions. Value "${accept}" is not a valid extension.`);
+                        }
+                    }
+                    if (!options.types)
+                        options.types = [];
+                    const accept = {
+                        'application/octet-stream': options.accept,
+                    };
+                    options.types.push({ accept: accept });
+                }
+                // open the dialog box
+                const handles = await window.showOpenFilePicker({
+                    id: options.directoryId,
+                    startIn: options.startDirectory,
+                    types: options.types,
+                    multiple: options.multiple,
+                });
+                const fileArray = (await Promise.all(handles.map(async (handle) => {
+                    const file = await handle.getFile();
+                    file.handle = handle;
+                    return file;
+                })));
+                if (!options.multiple) {
+                    return fileArray[0];
+                }
+                return fileArray;
+            }
+            catch (err) {
+                // fail silently if the user has simply canceled the dialog.
+                const error = err;
+                if (error.name !== 'AbortError') {
+                    console.error(error.name, error.message);
+                }
+                return null;
+            }
+        }
+        // fallback if the File System Access API is not supported
+        // or the user doesn't want to use it
+        // coerce options.accept into a string
+        if (isArray(options.accept)) {
+            options.accept = options.accept.join(',');
+        }
+        else {
+            options.accept = options.accept ?? '*';
+        }
+        const input = document.createElement('input');
+        input.type = 'file';
+        input.accept = options.accept;
+        input.multiple = options.multiple ?? false;
+        input.style.display = 'none';
+        document.body.appendChild(input);
+        input.click();
+        const fileArray = await new Promise((resolve) => {
+            input.onchange = () => {
+                resolve(input.files && input.files.length > 0
+                    ? Array.from(input.files)
+                    : null);
+                document.body.removeChild(input);
+            };
+        });
+        if (options.multiple || !fileArray) {
+            return fileArray;
+        }
+        return fileArray[0];
+    }
+    async readFile(file, readAs = 'text', encoding = 'UTF-8') {
+        if (readAs == 'text') {
+            return new Promise((resolve) => {
+                const reader = new FileReader();
+                reader.readAsText(file, encoding);
+                reader.onload = function (e) {
+                    resolve(e.target.result);
+                };
+            });
+        }
+        return new Promise((resolve) => {
+            const reader = new FileReader();
+            reader.readAsArrayBuffer(file);
+            reader.onload = function (e) {
+                resolve(e.target.result);
+            };
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: FileSystemService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: FileSystemService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: FileSystemService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+function normalizePath(input) {
+    if (!Array.isArray(input)) {
+        input = input.trim();
+        return input.replace(/\/\/+$/g, "/");
+    }
+    return input
+        .filter(Boolean)
+        .map((part, index) => {
+        if (index === 0) {
+            return part.replace(/\/+$/g, "");
+        }
+        return part.replace(/^\/+|\/+$/g, "");
+    })
+        .join("/")
+        .replace(/\/\/+/g, "/");
+}
+
+const FAULTY_URL_REGEX = /https?:\/\//;
+function getUrl(apiUrl, url) {
+    url = normalizePath(url);
+    const finalUrl = apiUrl + url.replace(/^\//, '');
+    if (FAULTY_URL_REGEX.test(url)) {
+        console.warn(`DKT-WA0020: The url "${url}" passed into custom HTTP Service seems to be faulty, as it would produce a request to "${finalUrl}". Custom HTTP Service instances prepend an API url, and thus only accept relative url paths.`);
+    }
+    return finalUrl;
+}
+function getOpts(defaultOptions, options) {
+    return { ...defaultOptions, ...(options ?? {}) };
+}
+function convertToHttpParams(params) {
+    if (params instanceof HttpParams || !params) {
+        return params;
+    }
+    let httpParams = new HttpParams();
+    for (const key of Object.keys(params)) {
+        const value = params[key];
+        if (value == null) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            value.forEach((item) => {
+                httpParams = httpParams.append(key, item.toString());
+            });
+        }
+        else {
+            httpParams = httpParams.append(key, value.toString());
+        }
+    }
+    return httpParams;
+}
+function createHttpService(apiUrl, defaultOptions = {}) {
+    let http;
+    return class {
+        constructor() {
+            this.apiUrl = apiUrl;
+            http = inject(HttpClient);
+        }
+        request(methodOrReq, url, options) {
+            if (typeof methodOrReq === 'string') {
+                const finalUrl = getUrl(apiUrl, url);
+                const finalOptions = getOpts(defaultOptions, options);
+                if (finalOptions.params) {
+                    finalOptions.params = convertToHttpParams(finalOptions.params);
+                }
+                return http.request(methodOrReq, finalUrl, finalOptions);
+            }
+            return http.request(methodOrReq);
+        }
+        delete(url, options) {
+            const finalUrl = getUrl(apiUrl, url);
+            const finalOptions = getOpts(defaultOptions, options);
+            if (finalOptions.params) {
+                finalOptions.params = convertToHttpParams(finalOptions.params);
+            }
+            return http.delete(finalUrl, finalOptions);
+        }
+        get(url, options) {
+            const finalUrl = getUrl(apiUrl, url);
+            const finalOptions = getOpts(defaultOptions, options);
+            if (finalOptions.params) {
+                finalOptions.params = convertToHttpParams(finalOptions.params);
+            }
+            return http.get(finalUrl, finalOptions);
+        }
+        head(url, options) {
+            const finalUrl = getUrl(apiUrl, url);
+            const finalOptions = getOpts(defaultOptions, options);
+            if (finalOptions.params) {
+                finalOptions.params = convertToHttpParams(finalOptions.params);
+            }
+            return http.head(finalUrl, finalOptions);
+        }
+        jsonp(url, callbackParam) {
+            url = getUrl(apiUrl, url);
+            return http.jsonp(url, callbackParam);
+        }
+        options(url, options) {
+            const finalUrl = getUrl(apiUrl, url);
+            const finalOptions = getOpts(defaultOptions, options);
+            if (finalOptions.params) {
+                finalOptions.params = convertToHttpParams(finalOptions.params);
+            }
+            return http.options(finalUrl, finalOptions);
+        }
+        patch(url, body, options) {
+            const finalUrl = getUrl(apiUrl, url);
+            const finalOptions = getOpts(defaultOptions, options);
+            if (finalOptions.params) {
+                finalOptions.params = convertToHttpParams(finalOptions.params);
+            }
+            return http.patch(finalUrl, body, finalOptions);
+        }
+        post(url, body, options) {
+            const finalUrl = getUrl(apiUrl, url);
+            const finalOptions = getOpts(defaultOptions, options);
+            if (finalOptions.params) {
+                finalOptions.params = convertToHttpParams(finalOptions.params);
+            }
+            return http.post(finalUrl, body, finalOptions);
+        }
+        put(url, body, options) {
+            const finalUrl = getUrl(apiUrl, url);
+            const finalOptions = getOpts(defaultOptions, options);
+            if (finalOptions.params) {
+                finalOptions.params = convertToHttpParams(finalOptions.params);
+            }
+            return http.put(finalUrl, body, finalOptions);
+        }
+    };
+}
+
+const _ExpectedModifierKeySide = {
+    None: 'none',
+    Left: 'left',
+    Right: 'right',
+    Any: 'any',
+};
+
+function trySettingModifierKey(modifierKeyName, keyCode, rawKeyCode, previouslyFoundKeyCode, currentKeyState) {
+    if (keyCode === modifierKeyName) {
+        if (previouslyFoundKeyCode) {
+            console.error(new Error(`DKT-NF0030: A keyboard shortcut definition cannot contain two modifier keys of the same type. Got "${previouslyFoundKeyCode}" and "${rawKeyCode}"; only the first one will be included.`));
+            return [currentKeyState, previouslyFoundKeyCode, true];
+        }
+        return [_ExpectedModifierKeySide.Any, keyCode, true];
+    }
+    if (keyCode === modifierKeyName + 'left') {
+        if (previouslyFoundKeyCode) {
+            console.error(new Error(`DKT-NF0030: A keyboard shortcut definition cannot contain two modifier keys of the same type. Got "${previouslyFoundKeyCode}" and "${rawKeyCode}"; only the first one will be included.`));
+            return [currentKeyState, previouslyFoundKeyCode, true];
+        }
+        return [_ExpectedModifierKeySide.Left, keyCode, true];
+    }
+    if (keyCode === modifierKeyName + 'right') {
+        if (previouslyFoundKeyCode) {
+            console.error(new Error(`DKT-NF0030: A keyboard shortcut definition cannot contain two modifier keys of the same type. Got "${previouslyFoundKeyCode}" and "${rawKeyCode}"; only the first one will be included.`));
+            return [currentKeyState, previouslyFoundKeyCode, true];
+        }
+        return [_ExpectedModifierKeySide.Right, keyCode, true];
+    }
+    return [currentKeyState, previouslyFoundKeyCode, false];
+}
+function isModifierKeyInWrongState(state, expectedState) {
+    if (expectedState === _ExpectedModifierKeySide.Any)
+        return !state.left && !state.right;
+    let expectedLeft = false, expectedRight = false;
+    switch (expectedState) {
+        case _ExpectedModifierKeySide.None:
+            break;
+        case _ExpectedModifierKeySide.Left:
+            expectedLeft = true;
+            break;
+        case _ExpectedModifierKeySide.Right:
+            expectedRight = true;
+            break;
+    }
+    return expectedLeft !== state.left || expectedRight !== state.right;
+}
+
+class KeyboardService {
+    constructor(rendererFactory) {
+        this._isLeftCtrlHeld = signal(false);
+        this._isRightCtrlHeld = signal(false);
+        this.isLeftCtrlHeld = this._isLeftCtrlHeld.asReadonly();
+        this.isRightCtrlHeld = this._isRightCtrlHeld.asReadonly();
+        this.isCtrlHeld = computed(() => this._isLeftCtrlHeld() || this._isRightCtrlHeld());
+        this._isLeftAltHeld = signal(false);
+        this._isRightAltHeld = signal(false);
+        this.isAltHeld = this._isLeftAltHeld.asReadonly();
+        this.isAltGraphHeld = this._isRightAltHeld.asReadonly();
+        this._isLeftShiftHeld = signal(false);
+        this._isRightShiftHeld = signal(false);
+        this.isLeftShiftHeld = this._isLeftShiftHeld.asReadonly();
+        this.isRightShiftHeld = this._isRightShiftHeld.asReadonly();
+        this.isShiftHeld = computed(() => this._isLeftShiftHeld() || this._isRightShiftHeld());
+        // "⊞ Win" on Windows, "⌘ Command" on Mac
+        this._isLeftMetaHeld = signal(false);
+        this._isRightMetaHeld = signal(false);
+        this.isLeftMetaHeld = this._isLeftMetaHeld.asReadonly();
+        this.isRightMetaHeld = this._isRightMetaHeld.asReadonly();
+        this.isMetaHeld = computed(() => this._isLeftMetaHeld() || this._isRightMetaHeld());
+        this.isAnyModifierKeyHeld = computed(() => this.isCtrlHeld() ||
+            this.isAltHeld() ||
+            this.isAltGraphHeld() ||
+            this.isShiftHeld() ||
+            this.isMetaHeld());
+        this._capsLockState = signal(undefined);
+        this.capsLockState = this._capsLockState.asReadonly();
+        this._numLockState = signal(undefined);
+        this.numLockState = this._numLockState.asReadonly();
+        this._scrollLockState = signal(undefined);
+        this.scrollLockState = this._scrollLockState.asReadonly();
+        //! key subjects
+        this._shortcutSubject$ = new Subject();
+        this.anyShortcut$ = this._shortcutSubject$.pipe(map((v) => v.publicData));
+        this._keySubject$ = new Subject();
+        this.anyKeyPress$ = this._keySubject$.asObservable();
+        this._keyStateSubject$ = new Subject();
+        this.anyKeyState$ = this._keyStateSubject$.asObservable();
+        this._KEY_CODE_SIGNALS_MAP = new Map([
+            ['ControlLeft', this._isLeftCtrlHeld],
+            ['ControlRight', this._isRightCtrlHeld],
+            ['AltLeft', this._isLeftAltHeld],
+            ['AltRight', this._isRightAltHeld],
+            ['ShiftLeft', this._isLeftShiftHeld],
+            ['ShiftRight', this._isRightShiftHeld],
+            ['MetaLeft', this._isLeftMetaHeld],
+            ['MetaRight', this._isRightMetaHeld],
+        ]);
+        this.renderer = rendererFactory.createRenderer(null, null);
+        //listen to events
+        this.removeListenFuncKeydown = this.renderer.listen('document', 'keydown', (e) => this._onKeydown(e));
+        this.removeListenFuncKeyup = this.renderer.listen('document', 'keyup', (e) => this._onKeyup(e));
+        this.removeListenFuncWindowblur = this.renderer.listen('window', 'blur', () => this._resetAllKeys());
+    }
+    ngOnDestroy() {
+        //destroy event listeners
+        this.removeListenFuncKeydown();
+        this.removeListenFuncKeyup();
+        this.removeListenFuncWindowblur();
+    }
+    _resetAllKeys() {
+        this._isLeftCtrlHeld.set(false);
+        this._isRightCtrlHeld.set(false);
+        this._isLeftAltHeld.set(false);
+        this._isRightAltHeld.set(false);
+        this._isLeftShiftHeld.set(false);
+        this._isRightShiftHeld.set(false);
+        this._isLeftMetaHeld.set(false);
+        this._isRightMetaHeld.set(false);
+    }
+    _demapKeyCode(code) {
+        code = code.replace(/[^a-z0-9]/gi, '').toLowerCase();
+        if (code.match(/^(left|right|up|down)$/))
+            return `Arrow${code.charAt(0).toUpperCase()}${code.substring(1)}`;
+        if (code.match(/^[a-z]$/))
+            return `Key${code.toUpperCase()}`;
+        if (code.match(/^\d$/))
+            return `Digit${code}`;
+        if (code === 'ctrl')
+            return 'control';
+        if (code === 'ctrlleft')
+            return 'controlleft';
+        if (code === 'alt')
+            return 'altleft';
+        if (code.match(/^altgr(aph)?$/))
+            return 'altright';
+        if (code.match(/^win(dows)?$/))
+            return 'meta';
+        if (code === 'cmd')
+            return 'meta';
+        return code;
+    }
+    _emitShortcut(event) {
+        const keys = [];
+        if (this._isLeftCtrlHeld())
+            keys.push('ControlLeft');
+        if (this._isRightCtrlHeld())
+            keys.push('ControlRight');
+        if (this._isLeftAltHeld())
+            keys.push('AltLeft');
+        if (this._isRightAltHeld())
+            keys.push('AltRight');
+        if (this._isLeftShiftHeld())
+            keys.push('ShiftLeft');
+        if (this._isRightShiftHeld())
+            keys.push('ShiftRight');
+        if (this._isLeftMetaHeld())
+            keys.push('MetaLeft');
+        if (this._isRightMetaHeld())
+            keys.push('MetaRight');
+        keys.push(event.code);
+        this._shortcutSubject$.next({
+            ctrl: {
+                left: this._isLeftCtrlHeld(),
+                right: this._isRightCtrlHeld(),
+            },
+            alt: {
+                left: this._isLeftAltHeld(),
+                right: this._isRightAltHeld(),
+            },
+            shift: {
+                left: this._isLeftShiftHeld(),
+                right: this._isRightShiftHeld(),
+            },
+            meta: {
+                left: this._isLeftMetaHeld(),
+                right: this._isRightMetaHeld(),
+            },
+            key: event.code.toLowerCase(),
+            publicData: {
+                keys,
+                event,
+            },
+        });
+    }
+    _emitKeydown(event) {
+        const key = event.code;
+        this._keySubject$.next({ key, event });
+    }
+    _emitKeyStateDown(event) {
+        const key = event.code;
+        this._keyStateSubject$.next({ key, event, isHeld: true });
+    }
+    _emitKeyStateUp(event) {
+        const key = event.code;
+        this._keyStateSubject$.next({ key, event, isHeld: false });
+    }
+    listenToShortcut(toMatch, treatAltGraphAsAltPlusCtrl = true) {
+        const expectedStates = {
+            ctrl: _ExpectedModifierKeySide.None,
+            alt: _ExpectedModifierKeySide.None,
+            shift: _ExpectedModifierKeySide.None,
+            meta: _ExpectedModifierKeySide.None,
+        };
+        let ctrlKey = null;
+        let altKey = null;
+        let isAltGraphExpected = false;
+        let shiftKey = null;
+        let metaKey = null;
+        let expectedKey = null;
+        let success = false;
+        for (const rawKey of toMatch) {
+            const key = this._demapKeyCode(rawKey).toLowerCase();
+            success = false;
+            [expectedStates.ctrl, ctrlKey, success] = trySettingModifierKey('control', key, rawKey, ctrlKey, expectedStates.ctrl);
+            if (success)
+                continue;
+            [expectedStates.alt, altKey, success] = trySettingModifierKey('alt', key, rawKey, altKey, expectedStates.alt);
+            if (key === 'altright') {
+                isAltGraphExpected = true;
+            }
+            if (success)
+                continue;
+            [expectedStates.shift, shiftKey, success] = trySettingModifierKey('shift', key, rawKey, shiftKey, expectedStates.shift);
+            if (success)
+                continue;
+            [expectedStates.meta, metaKey, success] = trySettingModifierKey('meta', key, rawKey, metaKey, expectedStates.meta);
+            if (success)
+                continue;
+            if (expectedKey) {
+                console.error(new Error(`DKT-NF0031: A keyboard shortcut definition cannot contain two final keys. Got "${expectedKey}" and "${rawKey}"; only the first one will be included.`));
+                break;
+            }
+            expectedKey = key;
+        }
+        if (treatAltGraphAsAltPlusCtrl && isAltGraphExpected) {
+            if (expectedStates.ctrl === _ExpectedModifierKeySide.Right) {
+                console.error(new Error(`DKT-NF0032: A keyboard shortcut definition that treats AltGraph as Alt+Ctrl cannot expect the user to press AltGraph and ControlRight keys (while not pressing ControlLeft), as pressing AltGraph automatically presses ControlLeft.`));
+            }
+            expectedStates.ctrl = _ExpectedModifierKeySide.Left;
+        }
+        return this._shortcutSubject$.pipe(filter((shortcut) => {
+            if (isModifierKeyInWrongState(shortcut.ctrl, expectedStates.ctrl))
+                return false;
+            if (isModifierKeyInWrongState(shortcut.alt, expectedStates.alt))
+                return false;
+            if (isModifierKeyInWrongState(shortcut.shift, expectedStates.shift))
+                return false;
+            if (isModifierKeyInWrongState(shortcut.meta, expectedStates.meta))
+                return false;
+            if (shortcut.key !== expectedKey)
+                return false;
+            return true;
+        }), map((v) => v.publicData));
+    }
+    listenToKey(code) {
+        const keyStr = this._demapKeyCode(code);
+        return this.anyKeyPress$.pipe(filter((key) => key.key == keyStr));
+    }
+    listenToKeyState(code) {
+        const keyStr = this._demapKeyCode(code);
+        return this.anyKeyState$.pipe(filter((key) => key.key == keyStr));
+    }
+    _onKeydown(event) {
+        let wasModifierKey = false;
+        const modifierSignal = this._KEY_CODE_SIGNALS_MAP.get(event.code);
+        if (modifierSignal) {
+            wasModifierKey = true;
+            modifierSignal.set(true);
+        }
+        this._updateLockKeyStates(event);
+        this._emitKeyStateDown(event);
+        if (!wasModifierKey && this.isAnyModifierKeyHeld()) {
+            this._emitShortcut(event);
+        }
+        else
+            this._emitKeydown(event);
+    }
+    _updateLockKeyStates(event) {
+        this._capsLockState.set(event.getModifierState?.('CapsLock'));
+        this._numLockState.set(event.getModifierState?.('NumLock'));
+        this._scrollLockState.set(event.getModifierState?.('ScrollLock'));
+    }
+    _onKeyup(event) {
+        const modifierSignal = this._KEY_CODE_SIGNALS_MAP.get(event.code);
+        modifierSignal?.set(false);
+        this._emitKeyStateUp(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: KeyboardService, deps: [{ token: i1.ɵDomRendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: KeyboardService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: KeyboardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ɵDomRendererFactory2 }] });
+
+/**
+ * Custom RxJS operator that throttles incoming values but saves the last one when (emitted when the throttle duration ends). A combination of throttleTime and debounceTime.
+ * @param duration the throttle duration
+ * @returns an RxJS operator function
+ */
+function throttleSaveLast(duration) {
+    return (source) => merge(source.pipe(throttleTime(duration)), source.pipe(debounceTime(duration))).pipe(throttleTime(0, undefined, { leading: true, trailing: false }));
+}
+
+var ViewportRelation;
+(function (ViewportRelation) {
+    ViewportRelation["Above"] = "above";
+    ViewportRelation["PartiallyAbove"] = "partially-above";
+    ViewportRelation["Inside"] = "inside";
+    ViewportRelation["PartiallyBelow"] = "partially-below";
+    ViewportRelation["Below"] = "below";
+    ViewportRelation["InsideButTooLarge"] = "inside-too-large";
+    ViewportRelation["Undefined"] = "undefined";
+})(ViewportRelation || (ViewportRelation = {}));
+class ViewportMargins {
+    constructor(margin) {
+        this.top = signal(0);
+        this.bottom = signal(0);
+        if (isNumber(margin)) {
+            this.top.set(margin);
+            this.bottom.set(margin);
+            return;
+        }
+        this.top.set(margin?.top ?? 0);
+        this.bottom.set(margin?.bottom ?? 0);
+    }
+}
+class ArdViewportObserverRef {
+    constructor(element, update$, config) {
+        this.update$ = update$;
+        this._rawPosition = signal(undefined);
+        this.position = computed(() => {
+            const pos = this._rawPosition();
+            if (!pos)
+                return undefined;
+            return {
+                top: pos.top - this._margins.top(),
+                bottom: window.innerHeight - pos.bottom - this._margins.bottom(),
+            };
+        });
+        this.viewportRelation = computed(() => this._getNewRelation(this._rawPosition()));
+        this.isInViewport = computed(() => this.viewportRelation() === ViewportRelation.Undefined
+            ? undefined
+            : this.viewportRelation() === ViewportRelation.Inside ||
+                this.viewportRelation() === ViewportRelation.PartiallyAbove ||
+                this.viewportRelation() === ViewportRelation.PartiallyBelow);
+        this._isDestroyed = signal(false);
+        this.isDestroyed = this._isDestroyed.asReadonly();
+        this.element =
+            element instanceof ElementRef ? element.nativeElement : element;
+        setTimeout(() => {
+            this._updateViewportRelation();
+        }, 0);
+        this._throttleTime = config.throttleTime;
+        this._margins = new ViewportMargins(config.margin);
+        this.margins = {
+            top: this._margins.top.asReadonly(),
+            bottom: this._margins.bottom.asReadonly(),
+        };
+        this._scrollSubscription = this.update$
+            .pipe(throttleSaveLast(this._throttleTime))
+            .subscribe(() => this._updateViewportRelation());
+    }
+    _updateViewportRelation() {
+        const rect = this.element.getBoundingClientRect();
+        this._rawPosition.set({
+            top: rect.top,
+            bottom: rect.bottom,
+        });
+    }
+    _getNewRelation(rect) {
+        if (!rect)
+            return undefined;
+        const topThreshold = this._margins.top();
+        if (rect.bottom <= topThreshold) {
+            return ViewportRelation.Above;
+        }
+        if (rect.bottom > topThreshold && rect.top < topThreshold) {
+            return ViewportRelation.PartiallyAbove;
+        }
+        const bottomThreshold = window.innerHeight - this._margins.bottom();
+        if (rect.top > topThreshold && rect.bottom > bottomThreshold) {
+            return ViewportRelation.InsideButTooLarge;
+        }
+        if (rect.top < bottomThreshold && rect.bottom > bottomThreshold) {
+            return ViewportRelation.PartiallyBelow;
+        }
+        if (rect.top >= bottomThreshold) {
+            return ViewportRelation.Below;
+        }
+        return ViewportRelation.Inside;
+    }
+    recheck() {
+        this._updateViewportRelation();
+    }
+    destroy() {
+        if (this.isDestroyed())
+            return;
+        this._isDestroyed.set(true);
+        this._scrollSubscription.unsubscribe();
+    }
+    setMargin(top, bottom = top) {
+        this._margins.top.set(top);
+        this._margins.bottom.set(bottom);
+        this._updateViewportRelation();
+        return this;
+    }
+}
+
+const _viewportObserverDefaults = {
+    margin: 0,
+    throttleTime: 100,
+};
+const ARD_VIEWPORT_OBSERVER_DEFAULTS = new InjectionToken('ard-viewport-observer-defaults', {
+    factory: () => ({
+        ..._viewportObserverDefaults,
+    }),
+});
+function provideViewportObserverDefaults(config) {
+    return {
+        provide: ARD_VIEWPORT_OBSERVER_DEFAULTS,
+        useValue: { ..._viewportObserverDefaults, ...config },
+    };
+}
+
+class ArdiumViewportObserverService {
+    constructor(rendererFactory) {
+        this._lastWindowHeight = window.innerHeight;
+        this._DEFAULTS = inject(ARD_VIEWPORT_OBSERVER_DEFAULTS);
+        this._scrollOrResizeSubject = new Subject();
+        this.scrollOrResize$ = this._scrollOrResizeSubject.asObservable();
+        this._registeredObservers = [];
+        this.renderer = rendererFactory.createRenderer(null, null);
+        this.setScrollHost(document);
+        this._resizeCleanupFn = this.renderer.listen(window, 'resize', () => {
+            window.innerHeight !== this._lastWindowHeight &&
+                this._scrollOrResizeSubject.next();
+        });
+    }
+    setScrollHost(element) {
+        this._cleanupObservers();
+        this._scrollCleanupFn = this.renderer.listen(element, 'scroll', () => this._scrollOrResizeSubject.next());
+    }
+    observeElement(element, config) {
+        const finalConfig = { ...this._DEFAULTS, ...(config ?? {}) };
+        const vo = new ArdViewportObserverRef(element, this.scrollOrResize$, finalConfig);
+        this._registeredObservers.push(vo);
+        return vo;
+    }
+    observeById(id, config) {
+        const element = document.getElementById(id);
+        if (!element) {
+            throw new Error(`DKT-NF0001: Trying to observe an element by id, but the element with id "${id}" does not exist.`);
+        }
+        return this.observeElement(element, config);
+    }
+    observeByQuery(query, config) {
+        const element = document.querySelector(query);
+        if (!element) {
+            throw new Error(`DKT-NF0002: Trying to observe an element by query, but no element matching "${query}" exists.`);
+        }
+        return this.observeElement(element, config);
+    }
+    recheckAll() {
+        this._scrollOrResizeSubject.next();
+    }
+    _cleanupObservers() {
+        this._scrollCleanupFn?.();
+        this._registeredObservers.forEach((obs) => obs.destroy());
+    }
+    ngOnDestroy() {
+        this._cleanupObservers();
+        this._resizeCleanupFn?.();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumViewportObserverService, deps: [{ token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumViewportObserverService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumViewportObserverService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i0.RendererFactory2 }] });
+
+/**
+  Detects when the user clicks outside a given element.
+
+  @license
+  Shamelessly stolen from [Christian Liebel](https://github.com/chliebel/angular2-click-outside)
+*/
+class ArdiumClickOutsideDirective {
+    constructor() {
+        this._elementRef = inject(ElementRef);
+        this.ardClickOutside = output();
+    }
+    onClick(event, target) {
+        if (!target)
+            return;
+        const hostContainsTarget = this._elementRef.nativeElement.contains(target);
+        if (!hostContainsTarget) {
+            this.ardClickOutside.emit(event);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumClickOutsideDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.5", type: ArdiumClickOutsideDirective, isStandalone: false, selector: "[ardClickOutside]", outputs: { ardClickOutside: "ardClickOutside" }, host: { listeners: { "document:mousedown": "onClick($event,$event.target)", "document:touchstart": "onClick($event,$event.target)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumClickOutsideDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[ardClickOutside]', standalone: false }]
+        }], propDecorators: { onClick: [{
+                type: HostListener,
+                args: ['document:mousedown', ['$event', '$event.target']]
+            }, {
+                type: HostListener,
+                args: ['document:touchstart', ['$event', '$event.target']]
+            }] } });
+
+class ArdiumClickOutsideModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumClickOutsideModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: ArdiumClickOutsideModule, declarations: [ArdiumClickOutsideDirective], imports: [CommonModule], exports: [ArdiumClickOutsideDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumClickOutsideModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumClickOutsideModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ArdiumClickOutsideDirective],
+                    imports: [CommonModule],
+                    exports: [ArdiumClickOutsideDirective],
+                }]
+        }] });
+
+const UNESCAPED_HTML_REGEX = /[&<>"']/g;
+const HTML_ESCAPES = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+};
+function escapeHTML(value) {
+    if (!value || !UNESCAPED_HTML_REGEX.test(value))
+        return value;
+    return value.replace(UNESCAPED_HTML_REGEX, (chr) => HTML_ESCAPES[chr]);
+}
+
+class ArdiumEscapeHTMLPipe {
+    transform(value) {
+        return escapeHTML(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumEscapeHTMLPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: ArdiumEscapeHTMLPipe, isStandalone: false, name: "escapeHTML" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumEscapeHTMLPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'escapeHTML',
+                    standalone: false,
+                }]
+        }] });
+
+class ArdiumEscapeHTMLModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumEscapeHTMLModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: ArdiumEscapeHTMLModule, declarations: [ArdiumEscapeHTMLPipe], imports: [CommonModule], exports: [ArdiumEscapeHTMLPipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumEscapeHTMLModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumEscapeHTMLModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ArdiumEscapeHTMLPipe],
+                    imports: [CommonModule],
+                    exports: [ArdiumEscapeHTMLPipe],
+                }]
+        }] });
+
+const _holdDefaults = {
+    delay: 500,
+    repeat: 1000 / 15,
+    allowSpaceKey: false,
+    allowEnterKey: false,
+};
+const ARD_HOLD_DEFAULTS = new InjectionToken('ard-hold-defaults', {
+    factory: () => ({
+        ..._holdDefaults,
+    }),
+});
+function provideHoldDefaults(config) {
+    return {
+        provide: ARD_HOLD_DEFAULTS,
+        useValue: { ..._holdDefaults, ...config },
+    };
+}
+
+/** Coerces a data-bound value (typically a string) to a boolean. */
+function coerceBooleanProperty(value) {
+    return value != null && `${value}` !== 'false';
+}
+
+function coerceNumberProperty(value, fallbackValue = undefined) {
+    return _isNumberValue(value) ? Number(value) : fallbackValue;
+}
+/**
+ * Whether the provided value is considered a number.
+ */
+function _isNumberValue(value) {
+    return !isNaN(parseFloat(value)) && !isNaN(Number(value));
+}
+
+/**
+ * Detects when the user clicks-and-holds a given element.
+ */
+class ArdiumHoldDirective {
+    constructor() {
+        this._DEFAULTS = inject(ARD_HOLD_DEFAULTS);
+        this.ardHold = output();
+        this.ardHoldDisabled = input(false, {
+            transform: (v) => coerceBooleanProperty(v),
+        });
+        this.ardHoldDelay = input(this._DEFAULTS.delay, {
+            transform: (v) => coerceNumberProperty(v, this._DEFAULTS.delay),
+        });
+        this.ardHoldRepeat = input(this._DEFAULTS.repeat, {
+            transform: (v) => coerceNumberProperty(v, this._DEFAULTS.repeat),
+        });
+        this.ardAllowSpaceKey = input(this._DEFAULTS.allowSpaceKey, {
+            transform: (v) => coerceBooleanProperty(v),
+        });
+        this.ardAllowEnterKey = input(this._DEFAULTS.allowEnterKey, {
+            transform: (v) => coerceBooleanProperty(v),
+        });
+        this.interval = null;
+        this.timeout = null;
+        this.isKeyDown = false;
+        effect(() => {
+            if (this.ardHoldDisabled()) {
+                this._clear();
+            }
+        });
+    }
+    onMouseDown() {
+        if (this.ardHoldDisabled())
+            return;
+        this.timeout = setTimeout(() => {
+            this.timeout = null;
+            this.interval = setInterval(() => {
+                this.ardHold.emit();
+            }, this.ardHoldRepeat());
+        }, this.ardHoldDelay());
+    }
+    onMouseUp() {
+        this._clear();
+    }
+    _clear() {
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+            this.timeout = null;
+            return;
+        }
+        if (!this.interval)
+            return;
+        clearInterval(this.interval);
+        this.interval = null;
+    }
+    onKeyDown(event) {
+        if (this.ardAllowEnterKey() && event.code == 'Enter') {
+            event.preventDefault();
+        }
+        if (this.isKeyDown)
+            return;
+        if ((this.ardAllowSpaceKey() && event.code == 'Space') ||
+            (this.ardAllowEnterKey() && event.code == 'Enter')) {
+            this.onMouseDown();
+            this.isKeyDown = true;
+        }
+    }
+    onKeyUp(event) {
+        if ((this.ardAllowSpaceKey() && event.code == 'Space') ||
+            (this.ardAllowEnterKey() && event.code == 'Enter')) {
+            this.onMouseUp();
+            this.isKeyDown = false;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumHoldDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.0.5", type: ArdiumHoldDirective, isStandalone: false, selector: "[ardHold]", inputs: { ardHoldDisabled: { classPropertyName: "ardHoldDisabled", publicName: "ardHoldDisabled", isSignal: true, isRequired: false, transformFunction: null }, ardHoldDelay: { classPropertyName: "ardHoldDelay", publicName: "ardHoldDelay", isSignal: true, isRequired: false, transformFunction: null }, ardHoldRepeat: { classPropertyName: "ardHoldRepeat", publicName: "ardHoldRepeat", isSignal: true, isRequired: false, transformFunction: null }, ardAllowSpaceKey: { classPropertyName: "ardAllowSpaceKey", publicName: "ardAllowSpaceKey", isSignal: true, isRequired: false, transformFunction: null }, ardAllowEnterKey: { classPropertyName: "ardAllowEnterKey", publicName: "ardAllowEnterKey", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { ardHold: "ardHold" }, host: { listeners: { "mousedown": "onMouseDown()", "touchstart": "onMouseDown()", "document:mouseup": "onMouseUp()", "document:touchend": "onMouseUp()", "keydown": "onKeyDown($event)", "keyup": "onKeyUp($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumHoldDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[ardHold]', standalone: false }]
+        }], ctorParameters: () => [], propDecorators: { onMouseDown: [{
+                type: HostListener,
+                args: ['mousedown']
+            }, {
+                type: HostListener,
+                args: ['touchstart']
+            }], onMouseUp: [{
+                type: HostListener,
+                args: ['document:mouseup']
+            }, {
+                type: HostListener,
+                args: ['document:touchend']
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }], onKeyUp: [{
+                type: HostListener,
+                args: ['keyup', ['$event']]
+            }] } });
+
+class ArdiumHoldModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumHoldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: ArdiumHoldModule, declarations: [ArdiumHoldDirective], imports: [CommonModule], exports: [ArdiumHoldDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumHoldModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumHoldModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ArdiumHoldDirective],
+                    imports: [CommonModule],
+                    exports: [ArdiumHoldDirective],
+                }]
+        }] });
+
+const ArdInfScrollTarget = {
+    Host: 'host',
+    HTML: 'html',
+};
+class ArdiumInfiniteScrollDirective {
+    _getElementRect() {
+        return this.elementRef.nativeElement.getBoundingClientRect();
+    }
+    _getElementScrollTop() {
+        return this.elementRef.nativeElement.scrollTop;
+    }
+    _getElementScrollHeight() {
+        return this.elementRef.nativeElement.scrollHeight;
+    }
+    constructor() {
+        this.elementRef = inject(ElementRef);
+        this._DEFAULTS = inject(ARD_INFINITE_SCROLL_DEFAULTS);
+        this.ardInfScrollReachThreshold = output();
+        //! options
+        this.ardInfScrollThreshold = input(this._DEFAULTS.threshold, {
+            transform: (v) => coerceNumberProperty(v, this._DEFAULTS.threshold),
+        });
+        this.ardInfScrollActive = model(true);
+        this.ardInfScrollTarget = input(this._DEFAULTS.target);
+        // re-check if threshold is reached immediately when directive becomes active again
+        // needed when the content is not enough to fill the container and thus the scroll is already at the end when the directive becomes active
+        effect(() => {
+            const active = this.ardInfScrollActive();
+            if (!active)
+                return;
+            const target = untracked(() => this.ardInfScrollTarget());
+            if (target === ArdInfScrollTarget.Host) {
+                this._detectHostReachThreshold();
+                return;
+            }
+            this._detectWindowReachThreshold();
+        });
+    }
+    //! event handlers
+    onHostScroll() {
+        if (!this.ardInfScrollActive())
+            return;
+        if (this.ardInfScrollTarget() !== ArdInfScrollTarget.Host) {
+            console.error(`DKT-NF1000: ardInfScroll directive has target set to "html", but the host element has just been scrolled. To ensure the directive functions properly, make the host element unscrollable.`);
+            return;
+        }
+        this._detectHostReachThreshold();
+    }
+    onWindowScroll() {
+        if (!this.ardInfScrollActive())
+            return;
+        if (this.ardInfScrollTarget() !== ArdInfScrollTarget.HTML)
+            return;
+        this._detectWindowReachThreshold();
+    }
+    _detectHostReachThreshold() {
+        const { height } = this._getElementRect();
+        const scrollTop = this._getElementScrollTop();
+        const scrollHeight = this._getElementScrollHeight();
+        const thresholdOffset = this.ardInfScrollThreshold();
+        if (scrollTop + height >= scrollHeight - thresholdOffset) {
+            this.ardInfScrollActive.set(false);
+            this.ardInfScrollReachThreshold.emit();
+        }
+    }
+    _detectWindowReachThreshold() {
+        const { top, height } = this._getElementRect();
+        const viewportHeight = window.innerHeight;
+        const thresholdOffset = this.ardInfScrollThreshold();
+        if (-1 * top + viewportHeight >= height - thresholdOffset) {
+            this.ardInfScrollActive.set(false);
+            this.ardInfScrollReachThreshold.emit();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumInfiniteScrollDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.0.5", type: ArdiumInfiniteScrollDirective, isStandalone: false, selector: "[ardInfScroll]", inputs: { ardInfScrollThreshold: { classPropertyName: "ardInfScrollThreshold", publicName: "ardInfScrollThreshold", isSignal: true, isRequired: false, transformFunction: null }, ardInfScrollActive: { classPropertyName: "ardInfScrollActive", publicName: "ardInfScrollActive", isSignal: true, isRequired: false, transformFunction: null }, ardInfScrollTarget: { classPropertyName: "ardInfScrollTarget", publicName: "ardInfScrollTarget", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { ardInfScrollReachThreshold: "ardInfScrollReachThreshold", ardInfScrollActive: "ardInfScrollActiveChange" }, host: { listeners: { "scroll": "onHostScroll()", "window:scroll": "onWindowScroll()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumInfiniteScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ardInfScroll]',
+                    standalone: false,
+                }]
+        }], ctorParameters: () => [], propDecorators: { onHostScroll: [{
+                type: HostListener,
+                args: ['scroll']
+            }], onWindowScroll: [{
+                type: HostListener,
+                args: ['window:scroll']
+            }] } });
+
+const _infiniteScrollDefaults = {
+    threshold: 200,
+    target: ArdInfScrollTarget.HTML,
+};
+const ARD_INFINITE_SCROLL_DEFAULTS = new InjectionToken('ard-infinite-scroll-defaults', {
+    factory: () => ({ ..._infiniteScrollDefaults }),
+});
+function provideInfiniteScrollDefaults(config) {
+    return {
+        provide: ARD_INFINITE_SCROLL_DEFAULTS,
+        useValue: { ..._infiniteScrollDefaults, ...config },
+    };
+}
+
+class ArdiumInfiniteScrollModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumInfiniteScrollModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: ArdiumInfiniteScrollModule, declarations: [ArdiumInfiniteScrollDirective], imports: [CommonModule], exports: [ArdiumInfiniteScrollDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumInfiniteScrollModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumInfiniteScrollModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ArdiumInfiniteScrollDirective],
+                    imports: [CommonModule],
+                    exports: [ArdiumInfiniteScrollDirective],
+                }]
+        }] });
+
+const _filePipesDefaults = {
+    extensionWithDot: true,
+    sizePrecision: 2,
+    sizeUseSpace: true,
+};
+const ARD_FILE_PIPES_DEFAULTS = new InjectionToken('ard-file-pipes-defaults', {
+    factory: () => ({
+        ..._filePipesDefaults,
+    }),
+});
+function provideFilePipesDefaults(config) {
+    return {
+        provide: ARD_FILE_PIPES_DEFAULTS,
+        useValue: { ..._filePipesDefaults, ...config },
+    };
+}
+
+/**
+ * Formats a file extension from a string or File object.
+ *
+ * @param {string | File | null | undefined} value - The file name or File object whose extension is to be extracted.
+ * @param {boolean} [withDot=false] - Whether to include a dot ('.') before the file extension.
+ * @returns {string | null} - The file extension, or null if no extension is found or if the input is invalid.
+ *
+ * @example
+ * formatFileExtension('image.png'); // -> 'png'
+ * formatFileExtension('image.png', true); // -> '.png'
+ */
+function formatFileExtension(value, withDot = false) {
+    if (!value)
+        return null;
+    if (typeof value !== 'string') {
+        value = value.name;
+    }
+    const ext = value.match(/^.+\.([^.]+)$/)?.[1] ?? null;
+    const dot = withDot ? '.' : '';
+    return ext ? dot + ext : null;
+}
+/**
+ * Pipe that transforms a file or file name into its extension.
+ *
+ * @example
+ * {{ 'image.png' | fileext }} // -> 'png'
+ * {{ 'image.png' | fileext: true }} // -> '.png'
+ */
+class ArdiumFileExtensionPipe {
+    constructor() {
+        this._DEFAULTS = inject(ARD_FILE_PIPES_DEFAULTS);
+    }
+    /**
+     * Transforms the given value to its file extension.
+     *
+     * @param {string | File | null | undefined} value - The file name or File object to extract the extension from.
+     * @param {boolean} withDot - Whether to include a dot before the extension (defaults to config value).
+     * @returns {string | null} - The file extension or null if no extension is found.
+     *
+     *
+     * @example
+     * {{ 'image.png' | fileext }} // -> 'png'
+     * {{ 'image.png' | fileext: true }} // -> '.png'
+     */
+    transform(value, withDot = this._DEFAULTS.extensionWithDot) {
+        return formatFileExtension(value, withDot);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumFileExtensionPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: ArdiumFileExtensionPipe, isStandalone: false, name: "fileext" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumFileExtensionPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'fileext',
+                    standalone: false,
+                }]
+        }] });
+
+/**
+ * Formats a file name by removing its extension.
+ *
+ * @param {string | File | null | undefined} value - The file name or File object to extract the name without extension from.
+ * @returns {string} - The file name without the extension, or the original input if no extension is found.
+ *
+ * @example
+ * formatFileName('image.png'); // -> 'image'
+ * formatFileName('document.pdf'); // -> 'document'
+ * formatFileName('my-component.component.ts'); // -> 'my-component.component'
+ */
+function formatFileName(value) {
+    if (!value)
+        return "";
+    if (typeof value != "string") {
+        value = value.name;
+    }
+    return value.match(/^(.+)\.[^.]+$/)?.[1] ?? value;
+}
+/**
+ * Pipe that transforms a file or file name into its name without the extension.
+ *
+ * @example
+ * {{ 'image.png' | filename }} // -> 'image'
+ * {{ 'document.pdf' | filename }} // -> 'document'
+ * {{ 'my-component.component.ts' | filename }} // -> 'my-component.component'
+ */
+class ArdiumFileNamePipe {
+    /**
+     * Transforms the given value to its file name without the extension.
+     *
+     * @param {string | File | null | undefined} value - The file name or File object to extract the name without extension from.
+     * @returns {string} - The file name without the extension.
+     *
+     * @example
+     * {{ 'image.png' | filename }} // -> 'image'
+     * {{ 'document.pdf' | filename }} // -> 'document'
+   * {{ 'my-component.component.ts' | filename }} // -> 'my-component.component'
+     */
+    transform(value) {
+        return formatFileName(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumFileNamePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: ArdiumFileNamePipe, isStandalone: false, name: "filename" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumFileNamePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "filename",
+                    standalone: false,
+                }]
+        }] });
+
+const FILE_SIZE_UNITS = [
+    { unit: 'B', size: 1 }, // bytes
+    { unit: 'kB', size: 1e3 }, // kilobytes
+    { unit: 'MB', size: 1e6 }, // megabytes
+    { unit: 'GB', size: 1e9 }, // gigabytes
+    { unit: 'TB', size: 1e12 }, // terabytes
+    { unit: 'PB', size: 1e15 }, // petabytes
+    { unit: 'EB', size: 1e18 }, // exabytes
+    { unit: 'ZB', size: 1e21 }, // zettabytes
+    { unit: 'YB', size: 1e24 }, // yottabytes
+];
+/**
+ * Formats a file size into a human-readable string with the appropriate unit.
+ *
+ * @param {number | File | null | undefined} value - The file size as a number or a File object whose size is to be extracted.
+ * @param {number} [precision=2] - The number of decimal places to round to. Default is 2.
+ * @param {boolean} [useSpace=true] - Whether to include a space between the number and the unit. Default is true.
+ * @returns {string} - The formatted file size with the unit (e.g., '1.5 MB', '10 kB').
+ *
+ * @example
+ * formatFileSize(1024); // -> '1.00 kB'
+ * formatFileSize(1048576); // -> '1.00 MB'
+ * formatFileSize(1048576, 3); // -> '1.000 MB'
+ * formatFileSize(1048576, 3, false); // -> '1.000MB'
+ * formatFileSize(967680, 0); // -> '945 kB'
+ */
+function formatFileSize(value, precision = 2, useSpace = true) {
+    const space = useSpace ? ' ' : '';
+    if (!value)
+        return `0${space}B`;
+    if (typeof value != 'number') {
+        value = value.size;
+    }
+    if (value === 0)
+        return `0${space}B`;
+    const index = FILE_SIZE_UNITS.findIndex((unit) => value < unit.size);
+    const fileSizeUnit = index === -1
+        ? FILE_SIZE_UNITS[FILE_SIZE_UNITS.length - 1]
+        : FILE_SIZE_UNITS[index - 1];
+    const convertedValue = fileSizeUnit.unit === 'B'
+        ? value
+        : (value / fileSizeUnit.size).toFixed(precision);
+    return `${convertedValue}${space}${fileSizeUnit.unit}`;
+}
+/**
+ * Pipe that transforms a file or file size into a human-readable file size string.
+ *
+ * @example
+ * {{ 1024 | filesize }} // -> '1.00 kB'
+ * {{ 1048576 | filesize }} // -> '1.00 MB'
+ * {{ 1048576 | filesize:3 }} // -> '1.000 MB'
+ * {{ 1048576 | filesize:3:false }} // -> '1.000MB'
+ * {{ 967680 | filesize:0 }} // -> '945 kB'
+ */
+class ArdiumFileSizePipe {
+    constructor() {
+        /** Default configuration for the pipe */
+        this._DEFAULTS = inject(ARD_FILE_PIPES_DEFAULTS);
+    }
+    /**
+     * Transforms the given value to a human-readable file size string.
+     *
+     * @param {number | File | null | undefined} value - The file size as a number or File object whose size is to be extracted.
+     * @param {number} precision - The number of decimal places to round to (defaults to config value).
+     * @param {boolean} useSpace - Whether to include a space between the number and the unit (defaults to config value).
+     * @returns {string} - The formatted file size string (e.g., '1.5 MB', '10 kB').
+     *
+     * @example
+     * {{ 1024 | filesize }} // -> '1.00 kB'
+     * {{ 1048576 | filesize }} // -> '1.00 MB'
+     * {{ 1048576 | filesize:3 }} // -> '1.000 MB'
+     * {{ 1048576 | filesize:3:false }} // -> '1.000MB'
+     * {{ 967680 | filesize:0 }} // -> '945 kB'
+     */
+    transform(value, precision = this._DEFAULTS.sizePrecision, useSpace = this._DEFAULTS.sizeUseSpace) {
+        return formatFileSize(value, precision, useSpace);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumFileSizePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: ArdiumFileSizePipe, isStandalone: false, name: "filesize" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumFileSizePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'filesize',
+                    standalone: false,
+                }]
+        }] });
+
+class ArdiumFilePipesModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumFilePipesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.5", ngImport: i0, type: ArdiumFilePipesModule, declarations: [ArdiumFileExtensionPipe,
+            ArdiumFileNamePipe,
+            ArdiumFileSizePipe], imports: [CommonModule], exports: [ArdiumFileExtensionPipe, ArdiumFileNamePipe, ArdiumFileSizePipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumFilePipesModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.5", ngImport: i0, type: ArdiumFilePipesModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ArdiumFileExtensionPipe,
+                        ArdiumFileNamePipe,
+                        ArdiumFileSizePipe,
+                    ],
+                    imports: [CommonModule],
+                    exports: [ArdiumFileExtensionPipe, ArdiumFileNamePipe, ArdiumFileSizePipe],
+                }]
+        }] });
+
+/**
+ * Creates a writable, reactive array signal with convenient, immutable array manipulation methods.
+ *
+ * This helper returns a signal that wraps an array and exposes a full suite of mutating and non-mutating array methods,
+ * all of which will automatically trigger Angular reactivity.
+ *
+ * All mutator methods (such as `push`, `pop`, `splice`, `setAt`, `updateAt`, etc) return a new array value, preserving
+ * immutability for optimal signal reactivity. Do not depend on reference equality between updates.
+ *
+ * @template T The type of items stored in the array.
+ * @param {T[]} [initialValue=[]] Optional initial value for the array.
+ * @returns {WritableArraySignal<T>} A writable array signal with both native and array-specific helpers.
+ *
+ * @example
+ * const numbers = arraySignal([1, 2, 3]);
+ * numbers.push(4);          // [1, 2, 3, 4]
+ * numbers.pop();            // returns 4, numbers() === [1, 2, 3]
+ * numbers.setAt(1, 99);     // [1, 99, 3]
+ * numbers.filter(x => x>1); // [99, 3]
+ */
+function arraySignal(initialValue = []) {
+    const internalSignal = signal([
+        ...initialValue,
+    ]);
+    const _set = internalSignal.set;
+    const _update = internalSignal.update;
+    const _asReadonly = internalSignal.asReadonly;
+    // Native signal methods
+    internalSignal.set = (value) => _set([...value]);
+    internalSignal.update = (updateFn) => {
+        _update((current) => [...updateFn(current)]);
+    };
+    // isEmpty
+    internalSignal.isEmpty = computed(() => internalSignal().length === 0);
+    // setAt & updateAt
+    internalSignal.setAt = (index, newItem) => {
+        internalSignal.update((arr) => {
+            const newArr = [...arr];
+            newArr[index] = newItem;
+            return newArr;
+        });
+    };
+    internalSignal.updateAt = (index, updateFn) => {
+        internalSignal.update((arr) => {
+            const newArr = [...arr];
+            newArr[index] = updateFn(newArr[index]);
+            return newArr;
+        });
+    };
+    // Array methods
+    internalSignal.fill = (value, start, end) => {
+        internalSignal.update((arr) => {
+            const newArr = [...arr];
+            newArr.fill(value, start, end);
+            return newArr;
+        });
+    };
+    internalSignal.filter = (predicate) => {
+        internalSignal.update((arr) => arr.filter(predicate));
+    };
+    internalSignal.map = (mapFn) => {
+        internalSignal.update((arr) => arr.map(mapFn));
+    };
+    internalSignal.pop = () => {
+        let value;
+        internalSignal.update((arr) => {
+            const newArr = [...arr];
+            value = newArr.pop();
+            return newArr;
+        });
+        return value;
+    };
+    internalSignal.push = (...items) => {
+        let length;
+        internalSignal.update((arr) => {
+            const newArr = [...arr, ...items];
+            length = newArr.length;
+            return newArr;
+        });
+        return length;
+    };
+    internalSignal.reverse = () => {
+        internalSignal.update((arr) => {
+            const newArr = [...arr];
+            newArr.reverse();
+            return newArr;
+        });
+    };
+    internalSignal.shift = () => {
+        let value;
+        internalSignal.update((arr) => {
+            const newArr = [...arr];
+            value = newArr.shift();
+            return newArr;
+        });
+        return value;
+    };
+    internalSignal.sort = (compareFn) => {
+        internalSignal.update((arr) => {
+            const newArr = [...arr];
+            newArr.sort(compareFn);
+            return newArr;
+        });
+    };
+    internalSignal.splice = (start, deleteCount, ...items) => {
+        let removed = [];
+        internalSignal.update((arr) => {
+            const newArr = [...arr];
+            removed = newArr.splice(start, deleteCount ?? arr.length, ...items);
+            return newArr;
+        });
+        return removed;
+    };
+    internalSignal.unshift = (...items) => {
+        let length;
+        internalSignal.update((arr) => {
+            const newArr = [...items, ...arr];
+            length = newArr.length;
+            return newArr;
+        });
+        return length;
+    };
+    // create a wrapper with only 
+    internalSignal.asReadonly = () => {
+        const readonlySignal = _asReadonly();
+        readonlySignal.isEmpty = internalSignal.isEmpty;
+        return readonlySignal;
+    };
+    return internalSignal;
+}
+
+/**
+ * Creates a writable, reactive counter signal with convenient helpers and computed queries.
+ *
+ * @param {number} [initial=0] The initial value of the counter.
+ * @returns {WritableCounterSignal} A writable counter signal instance.
+ *
+ * @example
+ * const count = counterSignal(10);
+ * count.inc();     // 11
+ * count.dec(2);    // 9
+ * count.reset();   // 10
+ * count.isReset(); // true
+ */
+function counterSignal(initial = 0) {
+    const internalSignal = signal(initial);
+    const isResetSignal = signal(true);
+    const _set = internalSignal.set;
+    const _update = internalSignal.update;
+    const _asReadonly = internalSignal.asReadonly;
+    let _initial = initial;
+    // Native methods
+    internalSignal.set = (value) => {
+        _set(value);
+        isResetSignal.set(false);
+    };
+    internalSignal.update = (updater) => {
+        _update((current) => updater(current));
+        isResetSignal.set(false);
+    };
+    // Counter methods
+    internalSignal.increment = (amount = 1) => {
+        internalSignal.update((val) => val + amount);
+    };
+    internalSignal.decrement = (amount = 1) => {
+        internalSignal.update((val) => val - amount);
+    };
+    internalSignal.reset = () => {
+        _set(_initial);
+        isResetSignal.set(true);
+    };
+    internalSignal.setBaseValue = (value) => {
+        _initial = value;
+    };
+    internalSignal.asReadonly = () => {
+        const readonly = _asReadonly();
+        readonly.isReset = internalSignal.isReset;
+        readonly.value = internalSignal.value;
+        return readonly;
+    };
+    internalSignal.value = internalSignal.asReadonly();
+    internalSignal.isReset = isResetSignal.asReadonly();
+    return internalSignal;
+}
+
+/**
+ * Creates a `WritableSignal` that delays updates to its value until there's a pause in updates, based on the debounce time specified.
+ *
+ * @param initialValue - The initial value of the signal.
+ * @param debounceTime - The delay in milliseconds after the last update before applying the signal update.
+ * @returns A `WritableSignal<T>` that debounces value updates based on the specified debounce time.
+ */
+function debouncedSignal(initialValue, debounceTime) {
+    const internalSignal = signal(initialValue);
+    Object.assign(internalSignal, { debounceTime });
+    let timeoutId = null;
+    const originalSet = internalSignal.set;
+    const setDebouncedValue = (value) => {
+        // Clear the previous timeout if a new value is set before the debounce period ends
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        // Set a new timeout to update the signal after the debounce period
+        timeoutId = setTimeout(() => {
+            originalSet(value);
+            timeoutId = null;
+        }, debounceTime);
+    };
+    // Override the `set` method to include debouncing
+    internalSignal.set = (value) => {
+        setDebouncedValue(value);
+    };
+    internalSignal.update = (fn) => {
+        setDebouncedValue(fn(internalSignal()));
+    };
+    return internalSignal;
+}
+
+/**
+ * Creates a writable, reactive Map signal with full Map-like API and helpers.
+ *
+ * This factory returns a signal wrapping a JavaScript `Map`, exposing both non-mutating and mutating methods
+ * for convenient and fully reactive manipulation of key-value pairs.
+ *
+ * All mutator methods (`setKey`, `delete`, `clear`, `setMap`, etc.) always replace the Map with a cloned version,
+ * ensuring immutability for predictable reactivity.
+ *
+ * The signal also provides computed signals for common queries (such as `isEmpty`, `size`, `entriesArray`, `keysArray`, `valuesArray`),
+ * and offers a type-safe, readonly view via `.asReadonly()`.
+ *
+ * @template K The type of keys.
+ * @template V The type of values.
+ * @param {Iterable<[K, V]>} [initialValue=[]] Optional initial map contents, as entries or another Map.
+ * @returns {WritableMapSignal<K, V>} A writable Map signal instance with both native and Map-specific helpers.
+ *
+ * @example
+ * const map = mapSignal<string, number>([['a', 1], ['b', 2]]);
+ * map.setKey('c', 3);        // Adds key 'c'
+ * map.delete('a');           // Removes key 'a'
+ * map.update(m => { m.set('d', 4); return m; });
+ * map.entriesArray();        // [['b', 2], ['c', 3], ['d', 4]]
+ */
+function mapSignal(initialValue = []) {
+    const internalSignal = signal(new Map(initialValue));
+    const _set = internalSignal.set;
+    const _update = internalSignal.update;
+    const _asReadonly = internalSignal.asReadonly;
+    internalSignal.setMap = (value) => _set(new Map(value));
+    internalSignal.set = (value) => _set(new Map(value));
+    internalSignal.setKey = (key, value) => {
+        internalSignal.update((map) => {
+            const copy = new Map(map);
+            copy.set(key, value);
+            return copy;
+        });
+    };
+    internalSignal.delete = (key) => {
+        let deleted = false;
+        internalSignal.update((map) => {
+            if (!map.has(key))
+                return map;
+            const copy = new Map(map);
+            deleted = copy.delete(key);
+            return copy;
+        });
+        return deleted;
+    };
+    internalSignal.clear = () => {
+        internalSignal.setMap(new Map());
+    };
+    internalSignal.get = (key) => internalSignal().get(key);
+    internalSignal.has = (key) => internalSignal().has(key);
+    internalSignal.update = (updateFn) => {
+        _update((current) => new Map(updateFn(current)));
+    };
+    internalSignal.updateAt = (key, updateFn) => {
+        internalSignal.update((map) => {
+            if (!map.has(key))
+                return map;
+            const copy = new Map(map);
+            copy.set(key, updateFn(copy.get(key)));
+            return copy;
+        });
+    };
+    internalSignal.entriesArray = computed(() => Array.from(internalSignal().entries()));
+    internalSignal.keysArray = computed(() => Array.from(internalSignal().keys()));
+    internalSignal.valuesArray = computed(() => Array.from(internalSignal().values()));
+    internalSignal.isEmpty = computed(() => internalSignal().size === 0);
+    internalSignal.size = computed(() => internalSignal().size);
+    internalSignal.asReadonly = () => {
+        const readonlySignal = _asReadonly();
+        readonlySignal.isEmpty = internalSignal.isEmpty;
+        readonlySignal.size = internalSignal.size;
+        readonlySignal.get = internalSignal.get;
+        readonlySignal.has = internalSignal.has;
+        readonlySignal.entriesArray = internalSignal.entriesArray;
+        readonlySignal.keysArray = internalSignal.keysArray;
+        readonlySignal.valuesArray = internalSignal.valuesArray;
+        return readonlySignal;
+    };
+    return internalSignal;
+}
+
+/**
+ * Defines the available persistent storage methods for the `persistentSignal`. Each method corresponds to a different browser storage mechanism:
+ * - `PersistentStorageMethod.LocalStorage`: Uses the browser's localStorage to persist the value across sessions.
+ * - `PersistentStorageMethod.SessionStorage`: Uses the browser's sessionStorage to persist the value for the duration of the page session.
+ * - `PersistentStorageMethod.Cookies`: Uses browser cookies to persist the value, allowing for additional options like expiration and path.
+ */
+const PersistentStorageMethod = {
+    Cookies: 'cookies',
+    LocalStorage: 'local-storage',
+    SessionStorage: 'session-storage',
+};
+function isSerializableSignal$1(options) {
+    return !!options.serialize && !!options.deserialize;
+}
+function persistentSignal(initialValue, options) {
+    if (!!options.serialize !== !!options.deserialize) {
+        throw new Error('DKT-FT3000: Both serialize and deserialize must either be both defined or both undefined.');
+    }
+    const isNonNullable = options.nonNullable === true;
+    if (isNonNullable && isNull(initialValue)) {
+        throw new Error('DKT-FT3002: Non-nullable persistent signals require a non-null initial value.');
+    }
+    if (!isSerializableSignal$1(options) &&
+        !isAnyString(initialValue) &&
+        !isNull(initialValue)) {
+        throw new Error('DKT-FT3001: Non-string initial values are only allowed for serializable signals. Define serialization options.');
+    }
+    const internalSignal = signal(initialValue);
+    const _asReadonly = internalSignal.asReadonly;
+    if (isNonNullable) {
+        const nonNullableSignal = internalSignal;
+        Object.assign(nonNullableSignal, {
+            method: options.method,
+            key: getKey(options),
+            serialized: computed(() => serializeValue$1(nonNullableSignal(), options)),
+        });
+        _assignPersistentSignalListeners(nonNullableSignal, options);
+        nonNullableSignal.asReadonly = () => {
+            const readonlySignal = _asReadonly();
+            readonlySignal.method = nonNullableSignal.method;
+            readonlySignal.key = nonNullableSignal.key;
+            readonlySignal.serialized = nonNullableSignal.serialized;
+            return readonlySignal;
+        };
+        return nonNullableSignal;
+    }
+    const nullableSignal = internalSignal;
+    Object.assign(nullableSignal, {
+        method: options.method,
+        key: getKey(options),
+        serialized: computed(() => serializeValue$1(nullableSignal(), options)),
+        clear: () => nullableSignal.set(null),
+    });
+    _assignPersistentSignalListeners(nullableSignal, options);
+    nullableSignal.asReadonly = () => {
+        const readonlySignal = _asReadonly();
+        readonlySignal.method = nullableSignal.method;
+        readonlySignal.key = nullableSignal.key;
+        readonlySignal.serialized = nullableSignal.serialized;
+        return readonlySignal;
+    };
+    return nullableSignal;
+}
+function _assignPersistentSignalListeners(signal, options) {
+    const storedValue = loadFromStorage(options);
+    if (storedValue !== null) {
+        signal.set(storedValue);
+    }
+    else {
+        updateStorage(options, signal());
+    }
+    const injector = inject(Injector);
+    runInInjectionContext(injector, () => {
+        effect(() => {
+            const value = signal();
+            updateStorage(options, value);
+        });
+    });
+}
+function loadFromStorage(options) {
+    let storedValue = null;
+    if (options.method === PersistentStorageMethod.LocalStorage) {
+        storedValue = localStorage.getItem(getKey(options));
+    }
+    else if (options.method === PersistentStorageMethod.SessionStorage) {
+        storedValue = sessionStorage.getItem(getKey(options));
+    }
+    else if (options.method === PersistentStorageMethod.Cookies) {
+        const match = document.cookie.match('(^|;)\\s*' + getKey(options) + '\\s*=\\s*([^;]+)');
+        storedValue = match ? decodeURIComponent(match[2]) : null;
+    }
+    return deserializeValue$1(storedValue, options);
+}
+function updateStorage(options, value) {
+    const serializedValue = serializeValue$1(value, options);
+    if (options.method === PersistentStorageMethod.LocalStorage) {
+        if (serializedValue === null)
+            localStorage.removeItem(getKey(options));
+        else
+            localStorage.setItem(getKey(options), serializedValue);
+    }
+    else if (options.method === PersistentStorageMethod.SessionStorage) {
+        if (serializedValue === null)
+            sessionStorage.removeItem(getKey(options));
+        else
+            sessionStorage.setItem(getKey(options), serializedValue);
+    }
+    else if (options.method === PersistentStorageMethod.Cookies) {
+        let cookieString = `${getKey(options)}=${serializedValue !== null ? encodeURIComponent(serializedValue) : ''}`;
+        if (serializedValue !== null) {
+            cookieString += `; expires=Thu, 01 Jan 1970 00:00:01 GMT;`;
+        }
+        else if (options.expires) {
+            const expires = options.expires instanceof Date
+                ? options.expires.toUTCString()
+                : options.expires;
+            cookieString += `; expires=${expires}`;
+        }
+        if (options.maxAge) {
+            cookieString += `; max-age=${options.maxAge}`;
+        }
+        cookieString += `; path=${options.path ?? '/'}`;
+        document.cookie = cookieString;
+    }
+}
+function getKey(options) {
+    return 'key' in options ? options.key : options.name;
+}
+function serializeValue$1(value, options) {
+    if (isSerializableSignal$1(options)) {
+        return options.serialize(value);
+    }
+    return value === null ? null : value;
+}
+function deserializeValue$1(value, options) {
+    if (value !== null && isSerializableSignal$1(options)) {
+        return options.deserialize(value);
+    }
+    return value;
+}
+
+function isSerializableSignal(options) {
+    return !!options.serialize && !!options.deserialize;
+}
+function queryParamSignal(initialValue, optionsOrParam) {
+    let options;
+    if (typeof optionsOrParam === 'string') {
+        options = { paramName: optionsOrParam };
+    }
+    else {
+        options = optionsOrParam;
+    }
+    if (!!options.serialize !== !!options.deserialize) {
+        throw new Error('DKT-FT3010: Both serialize and deserialize must either be both defined or both undefined.');
+    }
+    const isNonNullable = options.nonNullable === true;
+    if (isNonNullable && isNull(initialValue)) {
+        throw new Error('DKT-FT3012: Non-nullable query param signals require a non-null initial value.');
+    }
+    if (!isSerializableSignal(options) &&
+        !isAnyString(initialValue) &&
+        !isNull(initialValue)) {
+        throw new Error('DKT-FT3011: Non-string initial values are only allowed for serializable signals. Define serialization options.');
+    }
+    const internalSignal = signal(initialValue);
+    const _asReadonly = internalSignal.asReadonly;
+    if (isNonNullable) {
+        const nonNullableSignal = internalSignal;
+        Object.assign(nonNullableSignal, {
+            paramName: options.paramName,
+            serialized: computed(() => serializeValue(nonNullableSignal(), options)),
+        });
+        _assignQueryParamListeners(nonNullableSignal, initialValue, options);
+        nonNullableSignal.asReadonly = () => {
+            const readonlySignal = _asReadonly();
+            readonlySignal.serialized = nonNullableSignal.serialized;
+            return readonlySignal;
+        };
+        return nonNullableSignal;
+    }
+    const nullableSignal = internalSignal;
+    Object.assign(nullableSignal, {
+        paramName: options.paramName,
+        serialized: computed(() => serializeValue(nullableSignal(), options)),
+        clear: () => nullableSignal.set(null),
+    });
+    _assignQueryParamListeners(nullableSignal, initialValue, options);
+    nullableSignal.asReadonly = () => {
+        const readonlySignal = _asReadonly();
+        readonlySignal.serialized = nullableSignal.serialized;
+        return readonlySignal;
+    };
+    return nullableSignal;
+}
+function _assignQueryParamListeners(signal, initialValue, options) {
+    const router = inject(Router);
+    const storedValue = loadFromQueryParam(router, options);
+    const destroyRef = inject(DestroyRef);
+    const injector = inject(Injector);
+    let isApplyingRouterValue = false;
+    if (storedValue !== null) {
+        signal.set(storedValue);
+    }
+    else {
+        updateQueryParam(router, options, signal());
+    }
+    setTimeout(() => {
+        updateQueryParam(router, options, signal());
+    }, 0);
+    router.events
+        .pipe(filter((event) => event instanceof NavigationEnd), takeUntilDestroyed(destroyRef))
+        .subscribe(() => {
+        const nextValue = loadFromQueryParam(router, options);
+        const writableSignal = signal;
+        if (options.nonNullable === true && nextValue === null) {
+            writableSignal.set(initialValue);
+            return;
+        }
+        const currentSerialized = serializeValue(writableSignal(), options);
+        const nextSerialized = serializeValue(nextValue, options);
+        if (currentSerialized === nextSerialized) {
+            return;
+        }
+        isApplyingRouterValue = true;
+        writableSignal.set(nextValue);
+        isApplyingRouterValue = false;
+    });
+    runInInjectionContext(injector, () => {
+        effect(() => {
+            if (isApplyingRouterValue) {
+                return;
+            }
+            updateQueryParam(router, options, signal());
+        });
+    });
+}
+function loadFromQueryParam(router, options) {
+    const urlTree = router.parseUrl(router.url);
+    const queryParamValue = urlTree.queryParams[options.paramName];
+    const storedValue = queryParamValue === undefined || queryParamValue === null
+        ? null
+        : String(queryParamValue);
+    return deserializeValue(storedValue, options);
+}
+function updateQueryParam(router, options, value) {
+    const serializedValue = serializeValue(value, options);
+    const urlTree = router.parseUrl(router.url);
+    const currentParam = urlTree.queryParams[options.paramName] == null
+        ? null
+        : String(urlTree.queryParams[options.paramName]);
+    if (currentParam === serializedValue) {
+        return;
+    }
+    const queryParams = {
+        ...urlTree.queryParams,
+        [options.paramName]: serializedValue,
+    };
+    router.navigate([], {
+        queryParams,
+        queryParamsHandling: 'merge',
+        replaceUrl: true,
+    });
+}
+function serializeValue(value, options) {
+    if (isSerializableSignal(options)) {
+        return options.serialize(value);
+    }
+    return value === null ? null : value;
+}
+function deserializeValue(value, options) {
+    if (value !== null && isSerializableSignal(options)) {
+        return options.deserialize(value);
+    }
+    return value;
+}
+
+/**
+ * Creates a writable queue signal, which is a reactive queue data structure.
+ *
+ * @template T The type of elements held in the queue.
+ * @param {T[]} [initialValue=[]] Optional initial items in the queue.
+ * @returns {WritableQueueSignal<T>} The writable queue signal instance.
+ *
+ * @example
+ * const queue = queueSignal<number>([1, 2, 3]);
+ * queue.enqueue(4);              // new value: [1, 2, 3, 4]
+ * const value = queue.dequeue(); // 1    new value: [2, 3, 4]
+ * queue.clear();                 // new value: []
+ */
+function queueSignal(initialValue = []) {
+    const internalSignal = signal([
+        ...initialValue,
+    ]);
+    const _set = internalSignal.set;
+    const _update = internalSignal.update;
+    const _asReadonly = internalSignal.asReadonly;
+    // Native methods
+    internalSignal.set = (arr) => _set([...arr]);
+    internalSignal.update = (updateFn) => {
+        _update((current) => [...updateFn(current)]);
+    };
+    // Queue methods
+    internalSignal.enqueue = (...items) => {
+        internalSignal.update((queue) => [...queue, ...items]);
+    };
+    internalSignal.dequeue = () => {
+        let dequeued = undefined;
+        internalSignal.update((queue) => {
+            if (queue.length === 0)
+                return queue;
+            const copy = [...queue];
+            dequeued = copy.shift();
+            return copy;
+        });
+        return dequeued;
+    };
+    internalSignal.clear = () => {
+        internalSignal.set([]);
+    };
+    internalSignal.isEmpty = computed(() => internalSignal().length === 0);
+    internalSignal.size = computed(() => internalSignal().length);
+    internalSignal.front = computed(() => {
+        const queue = internalSignal();
+        return queue.length ? queue[0] : undefined;
+    });
+    internalSignal.asArray = computed(() => [...internalSignal()]);
+    internalSignal.peek = () => {
+        const queue = internalSignal();
+        return queue.length ? queue[0] : undefined;
+    };
+    internalSignal.asReadonly = () => {
+        const readonlySignal = _asReadonly();
+        readonlySignal.isEmpty = internalSignal.isEmpty;
+        readonlySignal.size = internalSignal.size;
+        readonlySignal.front = internalSignal.front;
+        readonlySignal.asArray = internalSignal.asArray;
+        readonlySignal.peek = internalSignal.peek;
+        return readonlySignal;
+    };
+    return internalSignal;
+}
+
+/**
+ * Creates a writable, reactive Set signal with convenient, immutable Set manipulation methods.
+ *
+ * This function returns a signal that wraps a JavaScript `Set` and exposes both non-mutating and mutating helpers,
+ * ensuring that all operations are fully reactive and immutably safe. All mutator methods (`add`, `delete`, `clear`, etc.)
+ * return a new Set value for robust signal reactivity.
+ *
+ * Also provides computed signals for queries such as `isEmpty`, `size`, and `asArray`, and offers a type-safe, read-only
+ * view via `.asReadonly()`.
+ *
+ * @template T The type of items stored in the set.
+ * @param {Iterable<T>} [initialValue=[]] Optional initial values for the set (can be another Set or any iterable).
+ * @returns {WritableSetSignal<T>} A writable Set signal instance with both native and Set-specific helpers.
+ *
+ * @example
+ * const ids = setSignal<number>([1, 2, 3]);
+ * ids.add(4);              // [1, 2, 3, 4]
+ * ids.delete(2);           // removes 2
+ * ids.has(3);              // true
+ * ids.asArray();           // [1, 3, 4]
+ * ids.clear();             // empty set
+ * ids.isEmpty();           // true
+ */
+function setSignal(initialValue = []) {
+    const internalSignal = signal(new Set(initialValue));
+    const _set = internalSignal.set;
+    const _update = internalSignal.update;
+    const _asReadonly = internalSignal.asReadonly;
+    // Native signal methods
+    internalSignal.set = (value) => _set(new Set(value));
+    internalSignal.update = (updateFn) => {
+        _update((current) => new Set(updateFn(current)));
+    };
+    // Computed helpers
+    internalSignal.isEmpty = computed(() => internalSignal().size === 0);
+    internalSignal.size = computed(() => internalSignal().size);
+    // Set methods
+    internalSignal.add = (value) => {
+        internalSignal.update((set) => {
+            if (set.has(value))
+                return set;
+            const copy = new Set(set);
+            copy.add(value);
+            return copy;
+        });
+    };
+    internalSignal.delete = (value) => {
+        let deleted = false;
+        internalSignal.update((set) => {
+            if (!set.has(value))
+                return set;
+            const copy = new Set(set);
+            deleted = copy.delete(value);
+            return copy;
+        });
+        return deleted;
+    };
+    internalSignal.clear = () => {
+        internalSignal.set(new Set());
+    };
+    internalSignal.has = (value) => {
+        return internalSignal().has(value);
+    };
+    internalSignal.asArray = computed(() => Array.from(internalSignal()));
+    internalSignal.asReadonly = () => {
+        const readonlySignal = _asReadonly();
+        readonlySignal.isEmpty = internalSignal.isEmpty;
+        readonlySignal.size = internalSignal.size;
+        readonlySignal.asArray = internalSignal.asArray;
+        return readonlySignal;
+    };
+    return internalSignal;
+}
+
+/**
+ * Creates a writable stack signal, which is a reactive stack data structure.
+ *
+ * @template T The type of elements held in the stack.
+ * @param {T[]} [initialValue=[]] Optional initial items in the stack.
+ * @returns {WritableStackSignal<T>} The writable stack signal instance.
+ *
+ * @example
+ * const stack = stackSignal<number>([1, 2, 3]);
+ * stack.push(4);             // [1, 2, 3, 4]
+ * const value = stack.pop(); // 4        [1, 2, 3]
+ * stack.clear();             // []
+ */
+function stackSignal(initialValue = []) {
+    const internalSignal = signal([
+        ...initialValue,
+    ]);
+    const _set = internalSignal.set;
+    const _update = internalSignal.update;
+    const _asReadonly = internalSignal.asReadonly;
+    // Native methods
+    internalSignal.set = (arr) => _set([...arr]);
+    internalSignal.update = (updateFn) => {
+        _update((current) => [...updateFn(current)]);
+    };
+    // Stack methods
+    internalSignal.push = (...items) => {
+        internalSignal.update((stack) => [...stack, ...items]);
+    };
+    internalSignal.pop = () => {
+        let popped = undefined;
+        internalSignal.update((stack) => {
+            if (stack.length === 0)
+                return stack;
+            const copy = [...stack];
+            popped = copy.pop();
+            return copy;
+        });
+        return popped;
+    };
+    internalSignal.clear = () => {
+        internalSignal.set([]);
+    };
+    internalSignal.isEmpty = computed(() => internalSignal().length === 0);
+    internalSignal.size = computed(() => internalSignal().length);
+    internalSignal.top = computed(() => {
+        const stack = internalSignal();
+        return stack.length ? stack[stack.length - 1] : undefined;
+    });
+    internalSignal.asArray = computed(() => [...internalSignal()]);
+    internalSignal.peek = () => {
+        const stack = internalSignal();
+        return stack.length ? stack[stack.length - 1] : undefined;
+    };
+    internalSignal.asReadonly = () => {
+        const readonlySignal = _asReadonly();
+        readonlySignal.isEmpty = internalSignal.isEmpty;
+        readonlySignal.size = internalSignal.size;
+        readonlySignal.top = internalSignal.top;
+        readonlySignal.asArray = internalSignal.asArray;
+        readonlySignal.peek = internalSignal.peek;
+        return readonlySignal;
+    };
+    return internalSignal;
+}
+
+/**
+ * Creates a `WritableSignal` that limits how often its value can be updated, using the throttle time specified.
+ *
+ * @param initialValue - The initial value of the signal.
+ * @param throttleTime - The minimum delay in milliseconds between signal updates.
+ * @returns A `WritableSignal<T>` that throttles value updates based on the specified throttle time.
+ */
+function throttledSignal(initialValue, throttleTime) {
+    const internalSignal = signal(initialValue);
+    Object.assign(internalSignal, { throttleTime });
+    let lastUpdate = 0;
+    let queuedValue = undefined;
+    let timeoutId = null;
+    const originalSet = internalSignal.set;
+    const setThrottledValue = (value) => {
+        const now = Date.now();
+        const timeSinceLastUpdate = now - lastUpdate;
+        // If the new value is different and enough time has passed, set it immediately
+        if (timeSinceLastUpdate >= throttleTime && internalSignal() !== value) {
+            lastUpdate = now;
+            originalSet(value);
+            queuedValue = undefined;
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+        }
+        else {
+            if (queuedValue === undefined) {
+                queuedValue = value;
+                timeoutId = setTimeout(() => {
+                    if (queuedValue !== null) {
+                        originalSet(queuedValue);
+                        lastUpdate = Date.now();
+                        queuedValue = undefined;
+                        timeoutId = null;
+                    }
+                }, throttleTime - timeSinceLastUpdate);
+            }
+            else {
+                queuedValue = value;
+            }
+        }
+    };
+    internalSignal.set = (value) => {
+        setThrottledValue(value);
+    };
+    internalSignal.update = (fn) => {
+        setThrottledValue(fn(internalSignal()));
+    };
+    return internalSignal;
+}
+
+/**
+ * Creates a writable, reactive tuple signal of **fixed length**, with tuple-specific and array-like helpers.
+ *
+ * This function returns a signal wrapping a tuple (fixed-length array), exposing safe, type-aware mutation and update helpers
+ * as well as computed signals for common tuple queries.
+ *
+ * All mutating methods (`set`, `setAt`, `updateAt`, `update`) return a new tuple value,
+ * preserving immutability and optimal signal reactivity.
+ *
+ * Also provides `.asReadonly()` for read-only consumption and computed signals for empty/entries.
+ *
+ * @template T The tuple type (e.g. `[number, string, boolean]`).
+ * @param {T} initialValue The initial tuple value.
+ * @returns {WritableTupleSignal<T>} A writable tuple signal with all mutation, query, and computed helpers.
+ *
+ * @example
+ * const point = tupleSignal<[number, number]>([0, 1]);
+ * point.setAt(1, 99);          // [0, 99]
+ * point.updateAt(0, x => x+10);// [10, 99]
+ * point();                     // [10, 99]
+ * point.entriesArray();        // [[0, 10], [1, 99]]
+ */
+function tupleSignal(initialValue) {
+    // Clone initialValue for safety.
+    const internalSignal = signal([
+        ...initialValue,
+    ]);
+    const _set = internalSignal.set;
+    const _update = internalSignal.update;
+    const _asReadonly = internalSignal.asReadonly;
+    internalSignal.set = (tuple) => _set([...tuple]);
+    internalSignal.update = (updateFn) => {
+        _update((current) => [...updateFn(current)]);
+    };
+    // Set by index (returns a new tuple).
+    internalSignal.setAt = (index, value) => {
+        internalSignal.update((current) => {
+            const next = [...current];
+            next[index] = value;
+            return next;
+        });
+    };
+    // Update by index.
+    internalSignal.updateAt = (index, updateFn) => {
+        internalSignal.update((current) => {
+            const next = [...current];
+            next[index] = updateFn(next[index]);
+            return next;
+        });
+    };
+    // Read-only API.
+    internalSignal.asReadonly = () => {
+        const readonlySignal = _asReadonly();
+        readonlySignal.entriesArray = internalSignal.entriesArray;
+        readonlySignal.getAt = internalSignal.getAt;
+        return readonlySignal;
+    };
+    // Computed helpers.
+    internalSignal.entriesArray = computed(() => {
+        const tuple = internalSignal();
+        return tuple.map((value, index) => [index, value]);
+    });
+    internalSignal.getAt = (index) => internalSignal()[index];
+    return internalSignal;
+}
+
+class FormControlTracker {
+    constructor(thisObjOrAbstractControl, options = {}) {
+        this.thisObjOrAbstractControl = thisObjOrAbstractControl;
+        this.options = options;
+        this._injector = this.options.injector ?? inject(Injector);
+        this._value$ = new BehaviorSubject(undefined);
+        this.value$ = this._value$.asObservable();
+        this.value = toSignal(this._value$, {
+            injector: this._injector,
+            initialValue: undefined,
+        });
+        this._errors$ = new BehaviorSubject(null);
+        this.errors$ = this._errors$.asObservable();
+        this.errors = toSignal(this._errors$, {
+            injector: this._injector,
+            initialValue: null,
+        });
+        this._touched$ = new BehaviorSubject(false);
+        this.touched$ = this._touched$.asObservable();
+        this.touched = toSignal(this._touched$, {
+            injector: this._injector,
+            initialValue: false,
+        });
+        this.untouched$ = this.touched$.pipe(map((v) => !v));
+        this.untouched = toSignal(this.untouched$, {
+            injector: this._injector,
+            initialValue: true,
+        });
+        this._pristine$ = new BehaviorSubject(true);
+        this.pristine$ = this._pristine$.asObservable();
+        this.pristine = toSignal(this._pristine$, {
+            injector: this._injector,
+            initialValue: true,
+        });
+        this.dirty$ = this.pristine$.pipe(map((v) => !v));
+        this.dirty = toSignal(this.dirty$, {
+            injector: this._injector,
+            initialValue: false,
+        });
+        this._status$ = new BehaviorSubject('VALID');
+        this.status$ = this._status$.asObservable();
+        this.status = toSignal(this._status$, {
+            injector: this._injector,
+            initialValue: 'VALID',
+        });
+        this.valid$ = this.status$.pipe(map((v) => v === 'VALID'));
+        this.valid = toSignal(this.valid$, {
+            injector: this._injector,
+            initialValue: true,
+        });
+        this.invalid$ = this.status$.pipe(map((v) => v === 'INVALID'));
+        this.invalid = toSignal(this.invalid$, {
+            injector: this._injector,
+            initialValue: false,
+        });
+        this.pending$ = this.status$.pipe(map((v) => v === 'PENDING'));
+        this.pending = toSignal(this.pending$, {
+            injector: this._injector,
+            initialValue: false,
+        });
+        this.disabled$ = this.status$.pipe(map((v) => v === 'DISABLED'));
+        this.disabled = toSignal(this.disabled$, {
+            injector: this._injector,
+            initialValue: false,
+        });
+        this.enabled$ = this.status$.pipe(map((v) => v !== 'DISABLED'));
+        this.enabled = toSignal(this.enabled$, {
+            injector: this._injector,
+            initialValue: true,
+        });
+        this.touchedHasErrors = computed(() => !!this.errors() && this.touched());
+        this._validators$ = new BehaviorSubject(null);
+        this.validators$ = this._validators$.asObservable();
+        this.validators = toSignal(this._validators$, {
+            injector: this._injector,
+            initialValue: null,
+        });
+        this._asyncValidators$ = new BehaviorSubject(null);
+        this.asyncValidators$ = this._asyncValidators$.asObservable();
+        this.asyncValidators = toSignal(this._asyncValidators$, {
+            injector: this._injector,
+            initialValue: null,
+        });
+        if (this._isAbstractControl(this.thisObjOrAbstractControl)) {
+            this.init();
+        }
+    }
+    _isAbstractControl(v) {
+        return (isFormControl(v) ||
+            isFormArray(v) ||
+            isFormGroup(v) ||
+            isFormRecord(v) ||
+            (!!v && typeof v === 'object' && 'events' in v && isObservable(v.events)));
+    }
+    init() {
+        if (this._isAbstractControl(this.thisObjOrAbstractControl)) {
+            this.instance = this.thisObjOrAbstractControl;
+        }
+        else {
+            const ngControl = this._injector.get(NgControl, null);
+            if (ngControl) {
+                // if the valueAccessor was not yet set by Angular, we have to do it manually here
+                if (this.options.attachValueAccessor ?? true) {
+                    if (!ngControl.valueAccessor ||
+                        (this.thisObjOrAbstractControl &&
+                            this.thisObjOrAbstractControl instanceof
+                                ngControl.valueAccessor.constructor)) {
+                        ngControl.valueAccessor = this
+                            .thisObjOrAbstractControl;
+                    }
+                }
+                // grab the AbstractControl instance
+                const instance = ngControl.control;
+                if (!instance)
+                    return;
+                this.instance = instance;
+            }
+        }
+        if (this.instance) {
+            const instance = this.instance;
+            // listen to all data available in the events emitter
+            this._eventsSub = instance.events.subscribe((event) => {
+                if (event instanceof ValueChangeEvent) {
+                    this._value$.next(event.value);
+                    return;
+                }
+                if (event instanceof TouchedChangeEvent) {
+                    this._touched$.next(event.touched);
+                    return;
+                }
+                if (event instanceof PristineChangeEvent) {
+                    this._pristine$.next(event.pristine);
+                    return;
+                }
+                if (event instanceof StatusChangeEvent) {
+                    this._status$.next(event.status);
+                    this._errors$.next(event.source.errors);
+                    return;
+                }
+            });
+            this._value$.next(instance.value);
+            this._touched$.next(instance.touched);
+            this._pristine$.next(instance.pristine);
+            this._status$.next(instance.status);
+            this._errors$.next(instance.errors);
+            // do not read the next lines of code if you are easily frightened
+            // I'm not proud of this part, but it had to be done. God please forgive me
+            // I didn't find any other feasible way to detect when the control changes its validators
+            // so it had to be hacked like this
+            // override the "setValidators" function to capture the validators
+            const oldSetValidators = instance.setValidators.bind(instance);
+            instance.setValidators = (...args) => {
+                oldSetValidators(...args);
+                const validators = instance._rawValidators;
+                this._validators$.next(isFunction(validators) ? [validators] : validators);
+            };
+            // override the "validator" setter to capture the validators
+            wrapSetter(instance, 'validator', () => {
+                const raw = instance._rawValidators;
+                this._validators$.next(isFunction(raw) ? [raw] : raw);
+            });
+            // override the "setAsyncValidators" function to capture the async validators
+            const oldSetAsyncValidators = instance.setAsyncValidators.bind(instance);
+            instance.setAsyncValidators = (...args) => {
+                oldSetAsyncValidators(...args);
+                const validators = instance._rawAsyncValidators;
+                this._asyncValidators$.next(isFunction(validators) ? [validators] : validators);
+            };
+            // override the "asyncValidator" setter to capture the async validators
+            wrapSetter(instance, 'asyncValidator', () => {
+                const raw = instance._rawAsyncValidators;
+                this._asyncValidators$.next(isFunction(raw) ? [raw] : raw);
+            });
+            // assign the validators at init time
+            const validators = instance._rawValidators;
+            this._validators$.next(isFunction(validators) ? [validators] : validators);
+            const asyncValidators = instance._rawAsyncValidators;
+            this._asyncValidators$.next(isFunction(asyncValidators) ? [asyncValidators] : asyncValidators);
+        }
+    }
+    destroy() {
+        this._eventsSub?.unsubscribe();
+    }
+}
+/**
+ * Gives reactive access to the properties of the given form control.
+ *
+ * Call `destroy()` to dispose of form control tracker.
+ *
+ * @param formControl the form control to be tracked.
+ * @param options optional configuration for the form control tracker.
+ * @returns an object containing all standard form control getters as signals.
+ * @example
+ * ```
+ * readonly ageControl = new FormControl('John');
+ *
+ * readonly ageControlTracker = trackFormControl(this.ageControl);
+ * ```
+ */
+function trackFormControl(formControl, options) {
+    return new FormControlTracker(formControl, {
+        ...options,
+        attachValueAccessor: false,
+    });
+}
+/**
+ * Gives reactive access to the properties of the Form Control assigned to the component instance.
+ *
+ * Call the `init()` method inside `ngOnInit()` to start listening to the Form Control, call `destroy()` to dispose of the listener.
+ *
+ * @param thisObj the component instance.
+ * @param options optional configuration for the form control tracker.
+ * @returns an object containing all standard form control getters as signals.
+ * @example
+ * ```
+ * export class MyComponent implements ControlValueAccessor, OnInit, OnDestroy {
+ *   readonly control = trackFormControl(this);
+ *
+ *   ngOnInit(): void {
+ *     this.control.init();
+ *   }
+ *   ngOnDestroy(): void {
+ *     this.control.destroy();
+ *   }
+ *   // control value accessor implementation ...
+ * }
+ * ```
+ */
+function trackBoundControl(thisObj, options) {
+    return new FormControlTracker(thisObj, options);
+}
+// --- helper: wraps an accessor setter on a single instance ---
+function wrapSetter(obj, propName, after) {
+    // find the accessor descriptor up the prototype chain
+    let proto = obj;
+    let desc;
+    while (proto && !(desc = Object.getOwnPropertyDescriptor(proto, propName))) {
+        proto = Object.getPrototypeOf(proto);
+    }
+    if (!desc || typeof desc.set !== 'function') {
+        throw new Error(`No setter found for ${String(propName)}`);
+    }
+    const originalSet = desc.set;
+    const originalGet = desc.get; // may exist
+    Object.defineProperty(obj, propName, {
+        configurable: true,
+        enumerable: desc.enumerable ?? true,
+        get: originalGet
+            ? function () {
+                return originalGet.call(this);
+            }
+            : undefined,
+        set: function (value) {
+            originalSet.call(this, value);
+            after();
+        },
+    });
+}
+
+/**
+ * Coerces a value to an array of trimmed non-empty strings.
+ * Any input that is not an array, `null` or `undefined` will be turned into a string
+ * using `String()` and split into an array with the given separator.
+ * `null`, `undefined`, and `""` will result in an empty array.
+ * This results in the following outcomes:
+ * - `null` -> `[]`
+ * - `[null]` -> `["null"]`
+ * - `["a", "b ", " "]` -> `["a", "b"]`
+ * - `[1, [2, 3]]` -> `["1", "2,3"]`
+ * - `"a,b , c"` -> `["a", "b", "c"]`
+ *
+ * Useful for defining CSS classes or table columns.
+ * @param value the value to coerce into an array of strings
+ * @param separator split-separator if value isn't an array. Defaults to the string `","`.
+ */
+function coerceArrayProperty(value, separator = ',') {
+    if (Array.isArray(value))
+        return value.map((v) => String(v).trim()).filter((v) => v.length);
+    if (value == null || value === '')
+        return [];
+    return String(value)
+        .split(separator)
+        .map((v) => v.trim())
+        .filter((v) => v.length);
+}
+
+function getUTCDate(year, monthIndex, day, hour = 0, minute = 0, second = 0, millisecond = 0) {
+    if (!isDefined(year) && !isDefined(monthIndex) && !isDefined(day)) {
+        const now = new Date();
+        now.setMinutes(now.getMinutes() + now.getTimezoneOffset());
+        return now;
+    }
+    return new Date(Date.UTC(year, monthIndex, day, hour, minute, second, millisecond));
+}
+function coerceDateProperty(v, fallback) {
+    if (typeof v == 'string') {
+        if (v.toLowerCase() === 'now') {
+            return new Date();
+        }
+    }
+    v = new Date(v);
+    if (isNaN(v.valueOf())) {
+        return fallback;
+    }
+    return v;
+}
+function coerceDateOnlyProperty(v, fallback, asUTC = false) {
+    if (typeof v == 'string') {
+        if (v.toLowerCase() === 'now' || v.toLowerCase() === 'today') {
+            const now = new Date();
+            now.setMinutes(now.getMinutes() + now.getTimezoneOffset());
+            return asUTC
+                ? getUTCDate(now.getFullYear(), now.getMonth(), now.getDate(), now.getHours(), now.getMinutes(), now.getSeconds(), now.getMilliseconds())
+                : now;
+        }
+    }
+    const dateV = new Date(v);
+    if (isNaN(dateV.valueOf())) {
+        return fallback;
+    }
+    if (dateV.toISOString().substring(10) === 'T00:00:00.000Z') {
+        if (asUTC) {
+            return dateV;
+        }
+        return new Date(dateV.getUTCFullYear(), dateV.getUTCMonth(), dateV.getUTCDate(), 0, 0, 0, 0);
+    }
+    if (asUTC) {
+        return getUTCDate(dateV.getFullYear(), dateV.getMonth(), dateV.getDate());
+    }
+    return new Date(dateV.getFullYear(), dateV.getMonth(), dateV.getDate(), 0, 0, 0, 0);
+}
+
+function getDomContentRect(el) {
+    if (el instanceof ElementRef)
+        el = el.nativeElement;
+    const elRect = el.getBoundingClientRect();
+    const [topPadd, rightPadd, bottomPadd, leftPadd] = getFourWayValue(el, 'padding');
+    const [topBorder, rightBorder, bottomBorder, leftBorder] = getFourWayValue(el, 'border-width');
+    return new DOMRect(elRect.x + leftPadd + leftBorder, elRect.y + topPadd + topBorder, elRect.width - leftPadd - rightPadd - leftBorder - rightBorder, elRect.height - topPadd - bottomPadd - topBorder - bottomBorder);
+}
+function getDomPaddingRect(el) {
+    if (el instanceof ElementRef)
+        el = el.nativeElement;
+    const elRect = el.getBoundingClientRect();
+    const [topBorder, rightBorder, bottomBorder, leftBorder] = getFourWayValue(el, 'border-width');
+    return new DOMRect(elRect.x + leftBorder, elRect.y + topBorder, elRect.width - leftBorder - rightBorder, elRect.height - topBorder - bottomBorder);
+}
+function getFourWayValue(el, v) {
+    const elValues = window.getComputedStyle(el).getPropertyValue(v);
+    const values = elValues.split(' ').map((v) => (v ? parseFloat(v) : null));
+    const topValue = values[0] ?? 0;
+    const rightValue = values[1] ?? topValue;
+    const bottomValue = values[2] ?? topValue;
+    const leftValue = values[3] ?? rightValue ?? topValue;
+    return [topValue, rightValue, bottomValue, leftValue];
+}
+
+function findBestSuggestions(toMatch, suggestions, mapFn) {
+    //map non-string values to strings, if needed
+    const suggestionStrings = suggestions.map((v) => typeof v == 'string' ? v : mapFn(v));
+    //* alternative method for single-char strings
+    //the similarity algorithm always returns zero in this case
+    if (toMatch.length == 1) {
+        return (suggestionStrings
+            //remember the original indexes
+            .map((v, index) => ({ str: v, index }))
+            //pick only the ones starting with the character to match
+            .filter((v) => v.str.startsWith(toMatch))
+            //map to string length and index
+            .map((v) => ({ rating: v.str.length, index: v.index }))
+            //sort by length, ascending
+            .sort((a, b) => a.rating - b.rating)
+            //map to original values
+            .map((v) => suggestions[v.index]));
+    }
+    //* standard method
+    return (suggestionStrings
+        //map to ratings of similarity between the string and toMatch
+        .map((v, index) => {
+        //always include if starts with the value to match
+        if (new RegExp(`^${toMatch}`, 'i').test(v))
+            return { rating: 1_000 - v.length, index };
+        //calculate conditional similarity
+        const similarity = diceCoefficient(toMatch, v);
+        const foundTerm = v.match(new RegExp(toMatch, 'ig'))?.[0];
+        const foundIndex = foundTerm ? v.indexOf(foundTerm) : -1;
+        const canBeFound = foundIndex != -1;
+        const foundIndexModifier = canBeFound
+            ? (Math.cos((foundIndex / 90) * Math.PI) + 1) ** 2 / 1.5
+            : 1;
+        const rating = similarity * foundIndexModifier;
+        return {
+            rating,
+            index,
+        };
+    })
+        //keep only ratings above or equal to 0.45
+        .filter((v) => v.rating >= 0.45)
+        //sort descending
+        .sort((a, b) => b.rating - a.rating)
+        //map to original values
+        .map((v) => suggestions[v.index]));
+}
+function findBestAutocomplate(toMatch, autocompletes) {
+    const targetArray = autocompletes.filter((v) => new RegExp(`^${toMatch}`, 'i').test(v));
+    let bestMatch = targetArray.shift();
+    let bestScore = 0;
+    for (const str of targetArray) {
+        const score = diceCoefficient(toMatch, str);
+        if (score > bestScore) {
+            bestMatch = str;
+            bestScore = score;
+        }
+    }
+    return bestMatch;
+}
+
+class EventRelativePos {
+    constructor(target, top, right, bottom, left) {
+        this.target = target;
+        this.top = top;
+        this.right = right;
+        this.bottom = bottom;
+        this.left = left;
+        this.overflowsTop = top < 0;
+        this.overflowsRight = right < 0;
+        this.overflowsBottom = bottom < 0;
+        this.overflowsLeft = left < 0;
+        this.overflows =
+            this.overflowsTop ||
+                this.overflowsRight ||
+                this.overflowsBottom ||
+                this.overflowsLeft;
+    }
+    valueOf() {
+        return {
+            top: this.top,
+            right: this.right,
+            bottom: this.bottom,
+            left: this.left,
+        };
+    }
+    toJSON() {
+        return JSON.stringify(this.valueOf());
+    }
+    toString() {
+        return this.toJSON();
+    }
+    static fromEvent(event, el) {
+        return getEventRelativePos(event, el);
+    }
+}
+function _isTouchEvent(v) {
+    return typeof v === 'object' && 'touches' in v;
+}
+function getEventRelativePos(event, el) {
+    //convert ElementRef
+    if (el instanceof ElementRef)
+        el = el.nativeElement;
+    //convert TouchEvent
+    if (_isTouchEvent(event)) {
+        const firstTouch = event.touches.item(0);
+        if (!firstTouch)
+            throw new Error('DKT-FT9000: Cannot read event position. The TouchEvent has no Touch instances.');
+        event = firstTouch;
+    }
+    //calculate
+    const elRect = el.getBoundingClientRect();
+    const eventX = event.clientX;
+    const eventY = event.clientY;
+    return new EventRelativePos(el, eventY - elRect.top, //top
+    elRect.right - eventX, //right
+    elRect.bottom - eventY, //bottom
+    eventX - elRect.left);
+}
+
+const ASCII_REGEX = /^[\x00-\x7F]*$/;
+const BASE64_REGEX = /^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$/;
+const HEX_REGEX = /^[0-9a-fA-F]+$/;
+const OCTAL_REGEX = /^[0-7]+$/;
+const BINARY_REGEX = /^[0-1]+$/;
+const IPV4_REGEX = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+const IPV6_REGEX = /^(([0-9a-fA-F]{1,4}:){7}([0-9a-fA-F]{1,4}|:))|(([0-9a-fA-F]{1,4}:){1,7}:)|(([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4})|(([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2})|(([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3})|(([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4})|(([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5})|([0-9a-fA-F]{1,4}:)((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9])?[0-9])\.){3}(25[0-5]|(2[0-4]|1{0,1}[0-9])?[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9])?[0-9])\.){3}(25[0-5]|(2[0-4]|1{0,1}[0-9])?[0-9])$/;
+const UUID_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+const HEX_COLOR_REGEX = /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+const RGB_COLOR_REGEX = /^rgb\(\s*(0|255|25[0-4]|2[0-4][0-9]|1?[0-9]{1,2})\s*,\s*(0|255|25[0-4]|2[0-4][0-9]|1?[0-9]{1,2})\s*,\s*(0|255|25[0-4]|2[0-4][0-9]|1?[0-9]{1,2})\s*\)$/;
+const HSL_COLOR_REGEX = /^hsl\(\s*(360|3[0-5][0-9]|[12]?[0-9]{1,2})\s*,\s*(100|[1-9]?[0-9])%\s*,\s*(100|[1-9]?[0-9])%\s*\)$/;
+class ExtValidators {
+    /**
+     * Validator that requires the control's value to contain a certain substring.
+     *
+     * @param seed The substring that the control's value should contain.
+     * @returns A validator function that returns an error map with the `contains` property if the validation check fails, otherwise `null`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('ng', ExtValidators.contains('angular'));
+     * console.log(control.errors);
+     * // { contains: { actualValue: 'ng', shouldContain: 'angular' } }
+     *
+     * const control = new FormControl('I love angular', ExtValidators.contains('angular'));
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static contains(seed) {
+        return (control) => {
+            const value = control.value;
+            if (typeof value !== 'string') {
+                // don't validate empty values to allow optional controls
+                // don't validate non-string values to avoid false positives
+                return null;
+            }
+            if (value.includes(seed)) {
+                return null;
+            }
+            return { contains: { actualValue: value, shouldContain: seed } };
+        };
+    }
+    /**
+     * Validator that requires the control's value to not contain a certain substring.
+     *
+     * @param seed The substring that the control's value should not contain.
+     * @returns A validator function that returns an error map with the `notContains` property if the validation check fails, otherwise `null`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('angular', ExtValidators.notContains('ng'));
+     * console.log(control.errors);
+     * // { notContains: { actualValue: 'angular', shouldNotContain: 'ng' } }
+     *
+     * const control = new FormControl('angular', ExtValidators.notContains('react'));
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static notContains(seed) {
+        return (control) => {
+            const value = control.value;
+            if (typeof value !== 'string') {
+                // don't validate empty values to allow optional controls
+                // don't validate non-string values to avoid false positives
+                return null;
+            }
+            if (!value.includes(seed)) {
+                return null;
+            }
+            return { notContains: { actualValue: value, shouldNotContain: seed } };
+        };
+    }
+    /**
+     * Validator that requires the control's value to be in lowercase.
+     *
+     * @returns An error map with the `lowercase` property if the validation check fails, otherwise `null`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('Angular', ExtValidators.lowercase);
+     * console.log(control.errors);
+     * // { lowercase: { actualValue: 'Angular' } }
+     *
+     * const control = new FormControl('angular', ExtValidators.lowercase);
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static lowercase(control) {
+        const value = control.value;
+        if (typeof value !== 'string') {
+            // don't validate empty values to allow optional controls
+            // don't validate non-string values to avoid false positives
+            return null;
+        }
+        if (value === value.toLowerCase()) {
+            return null;
+        }
+        return { lowercase: { actualValue: value } };
+    }
+    /**
+     * Validator that requires the control's value to be in uppercase.
+     *
+     * @returns An error map with the `uppercase` property if the validation check fails, otherwise `null`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('Angular', ExtValidators.uppercase);
+     * console.log(control.errors);
+     * // { uppercase: { actualValue: 'Angular' } }
+     *
+     * const control = new FormControl('ANGULAR', ExtValidators.uppercase);
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static uppercase(control) {
+        const value = control.value;
+        if (typeof value !== 'string') {
+            // don't validate empty values to allow optional controls
+            // don't validate non-string values to avoid false positives
+            return null;
+        }
+        if (value === value.toUpperCase()) {
+            return null;
+        }
+        return { uppercase: { actualValue: value } };
+    }
+    /**
+     * Validator that wraps the built-in `Validators.pattern` but allows specifying a custom error name instead of the default `pattern` key.
+     *
+     * @param name The error name to use when the validation fails.
+     * @param pattern A string or RegExp to test the control's value against.
+     * @returns A `ValidatorFn` that returns an error map with the given `name` when the value does not match the pattern.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('abc-123', ExtValidators.namedPattern('sku', /^[A-Z]{3}-\d{3}$/));
+     * console.log(control.errors);
+     * // { sku: { actualValue: 'abc-123' } }
+     *
+     * const control = new FormControl('ABC-123', ExtValidators.namedPattern('sku', /^[A-Z]{3}-\d{3}$/));
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static namedPattern(name, pattern) {
+        const validator = Validators.pattern(pattern);
+        return (control) => {
+            const validationResult = validator(control);
+            if (validationResult === null) {
+                return null;
+            }
+            return {
+                [name]: { actualValue: validationResult['pattern'].actualValue },
+            };
+        };
+    }
+    /**
+     * Validator that requires the control's numeric value to be divisible by the given divisor.
+     *
+     * - Accepts numbers or numeric strings (uses `parseFloat`).
+     * - Does not validate `null`/`undefined` values to allow optional controls.
+     * - If `divisor` is `null`/`undefined`/`0`, validation is skipped and `null` is returned.
+     *
+     * @param divisor The number the control's value must be divisible by.
+     * @returns A validator function that returns `{ divisibleBy: { divisor, actual } }` when invalid, otherwise `null`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('12', ExtValidators.divisibleBy(5));
+     * console.log(control.errors);
+     * // { divisibleBy: { divisor: 5, actual: '12' } }
+     *
+     * const control = new FormControl('15', ExtValidators.divisibleBy(5));
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static divisibleBy(divisor) {
+        return (control) => {
+            if (control.value == null || divisor == null || divisor === 0) {
+                return null; // don't validate empty values to allow optional controls
+            }
+            const value = parseFloat(control.value);
+            // Controls with NaN values after parsing should be treated as not having a
+            // divisor, per the HTML forms spec: https://www.w3.org/TR/html5/forms.html#attr-input-min
+            return !isNaN(value) && value % divisor !== 0
+                ? { divisibleBy: { divisor: divisor, actual: control.value } }
+                : null;
+        };
+    }
+    /**
+     * Validator that requires the control's value to contain only ASCII characters.
+     *
+     * @param control The form control to validate.
+     * @returns `null` when valid (or when value is not a string), otherwise `{ ascii: { actualValue } }`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('Zażółć', ExtValidators.ascii);
+     * console.log(control.errors);
+     * // { ascii: { actualValue: 'Zażółć' } }
+     *
+     * const control = new FormControl('Hello!', ExtValidators.ascii);
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static ascii(control) {
+        const value = control.value;
+        if (typeof value !== 'string') {
+            // don't validate empty values to allow optional controls
+            // don't validate non-string values to avoid false positives
+            return null;
+        }
+        return ASCII_REGEX.test(value) ? null : { ascii: { actualValue: value } };
+    }
+    /**
+     * Validator that requires the control's value to be valid Base64 (RFC 4648-style alphabet).
+     *
+     * Notes:
+     * - This checks *format* (characters + padding), not whether the decoded bytes are meaningful.
+     * - Non-string / empty values are not validated to allow optional controls.
+     *
+     * @param control The form control to validate.
+     * @returns `null` when valid (or when value is not a string), otherwise `{ base64: { actualValue } }`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('hello world', ExtValidators.base64);
+     * console.log(control.errors);
+     * // { base64: { actualValue: 'hello world' } }
+     *
+     * const control = new FormControl('aGVsbG8=', ExtValidators.base64);
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static base64(control) {
+        const value = control.value;
+        if (typeof value !== 'string') {
+            // don't validate empty values to allow optional controls
+            // don't validate non-string values to avoid false positives
+            return null;
+        }
+        return BASE64_REGEX.test(value) ? null : { base64: { actualValue: value } };
+    }
+    /**
+     * Validator that requires the control's value to be a hexadecimal string.
+     *
+     * - Accepts upper and lower case characters.
+     * - Does not allow `0x` prefix (pure hex digits only).
+     *
+     * @param control The form control to validate.
+     * @returns `null` when valid (or when value is not a string), otherwise `{ hex: { actualValue } }`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('0xdeadbeef', ExtValidators.hex);
+     * console.log(control.errors);
+     * // { hex: { actualValue: '0xdeadbeef' } }
+     *
+     * const control = new FormControl('deadBEEF', ExtValidators.hex);
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static hex(control) {
+        const value = control.value;
+        if (typeof value !== 'string') {
+            // don't validate empty values to allow optional controls
+            // don't validate non-string values to avoid false positives
+            return null;
+        }
+        return HEX_REGEX.test(value) ? null : { hex: { actualValue: value } };
+    }
+    /**
+     * Validator that requires the control's value to be an octal string (digits 0-7 only).
+     *
+     * @param control The form control to validate.
+     * @returns `null` when valid (or when value is not a string), otherwise `{ octal: { actualValue } }`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('128', ExtValidators.octal);
+     * console.log(control.errors);
+     * // { octal: { actualValue: '128' } }
+     *
+     * const control = new FormControl('755', ExtValidators.octal);
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static octal(control) {
+        const value = control.value;
+        if (typeof value !== 'string') {
+            // don't validate empty values to allow optional controls
+            // don't validate non-string values to avoid false positives
+            return null;
+        }
+        return OCTAL_REGEX.test(value) ? null : { octal: { actualValue: value } };
+    }
+    /**
+     * Validator that requires the control's value to be a binary string (digits 0-1 only).
+     *
+     * @param control The form control to validate.
+     * @returns `null` when valid (or when value is not a string), otherwise `{ binary: { actualValue } }`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('10201', ExtValidators.binary);
+     * console.log(control.errors);
+     * // { binary: { actualValue: '10201' } }
+     *
+     * const control = new FormControl('101010', ExtValidators.binary);
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static binary(control) {
+        const value = control.value;
+        if (typeof value !== 'string') {
+            // don't validate empty values to allow optional controls
+            // don't validate non-string values to avoid false positives
+            return null;
+        }
+        return BINARY_REGEX.test(value) ? null : { binary: { actualValue: value } };
+    }
+    /**
+     * Validator that requires the control's value to be a valid IP address.
+     *
+     * @param ipType The required IP version (`4` for IPv4, `6` for IPv6).
+     * @returns A validator function that returns `{ ipAddress: { requiredType, actualValue } }` when invalid, otherwise `null`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('999.1.2.3', ExtValidators.ipAddress(4));
+     * console.log(control.errors);
+     * // { ipAddress: { requiredType: 'IPv4', actualValue: '999.1.2.3' } }
+     *
+     * const control = new FormControl('127.0.0.1', ExtValidators.ipAddress(4));
+     * console.log(control.errors);
+     * // null
+     * ```
+     *
+     * ```ts
+     * const control = new FormControl('not-an-ip', ExtValidators.ipAddress(6));
+     * console.log(control.errors);
+     * // { ipAddress: { requiredType: 'IPv6', actualValue: 'not-an-ip' } }
+     *
+     * const control = new FormControl('::1', ExtValidators.ipAddress(6));
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static ipAddress(ipType) {
+        return (control) => {
+            const value = control.value;
+            if (typeof value !== 'string') {
+                // don't validate empty values to allow optional controls
+                // don't validate non-string values to avoid false positives
+                return null;
+            }
+            if (ipType === 6) {
+                return IPV6_REGEX.test(value)
+                    ? null
+                    : {
+                        ipAddress: {
+                            requiredType: 6,
+                            actualValue: value,
+                        },
+                    };
+            }
+            if (ipType === 4) {
+                return IPV4_REGEX.test(value)
+                    ? null
+                    : { ipAddress: { requiredType: 4, actualValue: value } };
+            }
+            return IPV4_REGEX.test(value) || IPV6_REGEX.test(value)
+                ? null
+                : {
+                    ipAddress: { requiredType: 'any', actualValue: value },
+                };
+        };
+    }
+    /**
+     * Validator that requires the control's value to be a UUID string.
+     *
+     * Notes:
+     * - This validates the canonical 8-4-4-4-12 hex format.
+     * - It does not enforce UUID version/variant bits (it accepts any hex in those positions).
+     *
+     * @param control The form control to validate.
+     * @returns `null` when valid (or when value is not a string), otherwise `{ uuid: { actualValue } }`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('550e8400-e29b-41d4-a716-44665544ZZZZ', ExtValidators.uuid);
+     * console.log(control.errors);
+     * // { uuid: { actualValue: '550e8400-e29b-41d4-a716-44665544ZZZZ' } }
+     *
+     * const control = new FormControl('550e8400-e29b-41d4-a716-446655440000', ExtValidators.uuid);
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static uuid(control) {
+        const value = control.value;
+        if (typeof value !== 'string') {
+            // don't validate empty values to allow optional controls
+            // don't validate non-string values to avoid false positives
+            return null;
+        }
+        return UUID_REGEX.test(value) ? null : { uuid: { actualValue: value } };
+    }
+    /**
+     * Validator that requires the control's value to be a hex color.
+     *
+     * Accepts:
+     * - `#RGB` / `RGB`
+     * - `#RRGGBB` / `RRGGBB`
+     *
+     * @param control The form control to validate.
+     * @returns `null` when valid (or when value is not a string), otherwise `{ hexColor: { actualValue } }`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('#12FG00', ExtValidators.hexColor);
+     * console.log(control.errors);
+     * // { hexColor: { actualValue: '#12FG00' } }
+     *
+     * const control = new FormControl('#ff00aa', ExtValidators.hexColor);
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static hexColor(control) {
+        const value = control.value;
+        if (typeof value !== 'string') {
+            // don't validate empty values to allow optional controls
+            // don't validate non-string values to avoid false positives
+            return null;
+        }
+        return HEX_COLOR_REGEX.test(value)
+            ? null
+            : { hexColor: { actualValue: value } };
+    }
+    /**
+     * Validator that requires the control's value to be an `rgb(r, g, b)` CSS color string.
+     *
+     * Constraints:
+     * - `r`, `g`, `b` must be integers in the range 0..255
+     * - Whitespace is allowed
+     *
+     * @param control The form control to validate.
+     * @returns `null` when valid (or when value is not a string), otherwise `{ rgbColor: { actualValue } }`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('rgb(256, 0, 0)', ExtValidators.rgbColor);
+     * console.log(control.errors);
+     * // { rgbColor: { actualValue: 'rgb(256, 0, 0)' } }
+     *
+     * const control = new FormControl('rgb(255, 0, 128)', ExtValidators.rgbColor);
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static rgbColor(control) {
+        const value = control.value;
+        if (typeof value !== 'string') {
+            // don't validate empty values to allow optional controls
+            // don't validate non-string values to avoid false positives
+            return null;
+        }
+        return RGB_COLOR_REGEX.test(value)
+            ? null
+            : { rgbColor: { actualValue: value } };
+    }
+    /**
+     * Validator that requires the control's value to be an `hsl(h, s%, l%)` CSS color string.
+     *
+     * Constraints:
+     * - `h` (hue) must be an integer in the range 0..360
+     * - `s` and `l` must be percentages in the range 0..100
+     * - Whitespace is allowed
+     *
+     * @param control The form control to validate.
+     * @returns `null` when valid (or when value is not a string), otherwise `{ hslColor: { actualValue } }`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl('hsl(361, 50%, 40%)', ExtValidators.hslColor);
+     * console.log(control.errors);
+     * // { hslColor: { actualValue: 'hsl(361, 50%, 40%)' } }
+     *
+     * const control = new FormControl('hsl(210, 50%, 40%)', ExtValidators.hslColor);
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static hslColor(control) {
+        const value = control.value;
+        if (typeof value !== 'string') {
+            // don't validate empty values to allow optional controls
+            // don't validate non-string values to avoid false positives
+            return null;
+        }
+        return HSL_COLOR_REGEX.test(value)
+            ? null
+            : { hslColor: { actualValue: value } };
+    }
+    /**
+     * Validator factory for password-like rules.
+     *
+     * You can combine any subset of rules. Only rules that are enabled will be validated.
+     *
+     * Returned error shape:
+     * - `null` when valid
+     * - `{ password: { ...details } }` when invalid, where `details` may include:
+     *   - `minLength` / `maxLength` objects with required/actual lengths
+     *   - boolean flags: `requireNumbers`, `requireUppercase`, `requireLowercase`, `requireSpecialCharacters`
+     *
+     * Notes:
+     * - Special character set is: `[!@#$%^&*(),.?":{}|<>]`
+     * - Non-string / empty values are not validated to allow optional controls.
+     *
+     * @param rules Password rules configuration.
+     * @returns A validator function that returns a `password` error map when validation fails, otherwise `null`.
+     *
+     * @example
+     *
+     * Negative example (produces an error and shows the nested details):
+     *
+     * ```ts
+     * const control = new FormControl('password', ExtValidators.password({
+     *   minLength: 8,
+     *   requireNumbers: true,
+     *   requireUppercase: true,
+     *   requireSpecialCharacters: true,
+     * }));
+     *
+     * console.log(control.errors);
+     * // {
+     * //   password: {
+     * //     requireNumbers: true,
+     * //     requireUppercase: true,
+     * //     requireSpecialCharacters: true
+     * //   }
+     * // }
+     *
+     * const control = new FormControl('P@ssw0rd!', ExtValidators.password({
+     *   minLength: 8,
+     *   requireNumbers: true,
+     *   requireUppercase: true,
+     *   requireSpecialCharacters: true,
+     * }));
+     *
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static password(rules) {
+        return (control) => {
+            const value = control.value;
+            if (typeof value !== 'string') {
+                // don't validate empty values to allow optional controls
+                // don't validate non-string values to avoid false positives
+                return null;
+            }
+            const errors = {};
+            if (rules.minLength != null && value.length < rules.minLength) {
+                errors.minLength = {
+                    requiredLength: rules.minLength,
+                    actualLength: value.length,
+                };
+            }
+            if (rules.maxLength != null && value.length > rules.maxLength) {
+                errors.maxLength = {
+                    requiredLength: rules.maxLength,
+                    actualLength: value.length,
+                };
+            }
+            if (rules.requireNumbers && !/\d/.test(value)) {
+                errors.requireNumbers = true;
+            }
+            if (rules.requireUppercase && !/[A-Z]/.test(value)) {
+                errors.requireUppercase = true;
+            }
+            if (rules.requireLowercase && !/[a-z]/.test(value)) {
+                errors.requireLowercase = true;
+            }
+            if (rules.requireSpecialCharacters &&
+                !/[!@#$%^&*(),.?":{}|<>]/.test(value)) {
+                errors.requireSpecialCharacters = true;
+            }
+            return Object.keys(errors).length > 0 ? { password: errors } : null;
+        };
+    }
+    /**
+     * Validator that requires the control's value (an array) to contain a specific element.
+     *
+     * Non-array values are ignored to avoid false positives.
+     *
+     * @param seed The element that must exist in the array (uses `Array.prototype.includes`).
+     * @returns A validator function that returns `{ arrayContains: { actualValue, shouldContain } }` when invalid, otherwise `null`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl(['a', 'b'], ExtValidators.arrayContains('c'));
+     * console.log(control.errors);
+     * // { arrayContains: { actualValue: ['a', 'b'], shouldContain: 'c' } }
+     *
+     * const control = new FormControl(['a', 'b', 'c'], ExtValidators.arrayContains('c'));
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static arrayContains(seed) {
+        return (control) => {
+            const value = control.value;
+            if (!Array.isArray(value)) {
+                // don't validate non-array values to avoid false positives
+                return null;
+            }
+            if (value.includes(seed)) {
+                return null;
+            }
+            return { arrayContains: { actualValue: value, shouldContain: seed } };
+        };
+    }
+    /**
+     * Validator that requires the control's value (an array) to *not* contain a specific element.
+     *
+     * Non-array values are ignored to avoid false positives.
+     *
+     * @param seed The element that must not exist in the array (uses `Array.prototype.includes`).
+     * @returns A validator function that returns `{ arrayNotContains: { actualValue, shouldNotContain } }` when invalid, otherwise `null`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl(['a', 'b'], ExtValidators.arrayNotContains('b'));
+     * console.log(control.errors);
+     * // { arrayNotContains: { actualValue: ['a', 'b'], shouldNotContain: 'b' } }
+     *
+     * const control = new FormControl(['a', 'b'], ExtValidators.arrayNotContains('c'));
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static arrayNotContains(seed) {
+        return (control) => {
+            const value = control.value;
+            if (!Array.isArray(value)) {
+                // don't validate non-array values to avoid false positives
+                return null;
+            }
+            if (!value.includes(seed)) {
+                return null;
+            }
+            return {
+                arrayNotContains: { actualValue: value, shouldNotContain: seed },
+            };
+        };
+    }
+    /**
+     * Validator that requires the control's value (an array) to contain only unique items.
+     *
+     * Uses a `Set` to compare uniqueness (`Set.size === array.length`).
+     *
+     * @param control The form control to validate.
+     * @returns `null` when valid (or when value is not an array), otherwise `{ arrayUnique: { actualValue } }`.
+     *
+     * @example
+     *
+     * ```ts
+     * const control = new FormControl([1, 1, 2], ExtValidators.arrayUnique);
+     * console.log(control.errors);
+     * // { arrayUnique: { actualValue: [1, 1, 2] } }
+     *
+     * const control = new FormControl([1, 2, 3], ExtValidators.arrayUnique);
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static arrayUnique(control) {
+        const value = control.value;
+        if (!Array.isArray(value)) {
+            // don't validate non-array values to avoid false positives
+            return null;
+        }
+        const uniqueValues = new Set(value);
+        if (uniqueValues.size === value.length) {
+            return null;
+        }
+        return { arrayUnique: { actualValue: value } };
+    }
+    /**
+     * Validator factory that requires uploaded file(s) to be at most the given size.
+     *
+     * Supported control value shapes:
+     * - a single `File`
+     * - an array of files (typically `File[]`)
+     *
+     * Non-file values (or arrays with no `File` instances) are ignored to avoid false positives.
+     *
+     * Error shape:
+     * - If a single `File` was provided: `{ fileMaxSize: { requiredMaxSize, actualSize } }`
+     * - If an array was provided: `{ fileMaxSize: { requiredMaxSize, actualSizes } }` where `actualSizes` are the sizes of invalid files
+     *
+     * @param maxSizeInBytes Maximum allowed size in bytes.
+     * @returns A validator function that returns a `fileMaxSize` error map when invalid, otherwise `null`.
+     *
+     * @example
+     *
+     * Negative example (single file; produces an error):
+     *
+     * ```ts
+     * const big = new File([new Uint8Array(10)], 'big.txt'); // example only
+     * Object.defineProperty(big, 'size', { value: 10_000_000 }); // force size for demo
+     *
+     * const control = new FormControl<File | null>(big, ExtValidators.fileMaxSize(1_000));
+     * console.log(control.errors);
+     * // { fileMaxSize: { requiredMaxSize: 1000, actualSize: 10000000 } }
+     * ```
+     *
+     * Negative example (array; produces an error with `actualSizes`):
+     *
+     * ```ts
+     * const f1 = new File([new Uint8Array(1)], 'a.txt');
+     * const f2 = new File([new Uint8Array(1)], 'b.txt');
+     * Object.defineProperty(f1, 'size', { value: 500 });
+     * Object.defineProperty(f2, 'size', { value: 1500 });
+     *
+     * const control = new FormControl<File[]>([f1, f2], ExtValidators.fileMaxSize(1000));
+     * console.log(control.errors);
+     * // { fileMaxSize: { requiredMaxSize: 1000, actualSizes: [1500] } }
+     *
+     * const f = new File([new Uint8Array(1)], 'ok.txt');
+     * Object.defineProperty(f, 'size', { value: 500 });
+     *
+     * const control = new FormControl<File | null>(f, ExtValidators.fileMaxSize(1000));
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static fileMaxSize(maxSizeInBytes) {
+        return (control) => {
+            const value = control.value;
+            if (value == null) {
+                return null;
+            }
+            let isSingleFile = false;
+            let files = null;
+            if (value instanceof File) {
+                files = [value];
+                isSingleFile = true;
+            }
+            else if (Array.isArray(value)) {
+                files = value;
+            }
+            else {
+                // don't validate non-file/non-array values to avoid false positives
+                return null;
+            }
+            const fileInstances = files.filter((f) => f instanceof File);
+            if (fileInstances.length === 0) {
+                return null;
+            }
+            const invalid = fileInstances.filter((f) => f.size > maxSizeInBytes);
+            if (invalid.length === 0) {
+                return null;
+            }
+            // preserve single-file shape when only one file was provided
+            if (isSingleFile) {
+                return {
+                    fileMaxSize: {
+                        requiredMaxSize: maxSizeInBytes,
+                        actualSize: fileInstances[0].size,
+                    },
+                };
+            }
+            return {
+                fileMaxSize: {
+                    requiredMaxSize: maxSizeInBytes,
+                    actualSizes: invalid.map((f) => f.size),
+                },
+            };
+        };
+    }
+    /**
+     * Validator factory that requires uploaded file(s) to be at least the given size.
+     *
+     * Supported control value shapes:
+     * - a single `File`
+     * - an array of files (typically `File[]`)
+     *
+     * Non-file values (or arrays with no `File` instances) are ignored to avoid false positives.
+     *
+     * Error shape:
+     * - If a single `File` was provided: `{ fileMinSize: { requiredMinSize, actualSize } }`
+     * - If an array was provided: `{ fileMinSize: { requiredMinSize, actualSizes } }` where `actualSizes` are the sizes of invalid files
+     *
+     * @param minSizeInBytes Minimum allowed size in bytes.
+     * @returns A validator function that returns a `fileMinSize` error map when invalid, otherwise `null`.
+     *
+     * @example
+     *
+     * Negative example (single file; produces an error):
+     *
+     * ```ts
+     * const tiny = new File([new Uint8Array(1)], 'tiny.txt');
+     * Object.defineProperty(tiny, 'size', { value: 50 });
+     *
+     * const control = new FormControl<File | null>(tiny, ExtValidators.fileMinSize(100));
+     * console.log(control.errors);
+     * // { fileMinSize: { requiredMinSize: 100, actualSize: 50 } }
+     * ```
+     *
+     * Negative example (array; produces an error with `actualSizes`):
+     *
+     * ```ts
+     * const f1 = new File([new Uint8Array(1)], 'a.txt');
+     * const f2 = new File([new Uint8Array(1)], 'b.txt');
+     * Object.defineProperty(f1, 'size', { value: 50 });
+     * Object.defineProperty(f2, 'size', { value: 200 });
+     *
+     * const control = new FormControl<File[]>([f1, f2], ExtValidators.fileMinSize(100));
+     * console.log(control.errors);
+     * // { fileMinSize: { requiredMinSize: 100, actualSizes: [50] } }
+     *
+     * const ok = new File([new Uint8Array(1)], 'ok.txt');
+     * Object.defineProperty(ok, 'size', { value: 150 });
+     *
+     * const control = new FormControl<File | null>(ok, ExtValidators.fileMinSize(100));
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static fileMinSize(minSizeInBytes) {
+        return (control) => {
+            const value = control.value;
+            if (value == null) {
+                return null;
+            }
+            let isSingleFile = false;
+            let files = null;
+            if (value instanceof File) {
+                files = [value];
+                isSingleFile = true;
+            }
+            else if (Array.isArray(value)) {
+                files = value;
+            }
+            else {
+                // don't validate non-file/non-array values to avoid false positives
+                return null;
+            }
+            const fileInstances = files.filter((f) => f instanceof File);
+            if (fileInstances.length === 0) {
+                return null;
+            }
+            const invalid = fileInstances.filter((f) => f.size < minSizeInBytes);
+            if (invalid.length === 0) {
+                return null;
+            }
+            if (isSingleFile) {
+                return {
+                    fileMinSize: {
+                        requiredMinSize: minSizeInBytes,
+                        actualSize: fileInstances[0].size,
+                    },
+                };
+            }
+            return {
+                fileMinSize: {
+                    requiredMinSize: minSizeInBytes,
+                    actualSizes: invalid.map((f) => f.size),
+                },
+            };
+        };
+    }
+    /**
+     * Validator factory that requires uploaded file(s) to have an allowed extension.
+     *
+     * Supported control value shapes:
+     * - a single `File`
+     * - an array of files (typically `File[]`)
+     *
+     * Notes:
+     * - Extension is derived from the last `.` in the filename: `file.name.split('.').pop()`
+     * - The extracted extension is lowercased before checking.
+     * - `allowedExtensions` should be provided in lowercase to match the comparison.
+     *
+     * Error shape:
+     * - If a single `File` was provided: `{ fileExtension: { allowedExtensions, actualExtension } }`
+     * - If an array was provided: `{ fileExtension: { allowedExtensions, invalidFiles } }`
+     *
+     * @param allowedExtensions A list of allowed extensions (without dots), e.g. `['png', 'jpg', 'pdf']`.
+     * @returns A validator function that returns a `fileExtension` error map when invalid, otherwise `null`.
+     *
+     * @example
+     *
+     * Negative example (single file; produces an error):
+     *
+     * ```ts
+     * const file = new File([new Uint8Array(1)], 'report.exe');
+     * const control = new FormControl<File | null>(file, ExtValidators.fileExtension(['pdf', 'docx']));
+     * console.log(control.errors);
+     * // { fileExtension: { allowedExtensions: ['pdf', 'docx'], actualExtension: 'exe' } }
+     * ```
+     *
+     * Negative example (array; produces an error with invalid file names):
+     *
+     * ```ts
+     * const a = new File([new Uint8Array(1)], 'a.png');
+     * const b = new File([new Uint8Array(1)], 'b.exe');
+     *
+     * const control = new FormControl<File[]>([a, b], ExtValidators.fileExtension(['png', 'jpg']));
+     * console.log(control.errors);
+     * // { fileExtension: { allowedExtensions: ['png', 'jpg'], invalidFiles: ['b.exe'] } }
+     *
+     * const file = new File([new Uint8Array(1)], 'photo.jpg');
+     * const control = new FormControl<File | null>(file, ExtValidators.fileExtension(['png', 'jpg']));
+     * console.log(control.errors);
+     * // null
+     * ```
+     */
+    static fileExtension(allowedExtensions) {
+        return (control) => {
+            const value = control.value;
+            if (value == null) {
+                return null;
+            }
+            let isSingleFile = false;
+            let files = null;
+            if (value instanceof File) {
+                files = [value];
+                isSingleFile = true;
+            }
+            else if (Array.isArray(value)) {
+                files = value;
+            }
+            else {
+                // don't validate non-file/non-array values to avoid false positives
+                return null;
+            }
+            const fileInstances = files.filter((f) => f instanceof File);
+            if (fileInstances.length === 0) {
+                return null;
+            }
+            const invalidFiles = fileInstances.filter((f) => {
+                const ext = f.name.split('.').pop()?.toLowerCase() || '';
+                return !allowedExtensions.includes(ext);
+            });
+            if (invalidFiles.length === 0) {
+                return null;
+            }
+            if (isSingleFile) {
+                const fileExtension = fileInstances[0].name
+                    .split('.')
+                    .pop()
+                    ?.toLowerCase();
+                return {
+                    fileExtension: {
+                        allowedExtensions: allowedExtensions,
+                        actualExtension: fileExtension,
+                    },
+                };
+            }
+            return {
+                fileExtension: {
+                    allowedExtensions: allowedExtensions,
+                    invalidFiles: invalidFiles.map((f) => f.name),
+                },
+            };
+        };
+    }
+}
+
+/*
+ * Public API Surface of devkit
+ */
+//! feature group 0 - services
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ARD_FILE_PIPES_DEFAULTS, ARD_HOLD_DEFAULTS, ARD_INFINITE_SCROLL_DEFAULTS, ARD_VIEWPORT_OBSERVER_DEFAULTS, ArdInfScrollTarget, ArdViewportObserverRef, ArdiumClickOutsideDirective, ArdiumClickOutsideModule, ArdiumEscapeHTMLModule, ArdiumEscapeHTMLPipe, ArdiumFileExtensionPipe, ArdiumFileNamePipe, ArdiumFilePipesModule, ArdiumFileSizePipe, ArdiumHoldDirective, ArdiumHoldModule, ArdiumInfiniteScrollDirective, ArdiumInfiniteScrollModule, ArdiumViewportObserverService, EventRelativePos, ExtValidators, FileSystemMethod, FileSystemService, FileSystemStartDirectory, KeyboardService, PersistentStorageMethod, arraySignal, coerceArrayProperty, coerceBooleanProperty, coerceDateOnlyProperty, coerceDateProperty, coerceNumberProperty, counterSignal, createHttpService, debouncedSignal, escapeHTML, findBestAutocomplate, findBestSuggestions, formatFileExtension, formatFileName, formatFileSize, getDomContentRect, getDomPaddingRect, getEventRelativePos, getUTCDate, mapSignal, persistentSignal, provideFilePipesDefaults, provideHoldDefaults, provideInfiniteScrollDefaults, provideViewportObserverDefaults, queryParamSignal, queueSignal, setSignal, stackSignal, throttledSignal, trackBoundControl, trackFormControl, tupleSignal };
+//# sourceMappingURL=ardium-pl-devkit.mjs.map