@fundamental-ngx/cdk 0.38.3-rc.4

package/esm2020/utils/functions/key-util.mjs

@@ -0,0 +1,77 @@
+import { isDevMode } from '@angular/core';
+import { A, ALT, BACKSPACE, C, CONTROL, DASH, DELETE, DOWN_ARROW, END, ENTER, ESCAPE, HOME, LEFT_ARROW, META, NUMPAD_MINUS, PAGE_DOWN, PAGE_UP, RIGHT_ARROW, SHIFT, SPACE, TAB, UP_ARROW, V, X } from '@angular/cdk/keycodes';
+/** Map of keyCodes and their corresponding "key" values */
+const keyMap = new Map([
+    [RIGHT_ARROW, ['ArrowRight', 'Right']],
+    [DOWN_ARROW, ['ArrowDown', 'Down']],
+    [LEFT_ARROW, ['ArrowLeft', 'Left']],
+    [UP_ARROW, ['ArrowUp', 'Up']],
+    [SPACE, ['Space', 'Spacebar', ' ']],
+    [ESCAPE, ['Escape', 'Esc']],
+    [DELETE, ['Delete', 'Del']],
+    [ENTER, ['Enter']],
+    [TAB, ['Tab']],
+    [HOME, ['Home']],
+    [END, ['End']],
+    [ALT, ['Alt']],
+    [CONTROL, ['Ctrl', 'Control', 'Meta']],
+    [META, ['Meta']],
+    [SHIFT, ['Shift']],
+    [BACKSPACE, ['Backspace']],
+    [A, ['KeyA']],
+    [C, ['KeyC']],
+    [V, ['KeyV']],
+    [X, ['KeyX']],
+    [PAGE_UP, ['PageUp']],
+    [PAGE_DOWN, ['PageDown']],
+    [DASH, ['-']],
+    [NUMPAD_MINUS, ['-']]
+]);
+export class KeyUtil {
+    /**
+     * Function used to unify key identification across different browsers using KeyCodes
+     *
+     * @param event     - KeyboardEvent
+     * @param keyCode   - event.key name matching W3C specification / (ASSCI char. codes)
+     * */
+    static isKeyCode(event, keyCode) {
+        if (Array.isArray(keyCode)) {
+            return keyCode.some((key) => this.isKeyCode(event, key));
+        }
+        if (event && keyMap.get(keyCode)) {
+            return keyMap.get(keyCode)?.some((alias) => alias === event.key) || keyCode === event.keyCode;
+        }
+        if (isDevMode()) {
+            throw new Error(`Invalid function arguments. Check if "event" is a KeyboardEvent or "key" is defined in keyMap`);
+        }
+        return false;
+    }
+    /**
+     * Function used to unify key identification across different browsers
+     *
+     * @param event     - KeyboardEvent
+     * @param keyType   - Type of key
+     * */
+    static isKeyType(event, keyType) {
+        if (event && keyType) {
+            switch (keyType) {
+                case 'numeric':
+                    return event.code
+                        ? event.code.toLowerCase().includes('digit')
+                        : (event.keyCode >= 48 && event.keyCode <= 57) || (event.keyCode >= 96 && event.keyCode <= 105);
+                case 'alphabetical':
+                    return event.code
+                        ? event.code.toLowerCase().includes('key')
+                        : event.keyCode >= 65 && event.keyCode <= 90;
+                // some service commands as alt, ctr, insert, print, f4 etc. All except letters, numbers and symbols
+                case 'control':
+                    return event.keyCode < 48 || (event.keyCode >= 112 && event.keyCode <= 123);
+            }
+        }
+        if (isDevMode()) {
+            throw new Error(`Invalid function arguments.`);
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key-util.js","sourceRoot":"","sources":["../../../../../../libs/cdk/src/lib/utils/functions/key-util.ts"],"names":[],"mappings":"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","sourcesContent":["import { isDevMode } from '@angular/core';\nimport {\n    A,\n    ALT,\n    BACKSPACE,\n    C,\n    CONTROL,\n    DASH,\n    DELETE,\n    DOWN_ARROW,\n    END,\n    ENTER,\n    ESCAPE,\n    HOME,\n    LEFT_ARROW,\n    META,\n    NUMPAD_MINUS,\n    PAGE_DOWN,\n    PAGE_UP,\n    RIGHT_ARROW,\n    SHIFT,\n    SPACE,\n    TAB,\n    UP_ARROW,\n    V,\n    X\n} from '@angular/cdk/keycodes';\n\n/** Map of keyCodes and their corresponding \"key\" values */\nconst keyMap: Map<number, string[]> = new Map([\n    [RIGHT_ARROW, ['ArrowRight', 'Right']],\n    [DOWN_ARROW, ['ArrowDown', 'Down']],\n    [LEFT_ARROW, ['ArrowLeft', 'Left']],\n    [UP_ARROW, ['ArrowUp', 'Up']],\n    [SPACE, ['Space', 'Spacebar', ' ']],\n    [ESCAPE, ['Escape', 'Esc']],\n    [DELETE, ['Delete', 'Del']],\n    [ENTER, ['Enter']],\n    [TAB, ['Tab']],\n    [HOME, ['Home']],\n    [END, ['End']],\n    [ALT, ['Alt']],\n    [CONTROL, ['Ctrl', 'Control', 'Meta']],\n    [META, ['Meta']],\n    [SHIFT, ['Shift']],\n    [BACKSPACE, ['Backspace']],\n    [A, ['KeyA']],\n    [C, ['KeyC']],\n    [V, ['KeyV']],\n    [X, ['KeyX']],\n    [PAGE_UP, ['PageUp']],\n    [PAGE_DOWN, ['PageDown']],\n    [DASH, ['-']],\n    [NUMPAD_MINUS, ['-']]\n]);\n\nexport class KeyUtil {\n    /**\n     * Function used to unify key identification across different browsers using KeyCodes\n     *\n     * @param event     - KeyboardEvent\n     * @param keyCode   - event.key name matching W3C specification / (ASSCI char. codes)\n     * */\n    static isKeyCode(event: KeyboardEvent, keyCode: number | number[]): boolean {\n        if (Array.isArray(keyCode)) {\n            return keyCode.some((key) => this.isKeyCode(event, key));\n        }\n\n        if (event && keyMap.get(keyCode)) {\n            return keyMap.get(keyCode)?.some((alias) => alias === event.key) || keyCode === event.keyCode;\n        }\n\n        if (isDevMode()) {\n            throw new Error(\n                `Invalid function arguments. Check if \"event\" is a KeyboardEvent or \"key\" is defined in keyMap`\n            );\n        }\n\n        return false;\n    }\n\n    /**\n     * Function used to unify key identification across different browsers\n     *\n     * @param event     - KeyboardEvent\n     * @param keyType   - Type of key\n     * */\n    static isKeyType(event: KeyboardEvent, keyType: 'alphabetical' | 'numeric' | 'control'): boolean {\n        if (event && keyType) {\n            switch (keyType) {\n                case 'numeric':\n                    return event.code\n                        ? event.code.toLowerCase().includes('digit')\n                        : (event.keyCode >= 48 && event.keyCode <= 57) || (event.keyCode >= 96 && event.keyCode <= 105);\n                case 'alphabetical':\n                    return event.code\n                        ? event.code.toLowerCase().includes('key')\n                        : event.keyCode >= 65 && event.keyCode <= 90;\n                // some service commands as alt, ctr, insert, print, f4 etc. All except letters, numbers and symbols\n                case 'control':\n                    return event.keyCode < 48 || (event.keyCode >= 112 && event.keyCode <= 123);\n            }\n        }\n\n        if (isDevMode()) {\n            throw new Error(`Invalid function arguments.`);\n        }\n\n        return false;\n    }\n}\n"]}

package/esm2020/utils/functions/module-deprecations-provider.mjs

@@ -0,0 +1,18 @@
+import { ModuleDeprecations } from '../tokens/module-deprecations.token';
+/** Module deprecations provider */
+export function moduleDeprecationsProvider(classRef) {
+    return {
+        provide: ModuleDeprecations,
+        useClass: classRef,
+        multi: true
+    };
+}
+/** Module deprecations provider factory */
+export function moduleDeprecationsFactory(factory) {
+    return {
+        provide: ModuleDeprecations,
+        ...factory,
+        multi: true
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kdWxlLWRlcHJlY2F0aW9ucy1wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvdXRpbHMvZnVuY3Rpb25zL21vZHVsZS1kZXByZWNhdGlvbnMtcHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFFekUsbUNBQW1DO0FBQ25DLE1BQU0sVUFBVSwwQkFBMEIsQ0FBQyxRQUFhO0lBQ3BELE9BQU87UUFDSCxPQUFPLEVBQUUsa0JBQWtCO1FBQzNCLFFBQVEsRUFBRSxRQUFRO1FBQ2xCLEtBQUssRUFBRSxJQUFJO0tBQ2QsQ0FBQztBQUNOLENBQUM7QUFFRCwyQ0FBMkM7QUFDM0MsTUFBTSxVQUFVLHlCQUF5QixDQUFDLE9BQTRCO0lBQ2xFLE9BQU87UUFDSCxPQUFPLEVBQUUsa0JBQWtCO1FBQzNCLEdBQUcsT0FBTztRQUNWLEtBQUssRUFBRSxJQUFJO0tBQ2QsQ0FBQztBQUNOLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGYWN0b3J5U2Fuc1Byb3ZpZGVyLCBQcm92aWRlciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTW9kdWxlRGVwcmVjYXRpb25zIH0gZnJvbSAnLi4vdG9rZW5zL21vZHVsZS1kZXByZWNhdGlvbnMudG9rZW4nO1xuXG4vKiogTW9kdWxlIGRlcHJlY2F0aW9ucyBwcm92aWRlciAqL1xuZXhwb3J0IGZ1bmN0aW9uIG1vZHVsZURlcHJlY2F0aW9uc1Byb3ZpZGVyKGNsYXNzUmVmOiBhbnkpOiBQcm92aWRlciB7XG4gICAgcmV0dXJuIHtcbiAgICAgICAgcHJvdmlkZTogTW9kdWxlRGVwcmVjYXRpb25zLFxuICAgICAgICB1c2VDbGFzczogY2xhc3NSZWYsXG4gICAgICAgIG11bHRpOiB0cnVlXG4gICAgfTtcbn1cblxuLyoqIE1vZHVsZSBkZXByZWNhdGlvbnMgcHJvdmlkZXIgZmFjdG9yeSAqL1xuZXhwb3J0IGZ1bmN0aW9uIG1vZHVsZURlcHJlY2F0aW9uc0ZhY3RvcnkoZmFjdG9yeTogRmFjdG9yeVNhbnNQcm92aWRlcik6IFByb3ZpZGVyIHtcbiAgICByZXR1cm4ge1xuICAgICAgICBwcm92aWRlOiBNb2R1bGVEZXByZWNhdGlvbnMsXG4gICAgICAgIC4uLmZhY3RvcnksXG4gICAgICAgIG11bHRpOiB0cnVlXG4gICAgfTtcbn1cbiJdfQ==

package/esm2020/utils/functions/parser-file-size.mjs

@@ -0,0 +1,37 @@
+const fileSizeMap = new Map([
+    ['KB', 1024],
+    ['MB', 1048576],
+    ['GB', 1073741824],
+    ['TB', 1099511627776]
+]);
+/** Parse file size to bytes */
+export function parserFileSize(fileSize) {
+    if (fileSize === '') {
+        return 0;
+    }
+    const sizes = fileSize.match(/[\d.]+|\D+/g);
+    if (sizes && sizes.length > 1) {
+        const size = Number(sizes[0].replace(/ +/g, ''));
+        const unit = sizes[1].replace(/ +/g, '').toUpperCase();
+        const unitSize = fileSizeMap.get(unit);
+        if (isNaN(size)) {
+            throw new Error('FileSizeError - Invalid File size please check.');
+        }
+        if (unit === 'B' || unit === 'BYTE' || unit === 'BYTES') {
+            return size;
+        }
+        if (!unitSize) {
+            throw new Error('FileSizeError - Invalid File size please check.');
+        }
+        else {
+            return unitSize * size;
+        }
+    }
+    else {
+        if (isNaN(Number(sizes))) {
+            throw new Error('FileSizeError - Invalid File size please check.');
+        }
+        return Number(sizes);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/functions/random-color-accent.mjs

@@ -0,0 +1,5 @@
+/** Get random number from 1 to 10. */
+export function getRandomColorAccent() {
+    return (Math.floor(Math.random() * 10) + 1);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFuZG9tLWNvbG9yLWFjY2VudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvdXRpbHMvZnVuY3Rpb25zL3JhbmRvbS1jb2xvci1hY2NlbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsc0NBQXNDO0FBQ3RDLE1BQU0sVUFBVSxvQkFBb0I7SUFDaEMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxHQUFHLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FBZ0IsQ0FBQztBQUMvRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29sb3JBY2NlbnQgfSBmcm9tICcuLi9kYXRhdHlwZXMnO1xuXG4vKiogR2V0IHJhbmRvbSBudW1iZXIgZnJvbSAxIHRvIDEwLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldFJhbmRvbUNvbG9yQWNjZW50KCk6IENvbG9yQWNjZW50IHtcbiAgICByZXR1cm4gKE1hdGguZmxvb3IoTWF0aC5yYW5kb20oKSAqIDEwKSArIDEpIGFzIENvbG9yQWNjZW50O1xufVxuIl19

package/esm2020/utils/functions/resize-observable.mjs

@@ -0,0 +1,33 @@
+import { fromEvent, Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+/**
+ * RxJS wrapper for ResizeObserver class.
+ * @param target HTML element to spy on.
+ * @param options @see {ResizeObserverOptions}
+ * @returns {Observable} with observer entries.
+ */
+export function resizeObservable(target, options) {
+    if ('ResizeObserver' in window) {
+        return new Observable((subscriber) => {
+            let animationFrame;
+            const ro = new ResizeObserver((entries) => {
+                animationFrame = window.requestAnimationFrame(() => {
+                    subscriber.next(entries);
+                });
+            });
+            ro.observe(target, options);
+            return function unsubscribe() {
+                if (animationFrame) {
+                    window.cancelAnimationFrame(animationFrame);
+                }
+                ro.unobserve(target);
+                ro.disconnect();
+            };
+        });
+    }
+    else {
+        // If current browser does not support resizeObserver, rely on window resize and return empty array of items.
+        return fromEvent(window, 'resize').pipe(map(() => []));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/functions/scroll.mjs

@@ -0,0 +1,19 @@
+/**
+ * Function used to scroll specified element by some distance
+ *
+ * @param containerElement     - Container element scrolled
+ * @param distanceToScroll     - Distance of scroll in px
+ * */
+export function scrollTop(containerElement, distanceToScroll) {
+    // Check if scrollTo method is supported by current browser
+    if (containerElement.scrollTo && containerElement.scrollTo instanceof Function) {
+        containerElement.scrollTo({
+            top: distanceToScroll,
+            behavior: 'smooth'
+        });
+    }
+    else {
+        containerElement.scrollTop = distanceToScroll;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Nyb2xsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9mdW5jdGlvbnMvc2Nyb2xsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztLQUtLO0FBQ0wsTUFBTSxVQUFVLFNBQVMsQ0FBQyxnQkFBeUIsRUFBRSxnQkFBd0I7SUFDekUsMkRBQTJEO0lBQzNELElBQUksZ0JBQWdCLENBQUMsUUFBUSxJQUFJLGdCQUFnQixDQUFDLFFBQVEsWUFBWSxRQUFRLEVBQUU7UUFDNUUsZ0JBQWdCLENBQUMsUUFBUSxDQUFDO1lBQ3RCLEdBQUcsRUFBRSxnQkFBZ0I7WUFDckIsUUFBUSxFQUFFLFFBQVE7U0FDckIsQ0FBQyxDQUFDO0tBQ047U0FBTTtRQUNILGdCQUFnQixDQUFDLFNBQVMsR0FBRyxnQkFBZ0IsQ0FBQztLQUNqRDtBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEZ1bmN0aW9uIHVzZWQgdG8gc2Nyb2xsIHNwZWNpZmllZCBlbGVtZW50IGJ5IHNvbWUgZGlzdGFuY2VcbiAqXG4gKiBAcGFyYW0gY29udGFpbmVyRWxlbWVudCAgICAgLSBDb250YWluZXIgZWxlbWVudCBzY3JvbGxlZFxuICogQHBhcmFtIGRpc3RhbmNlVG9TY3JvbGwgICAgIC0gRGlzdGFuY2Ugb2Ygc2Nyb2xsIGluIHB4XG4gKiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNjcm9sbFRvcChjb250YWluZXJFbGVtZW50OiBFbGVtZW50LCBkaXN0YW5jZVRvU2Nyb2xsOiBudW1iZXIpOiB2b2lkIHtcbiAgICAvLyBDaGVjayBpZiBzY3JvbGxUbyBtZXRob2QgaXMgc3VwcG9ydGVkIGJ5IGN1cnJlbnQgYnJvd3NlclxuICAgIGlmIChjb250YWluZXJFbGVtZW50LnNjcm9sbFRvICYmIGNvbnRhaW5lckVsZW1lbnQuc2Nyb2xsVG8gaW5zdGFuY2VvZiBGdW5jdGlvbikge1xuICAgICAgICBjb250YWluZXJFbGVtZW50LnNjcm9sbFRvKHtcbiAgICAgICAgICAgIHRvcDogZGlzdGFuY2VUb1Njcm9sbCxcbiAgICAgICAgICAgIGJlaGF2aW9yOiAnc21vb3RoJ1xuICAgICAgICB9KTtcbiAgICB9IGVsc2Uge1xuICAgICAgICBjb250YWluZXJFbGVtZW50LnNjcm9sbFRvcCA9IGRpc3RhbmNlVG9TY3JvbGw7XG4gICAgfVxufVxuIl19

package/esm2020/utils/functions/uuidv4-generator.mjs

@@ -0,0 +1,12 @@
+/** Generate a UUID v4 */
+export function uuidv4() {
+    const modifier = 16;
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        // eslint-disable-next-line no-bitwise
+        const r = (Math.random() * modifier) | 0, 
+        // eslint-disable-next-line no-bitwise
+        v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(modifier);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXVpZHY0LWdlbmVyYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvdXRpbHMvZnVuY3Rpb25zL3V1aWR2NC1nZW5lcmF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEseUJBQXlCO0FBQ3pCLE1BQU0sVUFBVSxNQUFNO0lBQ2xCLE1BQU0sUUFBUSxHQUFHLEVBQUUsQ0FBQztJQUNwQixPQUFPLHNDQUFzQyxDQUFDLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRTtRQUNqRSxzQ0FBc0M7UUFDdEMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLEdBQUcsUUFBUSxDQUFDLEdBQUcsQ0FBQztRQUNwQyxzQ0FBc0M7UUFDdEMsQ0FBQyxHQUFHLENBQUMsS0FBSyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsR0FBRyxDQUFDLEdBQUcsR0FBRyxDQUFDO1FBQ3hDLE9BQU8sQ0FBQyxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUNoQyxDQUFDLENBQUMsQ0FBQztBQUNQLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogR2VuZXJhdGUgYSBVVUlEIHY0ICovXG5leHBvcnQgZnVuY3Rpb24gdXVpZHY0KCk6IHN0cmluZyB7XG4gICAgY29uc3QgbW9kaWZpZXIgPSAxNjtcbiAgICByZXR1cm4gJ3h4eHh4eHh4LXh4eHgtNHh4eC15eHh4LXh4eHh4eHh4eHh4eCcucmVwbGFjZSgvW3h5XS9nLCAoYykgPT4ge1xuICAgICAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgbm8tYml0d2lzZVxuICAgICAgICBjb25zdCByID0gKE1hdGgucmFuZG9tKCkgKiBtb2RpZmllcikgfCAwLFxuICAgICAgICAgICAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWJpdHdpc2VcbiAgICAgICAgICAgIHYgPSBjID09PSAneCcgPyByIDogKHIgJiAweDMpIHwgMHg4O1xuICAgICAgICByZXR1cm4gdi50b1N0cmluZyhtb2RpZmllcik7XG4gICAgfSk7XG59XG4iXX0=

package/esm2020/utils/fundamental-ngx-cdk-utils.mjs

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

package/esm2020/utils/helpers/get-native-element.mjs

@@ -0,0 +1,18 @@
+import { coerceElement } from '@angular/cdk/coercion';
+/**
+ * Retrieves native element from ElementRef.
+ */
+export function getNativeElement(element) {
+    let coercible = element;
+    if (isHasElementRef(element)) {
+        coercible = element.elementRef();
+    }
+    return coerceElement(coercible);
+}
+/**
+ * Checks whether object has element reference in it.
+ */
+export function isHasElementRef(something) {
+    return something && typeof something['elementRef'] === 'function';
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LW5hdGl2ZS1lbGVtZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9oZWxwZXJzL2dldC1uYXRpdmUtZWxlbWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFHdEQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsZ0JBQWdCLENBQzVCLE9BQTREO0lBRTVELElBQUksU0FBUyxHQUFHLE9BQU8sQ0FBQztJQUN4QixJQUFJLGVBQWUsQ0FBSSxPQUFPLENBQUMsRUFBRTtRQUM3QixTQUFTLEdBQUcsT0FBTyxDQUFDLFVBQVUsRUFBRSxDQUFDO0tBQ3BDO0lBQ0QsT0FBTyxhQUFhLENBQUMsU0FBOEIsQ0FBQyxDQUFDO0FBQ3pELENBQUM7QUFFRDs7R0FFRztBQUNILE1BQU0sVUFBVSxlQUFlLENBQzNCLFNBQWM7SUFFZCxPQUFPLFNBQVMsSUFBSSxPQUFPLFNBQVMsQ0FBQyxZQUFZLENBQUMsS0FBSyxVQUFVLENBQUM7QUFDdEUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNvZXJjZUVsZW1lbnQgfSBmcm9tICdAYW5ndWxhci9jZGsvY29lcmNpb24nO1xuaW1wb3J0IHsgRWxlbWVudFJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIFJldHJpZXZlcyBuYXRpdmUgZWxlbWVudCBmcm9tIEVsZW1lbnRSZWYuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXROYXRpdmVFbGVtZW50PFQgZXh0ZW5kcyBFbGVtZW50ID0gSFRNTEVsZW1lbnQ+KFxuICAgIGVsZW1lbnQ6IHsgZWxlbWVudFJlZigpOiBFbGVtZW50UmVmPFQ+IH0gfCBUIHwgRWxlbWVudFJlZjxUPlxuKTogVCB7XG4gICAgbGV0IGNvZXJjaWJsZSA9IGVsZW1lbnQ7XG4gICAgaWYgKGlzSGFzRWxlbWVudFJlZjxUPihlbGVtZW50KSkge1xuICAgICAgICBjb2VyY2libGUgPSBlbGVtZW50LmVsZW1lbnRSZWYoKTtcbiAgICB9XG4gICAgcmV0dXJuIGNvZXJjZUVsZW1lbnQoY29lcmNpYmxlIGFzIFQgfCBFbGVtZW50UmVmPFQ+KTtcbn1cblxuLyoqXG4gKiBDaGVja3Mgd2hldGhlciBvYmplY3QgaGFzIGVsZW1lbnQgcmVmZXJlbmNlIGluIGl0LlxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNIYXNFbGVtZW50UmVmPFQgZXh0ZW5kcyBFbGVtZW50ID0gSFRNTEVsZW1lbnQ+KFxuICAgIHNvbWV0aGluZzogYW55XG4pOiBzb21ldGhpbmcgaXMgeyBlbGVtZW50UmVmKCk6IEVsZW1lbnRSZWY8VD4gfSB7XG4gICAgcmV0dXJuIHNvbWV0aGluZyAmJiB0eXBlb2Ygc29tZXRoaW5nWydlbGVtZW50UmVmJ10gPT09ICdmdW5jdGlvbic7XG59XG4iXX0=

package/esm2020/utils/helpers/index.mjs

@@ -0,0 +1,3 @@
+export * from './range-selector';
+export * from './get-native-element';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2hlbHBlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9yYW5nZS1zZWxlY3Rvcic7XG5leHBvcnQgKiBmcm9tICcuL2dldC1uYXRpdmUtZWxlbWVudCc7XG4iXX0=

package/esm2020/utils/helpers/range-selector.mjs

@@ -0,0 +1,117 @@
+import { isNumber } from '../typecheck';
+/**
+ * Utility type, that allows to track and select ranges of elements while using multi-selection.
+ *
+ * @usage
+ * Imagine we have a simple list of checkboxes:
+ * ```html
+ * <input
+ *  #checkboxInput
+ *  *ngFor="let o of options; let idx = index"
+ *  type="checkbox"
+ *  [checked]="selectionModel.checked(o)"
+ *  (click)="toggle(idx, $event)"
+ *  >
+ * ```
+ * With the given layout the logic should be as follows:
+ * ```typescript
+ * export class YourComponent {
+ *  options = ['a', 'b', 'c'];
+ *  readonly selectionModel = new SelectionModel(true);
+ *
+ *  private readonly _rangeSelector = new RangeSelector();
+ *
+ *
+ *  toggle(idx: number, event: PointerEvent): void {
+ *      // getting the toggled value of the checkbox
+ *      const toggledSelection = event.target.value;
+ *
+ *      // registering the selection of current checkbox
+ *      this._rangeSelector.onRangeElementToggled(idx, event);
+ *
+ *      // Apply value to each element in range.
+ *      // If checkbox was toggled without shift pressed or without previously selected one,
+ *      // this method will select only it.
+ *      this._rangeSelector.applyValueToEachInRange(idx => {
+ *          if (toggledSelection) {
+ *              this.selectionModel.select(options[idx]);
+ *          } else {
+ *              this.selectionModel.deselect(options[idx]);
+ *          }
+ *      });
+ *  }
+ * }
+ * ```
+ */
+export class RangeSelector {
+    constructor() {
+        /** @hidden */
+        this._previousSelectedIndex = null;
+    }
+    /**
+     * Last registered selection state (either multiple or single).
+     * Is updated on each `onRangeElementClicked` invokation. Will be `null` initially or once `reset()` is called.
+     */
+    get lastRangeSelectionState() {
+        return this._state ? { ...this._state } : null;
+    }
+    /**
+     * The method that should be used to register each checkbox toggle.
+     * Accepts two arguments: `index` and `event`. If none provided, will reset existing state.
+     * Otherwise will register current index as last checked.
+     *
+     * If toggling was done with "shift" pressed and there's a previously registered index, will register a range selection.
+     * At the same time if checkbox was toggled without shift pressed or without previously selected one, this method will select only it.
+     *
+     * After calling this method it's recommended to use `applyValueToEachInRange` to actually toggle each checkbox in range.
+     *
+     * See usage example on this class itself.
+     */
+    onRangeElementToggled(index, event) {
+        if (this._isNonNegativeInteger(this._previousSelectedIndex) &&
+            this._isNonNegativeInteger(index) &&
+            event?.shiftKey) {
+            this._state = {
+                isRangeSelection: true,
+                from: Math.min(this._previousSelectedIndex, index),
+                to: Math.max(this._previousSelectedIndex, index)
+            };
+            this._previousSelectedIndex = index;
+        }
+        else if (this._isNonNegativeInteger(index)) {
+            this._state = { isRangeSelection: false, from: index, to: index };
+            this._previousSelectedIndex = index;
+        }
+        else {
+            this.reset();
+        }
+        return this.lastRangeSelectionState;
+    }
+    /**
+     * Allows to apply selection to each item in selection range.
+     * Accepts a function to apply selection to each item by registered index.
+     *
+     * See usage example on this class itself.
+     */
+    applyValueToEachInRange(selectionMethod) {
+        const state = this.lastRangeSelectionState;
+        if (!state) {
+            return;
+        }
+        if (this._isNonNegativeInteger(state?.from) && this._isNonNegativeInteger(state?.to)) {
+            for (let index = state.from; index <= state.to; index++) {
+                selectionMethod(index);
+            }
+        }
+    }
+    /** Resets selection state. Useful when the list of selectable items is changed (e.g. by filtering, sorting, page change) */
+    reset() {
+        this._state = null;
+        this._previousSelectedIndex = null;
+    }
+    /** @hidden */
+    _isNonNegativeInteger(num) {
+        return isNumber(num) && num >= 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"range-selector.js","sourceRoot":"","sources":["../../../../../../libs/cdk/src/lib/utils/helpers/range-selector.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,MAAM,OAAO,aAAa;IAA1B;QACI,cAAc;QACN,2BAAsB,GAAkB,IAAI,CAAC;IA4EzD,CAAC;IAxEG;;;OAGG;IACH,IAAI,uBAAuB;QACvB,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IACnD,CAAC;IAED;;;;;;;;;;;OAWG;IACH,qBAAqB,CAAC,KAAc,EAAE,KAA+C;QACjF,IACI,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,sBAAsB,CAAC;YACvD,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC;YACjC,KAAK,EAAE,QAAQ,EACjB;YACE,IAAI,CAAC,MAAM,GAAG;gBACV,gBAAgB,EAAE,IAAI;gBACtB,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,sBAAsB,EAAE,KAAK,CAAC;gBAClD,EAAE,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,sBAAsB,EAAE,KAAK,CAAC;aACnD,CAAC;YACF,IAAI,CAAC,sBAAsB,GAAG,KAAK,CAAC;SACvC;aAAM,IAAI,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,EAAE;YAC1C,IAAI,CAAC,MAAM,GAAG,EAAE,gBAAgB,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC;YAClE,IAAI,CAAC,sBAAsB,GAAG,KAAK,CAAC;SACvC;aAAM;YACH,IAAI,CAAC,KAAK,EAAE,CAAC;SAChB;QAED,OAAO,IAAI,CAAC,uBAAuB,CAAC;IACxC,CAAC;IAED;;;;;OAKG;IACH,uBAAuB,CAAC,eAAwC;QAC5D,MAAM,KAAK,GAAG,IAAI,CAAC,uBAAuB,CAAC;QAE3C,IAAI,CAAC,KAAK,EAAE;YACR,OAAO;SACV;QAED,IAAI,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,EAAE,CAAC,EAAE;YAClF,KAAK,IAAI,KAAK,GAAG,KAAK,CAAC,IAAI,EAAE,KAAK,IAAI,KAAK,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE;gBACrD,eAAe,CAAC,KAAK,CAAC,CAAC;aAC1B;SACJ;IACL,CAAC;IAED,4HAA4H;IAC5H,KAAK;QACD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;IACvC,CAAC;IAED,cAAc;IACN,qBAAqB,CAAC,GAAqB;QAC/C,OAAO,QAAQ,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC;IACrC,CAAC;CACJ","sourcesContent":["import { Nullable } from '../models/nullable';\nimport { isNumber } from '../typecheck';\n\n/**\n * Utility type, that allows to track and select ranges of elements while using multi-selection.\n *\n * @usage\n * Imagine we have a simple list of checkboxes:\n * ```html\n * <input\n *  #checkboxInput\n *  *ngFor=\"let o of options; let idx = index\"\n *  type=\"checkbox\"\n *  [checked]=\"selectionModel.checked(o)\"\n *  (click)=\"toggle(idx, $event)\"\n *  >\n * ```\n * With the given layout the logic should be as follows:\n * ```typescript\n * export class YourComponent {\n *  options = ['a', 'b', 'c'];\n *  readonly selectionModel = new SelectionModel(true);\n *\n *  private readonly _rangeSelector = new RangeSelector();\n *\n *\n *  toggle(idx: number, event: PointerEvent): void {\n *      // getting the toggled value of the checkbox\n *      const toggledSelection = event.target.value;\n *\n *      // registering the selection of current checkbox\n *      this._rangeSelector.onRangeElementToggled(idx, event);\n *\n *      // Apply value to each element in range.\n *      // If checkbox was toggled without shift pressed or without previously selected one,\n *      // this method will select only it.\n *      this._rangeSelector.applyValueToEachInRange(idx => {\n *          if (toggledSelection) {\n *              this.selectionModel.select(options[idx]);\n *          } else {\n *              this.selectionModel.deselect(options[idx]);\n *          }\n *      });\n *  }\n * }\n * ```\n */\nexport class RangeSelector {\n    /** @hidden */\n    private _previousSelectedIndex: number | null = null;\n    /** @hidden */\n    private _state: RangeSelectionState | null;\n\n    /**\n     * Last registered selection state (either multiple or single).\n     * Is updated on each `onRangeElementClicked` invokation. Will be `null` initially or once `reset()` is called.\n     */\n    get lastRangeSelectionState(): RangeSelectionState | null {\n        return this._state ? { ...this._state } : null;\n    }\n\n    /**\n     * The method that should be used to register each checkbox toggle.\n     * Accepts two arguments: `index` and `event`. If none provided, will reset existing state.\n     * Otherwise will register current index as last checked.\n     *\n     * If toggling was done with \"shift\" pressed and there's a previously registered index, will register a range selection.\n     * At the same time if checkbox was toggled without shift pressed or without previously selected one, this method will select only it.\n     *\n     * After calling this method it's recommended to use `applyValueToEachInRange` to actually toggle each checkbox in range.\n     *\n     * See usage example on this class itself.\n     */\n    onRangeElementToggled(index?: number, event?: KeyboardEvent | MouseEvent | TouchEvent): RangeSelectionState | null {\n        if (\n            this._isNonNegativeInteger(this._previousSelectedIndex) &&\n            this._isNonNegativeInteger(index) &&\n            event?.shiftKey\n        ) {\n            this._state = {\n                isRangeSelection: true,\n                from: Math.min(this._previousSelectedIndex, index),\n                to: Math.max(this._previousSelectedIndex, index)\n            };\n            this._previousSelectedIndex = index;\n        } else if (this._isNonNegativeInteger(index)) {\n            this._state = { isRangeSelection: false, from: index, to: index };\n            this._previousSelectedIndex = index;\n        } else {\n            this.reset();\n        }\n\n        return this.lastRangeSelectionState;\n    }\n\n    /**\n     * Allows to apply selection to each item in selection range.\n     * Accepts a function to apply selection to each item by registered index.\n     *\n     * See usage example on this class itself.\n     */\n    applyValueToEachInRange(selectionMethod: (index: number) => void): void {\n        const state = this.lastRangeSelectionState;\n\n        if (!state) {\n            return;\n        }\n\n        if (this._isNonNegativeInteger(state?.from) && this._isNonNegativeInteger(state?.to)) {\n            for (let index = state.from; index <= state.to; index++) {\n                selectionMethod(index);\n            }\n        }\n    }\n\n    /** Resets selection state. Useful when the list of selectable items is changed (e.g. by filtering, sorting, page change) */\n    reset(): void {\n        this._state = null;\n        this._previousSelectedIndex = null;\n    }\n\n    /** @hidden */\n    private _isNonNegativeInteger(num: Nullable<number>): num is number {\n        return isNumber(num) && num >= 0;\n    }\n}\n\nexport interface RangeSelectionState {\n    isRangeSelection: boolean;\n    from: number;\n    to: number;\n}\n"]}

package/esm2020/utils/index.mjs

@@ -0,0 +1,19 @@
+export * from './utils.module';
+export * from './typecheck';
+export * from './coercion/array';
+export * from './models/nullable';
+export * from './consts';
+export * from './datatypes';
+export * from './decorators';
+export * from './directives';
+export * from './drag-and-drop';
+export * from './dynamic-component';
+export * from './functions';
+export * from './helpers';
+export * from './interfaces';
+export * from './list-item/list-item-utils';
+export * from './services';
+export * from './abstract-fd-ngx-class';
+export * from './pipes';
+export * from './tokens/module-deprecations.token';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0JBQWdCLENBQUM7QUFFL0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxvQ0FBb0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdXRpbHMubW9kdWxlJztcblxuZXhwb3J0ICogZnJvbSAnLi90eXBlY2hlY2snO1xuZXhwb3J0ICogZnJvbSAnLi9jb2VyY2lvbi9hcnJheSc7XG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9udWxsYWJsZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnN0cyc7XG5leHBvcnQgKiBmcm9tICcuL2RhdGF0eXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL2RlY29yYXRvcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9kaXJlY3RpdmVzJztcbmV4cG9ydCAqIGZyb20gJy4vZHJhZy1hbmQtZHJvcCc7XG5leHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZnVuY3Rpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vaGVscGVycyc7XG5leHBvcnQgKiBmcm9tICcuL2ludGVyZmFjZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9saXN0LWl0ZW0vbGlzdC1pdGVtLXV0aWxzJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9hYnN0cmFjdC1mZC1uZ3gtY2xhc3MnO1xuZXhwb3J0ICogZnJvbSAnLi9waXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL3Rva2Vucy9tb2R1bGUtZGVwcmVjYXRpb25zLnRva2VuJztcbiJdfQ==

package/esm2020/utils/interfaces/content-density.mjs

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

package/esm2020/utils/interfaces/css-class-builder.interface.mjs

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

package/esm2020/utils/interfaces/css-style-builder.interface.mjs

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

package/esm2020/utils/interfaces/has-element-ref.interface.mjs

@@ -0,0 +1,2 @@
+export const ELEMENT_REF_EXCEPTION = 'HasElementRef interface has to be implemented';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFzLWVsZW1lbnQtcmVmLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvdXRpbHMvaW50ZXJmYWNlcy9oYXMtZWxlbWVudC1yZWYuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BLE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLCtDQUErQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRWxlbWVudFJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgaW50ZXJmYWNlIEhhc0VsZW1lbnRSZWY8RWxlbWVudFR5cGUgZXh0ZW5kcyBFbGVtZW50ID0gSFRNTEVsZW1lbnQ+IHtcbiAgICBlbGVtZW50UmVmKCk6IEVsZW1lbnRSZWY8RWxlbWVudFR5cGU+O1xufVxuXG5leHBvcnQgY29uc3QgRUxFTUVOVF9SRUZfRVhDRVBUSU9OID0gJ0hhc0VsZW1lbnRSZWYgaW50ZXJmYWNlIGhhcyB0byBiZSBpbXBsZW1lbnRlZCc7XG4iXX0=

package/esm2020/utils/interfaces/index.mjs

@@ -0,0 +1,8 @@
+export * from './content-density';
+export * from './css-class-builder.interface';
+export * from './css-style-builder.interface';
+export * from './has-element-ref.interface';
+export * from './keyboard-support-item.interface';
+export * from './module-deprecation.interface';
+export * from './require.interface';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2ludGVyZmFjZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxxQkFBcUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29udGVudC1kZW5zaXR5JztcbmV4cG9ydCAqIGZyb20gJy4vY3NzLWNsYXNzLWJ1aWxkZXIuaW50ZXJmYWNlJztcbmV4cG9ydCAqIGZyb20gJy4vY3NzLXN0eWxlLWJ1aWxkZXIuaW50ZXJmYWNlJztcbmV4cG9ydCAqIGZyb20gJy4vaGFzLWVsZW1lbnQtcmVmLmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL2tleWJvYXJkLXN1cHBvcnQtaXRlbS5pbnRlcmZhY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9tb2R1bGUtZGVwcmVjYXRpb24uaW50ZXJmYWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcmVxdWlyZS5pbnRlcmZhY2UnO1xuIl19

package/esm2020/utils/interfaces/keyboard-support-item.interface.mjs

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

package/esm2020/utils/interfaces/module-deprecation.interface.mjs

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

package/esm2020/utils/interfaces/require.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWlyZS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL2ludGVyZmFjZXMvcmVxdWlyZS5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIFJlcXVpcmVBdExlYXN0T25lPFQsIEtleXMgZXh0ZW5kcyBrZXlvZiBUID0ga2V5b2YgVD4gPSBQaWNrPFQsIEV4Y2x1ZGU8a2V5b2YgVCwgS2V5cz4+ICZcbiAgICB7XG4gICAgICAgIFtLIGluIEtleXNdLT86IFJlcXVpcmVkPFBpY2s8VCwgSz4+ICYgUGFydGlhbDxQaWNrPFQsIEV4Y2x1ZGU8S2V5cywgSz4+PjtcbiAgICB9W0tleXNdO1xuXG5leHBvcnQgdHlwZSBSZXF1aXJlT25seU9uZTxULCBLZXlzIGV4dGVuZHMga2V5b2YgVCA9IGtleW9mIFQ+ID0gUGljazxULCBFeGNsdWRlPGtleW9mIFQsIEtleXM+PiAmXG4gICAge1xuICAgICAgICBbSyBpbiBLZXlzXS0/OiBSZXF1aXJlZDxQaWNrPFQsIEs+PiAmIFBhcnRpYWw8UmVjb3JkPEV4Y2x1ZGU8S2V5cywgSz4sIHVuZGVmaW5lZD4+O1xuICAgIH1bS2V5c107XG4iXX0=

package/esm2020/utils/list-item/list-item-utils.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const LIST_ITEM_COMPONENT = new InjectionToken('ListItemComponent');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC1pdGVtLXV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9saXN0LWl0ZW0vbGlzdC1pdGVtLXV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFL0MsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxjQUFjLENBQVcsbUJBQW1CLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBjb25zdCBMSVNUX0lURU1fQ09NUE9ORU5UID0gbmV3IEluamVjdGlvblRva2VuPHN0cmluZ1tdPignTGlzdEl0ZW1Db21wb25lbnQnKTtcblxuZXhwb3J0IGludGVyZmFjZSBMaXN0SXRlbUludGVyZmFjZSB7XG4gICAgc2VsZWN0ZWQ6IGJvb2xlYW47XG5cbiAgICBsaW5rOiBib29sZWFuO1xuXG4gICAgZm9jdXMoKTogdm9pZDtcbn1cbiJdfQ==

package/esm2020/utils/models/nullable.mjs

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

package/esm2020/utils/pipes/displayFn.pipe.mjs

@@ -0,0 +1,17 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DisplayFnPipe {
+    /** Transform value with display function. */
+    transform(value, displayFn, ...args) {
+        return displayFn(value, ...args);
+    }
+}
+DisplayFnPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DisplayFnPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+DisplayFnPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: DisplayFnPipe, name: "displayFnPipe" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: DisplayFnPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'displayFnPipe'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzcGxheUZuLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL3BpcGVzL2Rpc3BsYXlGbi5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDOztBQUtwRCxNQUFNLE9BQU8sYUFBYTtJQUN0Qiw2Q0FBNkM7SUFDN0MsU0FBUyxDQUFDLEtBQVUsRUFBRSxTQUFjLEVBQUUsR0FBRyxJQUFTO1FBQzlDLE9BQU8sU0FBUyxDQUFDLEtBQUssRUFBRSxHQUFHLElBQUksQ0FBQyxDQUFDO0lBQ3JDLENBQUM7OzBHQUpRLGFBQWE7d0dBQWIsYUFBYTsyRkFBYixhQUFhO2tCQUh6QixJQUFJO21CQUFDO29CQUNGLElBQUksRUFBRSxlQUFlO2lCQUN4QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQFBpcGUoe1xuICAgIG5hbWU6ICdkaXNwbGF5Rm5QaXBlJ1xufSlcbmV4cG9ydCBjbGFzcyBEaXNwbGF5Rm5QaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gICAgLyoqIFRyYW5zZm9ybSB2YWx1ZSB3aXRoIGRpc3BsYXkgZnVuY3Rpb24uICovXG4gICAgdHJhbnNmb3JtKHZhbHVlOiBhbnksIGRpc3BsYXlGbjogYW55LCAuLi5hcmdzOiBhbnkpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gZGlzcGxheUZuKHZhbHVlLCAuLi5hcmdzKTtcbiAgICB9XG59XG4iXX0=

package/esm2020/utils/pipes/filter-strings.pipe.mjs

@@ -0,0 +1,30 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FilterStringsPipe {
+    /**
+     * Performs filtering.
+     * @param values Array of items.
+     * @param params Search parameters.
+     */
+    transform(values = [], params) {
+        if (!params.searchTerm) {
+            return values;
+        }
+        if (params.key) {
+            values = values.filter((item) => item[params.key].toLocaleLowerCase().includes(params.searchTerm?.toLocaleLowerCase()));
+        }
+        else {
+            values = values.filter((item) => item.toLocaleLowerCase().includes(params.searchTerm?.toLocaleLowerCase()));
+        }
+        return values;
+    }
+}
+FilterStringsPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FilterStringsPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+FilterStringsPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: FilterStringsPipe, name: "fdFilterStrings" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FilterStringsPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'fdFilterStrings'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/pipes/index.mjs

@@ -0,0 +1,10 @@
+export * from './displayFn.pipe';
+export * from './filter-strings.pipe';
+export * from './is-compact.pipe';
+export * from './pipe.module';
+export * from './safe.pipe';
+export * from './search-highlight.pipe';
+export * from './truncate.pipe';
+export * from './two-digits.pipe';
+export * from './value-by-path.pipe';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL3BpcGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsc0JBQXNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Rpc3BsYXlGbi5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vZmlsdGVyLXN0cmluZ3MucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL2lzLWNvbXBhY3QucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3BpcGUubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vc2FmZS5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VhcmNoLWhpZ2hsaWdodC5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vdHJ1bmNhdGUucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3R3by1kaWdpdHMucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3ZhbHVlLWJ5LXBhdGgucGlwZSc7XG4iXX0=

package/esm2020/utils/pipes/is-compact.pipe.mjs

@@ -0,0 +1,16 @@
+import { Pipe } from '@angular/core';
+import { isCompactDensity } from './../functions/is-compact-density';
+import * as i0 from "@angular/core";
+export class IsCompactDensityPipe {
+    /** Check if the content density is compact. */
+    transform(size) {
+        return isCompactDensity(size);
+    }
+}
+IsCompactDensityPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: IsCompactDensityPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+IsCompactDensityPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: IsCompactDensityPipe, name: "isCompactDensity" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: IsCompactDensityPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'isCompactDensity' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtY29tcGFjdC5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9waXBlcy9pcy1jb21wYWN0LnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7QUFFcEQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sbUNBQW1DLENBQUM7O0FBR3JFLE1BQU0sT0FBTyxvQkFBb0I7SUFDN0IsK0NBQStDO0lBQy9DLFNBQVMsQ0FBQyxJQUFvQjtRQUMxQixPQUFPLGdCQUFnQixDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2xDLENBQUM7O2lIQUpRLG9CQUFvQjsrR0FBcEIsb0JBQW9COzJGQUFwQixvQkFBb0I7a0JBRGhDLElBQUk7bUJBQUMsRUFBRSxJQUFJLEVBQUUsa0JBQWtCLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb250ZW50RGVuc2l0eSB9IGZyb20gJy4uL2ludGVyZmFjZXMvY29udGVudC1kZW5zaXR5JztcbmltcG9ydCB7IGlzQ29tcGFjdERlbnNpdHkgfSBmcm9tICcuLy4uL2Z1bmN0aW9ucy9pcy1jb21wYWN0LWRlbnNpdHknO1xuXG5AUGlwZSh7IG5hbWU6ICdpc0NvbXBhY3REZW5zaXR5JyB9KVxuZXhwb3J0IGNsYXNzIElzQ29tcGFjdERlbnNpdHlQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gICAgLyoqIENoZWNrIGlmIHRoZSBjb250ZW50IGRlbnNpdHkgaXMgY29tcGFjdC4gKi9cbiAgICB0cmFuc2Zvcm0oc2l6ZTogQ29udGVudERlbnNpdHkpOiBib29sZWFuIHtcbiAgICAgICAgcmV0dXJuIGlzQ29tcGFjdERlbnNpdHkoc2l6ZSk7XG4gICAgfVxufVxuIl19