@ssv/ngx.ux 3.0.0-dev.36 → 3.0.0-dev.40

package/esm2022/index.mjs

@@ -0,0 +1,4 @@
+export { SsvUxModule } from "./ux.module";
+export * from "./viewport/index";
+export { VERSION } from "./version";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL25neC51eC9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUMxQyxjQUFjLGtCQUFrQixDQUFDO0FBRWpDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxXQUFXLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBTc3ZVeE1vZHVsZSB9IGZyb20gXCIuL3V4Lm1vZHVsZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdmlld3BvcnQvaW5kZXhcIjtcblxuZXhwb3J0IHsgVkVSU0lPTiB9IGZyb20gXCIuL3ZlcnNpb25cIjtcbiJdfQ==

package/esm2022/internal/internal.model.mjs

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

package/esm2022/platform/window.mjs

@@ -0,0 +1,31 @@
+import { InjectionToken, Injectable, inject } from "@angular/core";
+import * as i0 from "@angular/core";
+export const WINDOW = new InjectionToken("Window", {
+    factory: () => _window(),
+});
+export function _window() {
+    if (typeof window !== "undefined") {
+        return window;
+    }
+    return {};
+}
+export class WindowRef {
+    window = inject(WINDOW);
+    /** Window underlying native object. */
+    get native() {
+        return this.window;
+    }
+    /** Determines whether native element is supported or not. Generally `false` when executing in SSR. */
+    get hasNative() {
+        return !!this.native.window;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: WindowRef, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: WindowRef, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: WindowRef, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2luZG93LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9uZ3gudXgvc3JjL3BsYXRmb3JtL3dpbmRvdy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRW5FLE1BQU0sQ0FBQyxNQUFNLE1BQU0sR0FBRyxJQUFJLGNBQWMsQ0FBUyxRQUFRLEVBQUU7SUFDMUQsT0FBTyxFQUFFLEdBQUcsRUFBRSxDQUFDLE9BQU8sRUFBWTtDQUNsQyxDQUFDLENBQUM7QUFFSCxNQUFNLFVBQVUsT0FBTztJQUN0QixJQUFJLE9BQU8sTUFBTSxLQUFLLFdBQVcsRUFBRSxDQUFDO1FBQ25DLE9BQU8sTUFBTSxDQUFDO0lBQ2YsQ0FBQztJQUNELE9BQU8sRUFBRSxDQUFDO0FBQ1gsQ0FBQztBQUtELE1BQU0sT0FBTyxTQUFTO0lBRUosTUFBTSxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUV6Qyx1Q0FBdUM7SUFDdkMsSUFBSSxNQUFNO1FBQ1QsT0FBTyxJQUFJLENBQUMsTUFBZ0IsQ0FBQztJQUM5QixDQUFDO0lBRUQsc0dBQXNHO0lBQ3RHLElBQUksU0FBUztRQUNaLE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDO0lBQzdCLENBQUM7dUdBWlcsU0FBUzsyR0FBVCxTQUFTLGNBRlQsTUFBTTs7MkZBRU4sU0FBUztrQkFIckIsVUFBVTttQkFBQztvQkFDWCxVQUFVLEVBQUUsTUFBTTtpQkFDbEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiwgSW5qZWN0YWJsZSwgaW5qZWN0IH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcblxuZXhwb3J0IGNvbnN0IFdJTkRPVyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxXaW5kb3c+KFwiV2luZG93XCIsIHtcblx0ZmFjdG9yeTogKCkgPT4gX3dpbmRvdygpIGFzIFdpbmRvdyxcbn0pO1xuXG5leHBvcnQgZnVuY3Rpb24gX3dpbmRvdygpOiB1bmtub3duIHtcblx0aWYgKHR5cGVvZiB3aW5kb3cgIT09IFwidW5kZWZpbmVkXCIpIHtcblx0XHRyZXR1cm4gd2luZG93O1xuXHR9XG5cdHJldHVybiB7fTtcbn1cblxuQEluamVjdGFibGUoe1xuXHRwcm92aWRlZEluOiBcInJvb3RcIixcbn0pXG5leHBvcnQgY2xhc3MgV2luZG93UmVmIHtcblxuXHRwcml2YXRlIHJlYWRvbmx5IHdpbmRvdyA9IGluamVjdChXSU5ET1cpO1xuXG5cdC8qKiBXaW5kb3cgdW5kZXJseWluZyBuYXRpdmUgb2JqZWN0LiAqL1xuXHRnZXQgbmF0aXZlKCk6IFdpbmRvdyB7XG5cdFx0cmV0dXJuIHRoaXMud2luZG93IGFzIFdpbmRvdztcblx0fVxuXG5cdC8qKiBEZXRlcm1pbmVzIHdoZXRoZXIgbmF0aXZlIGVsZW1lbnQgaXMgc3VwcG9ydGVkIG9yIG5vdC4gR2VuZXJhbGx5IGBmYWxzZWAgd2hlbiBleGVjdXRpbmcgaW4gU1NSLiAqL1xuXHRnZXQgaGFzTmF0aXZlKCk6IGJvb2xlYW4ge1xuXHRcdHJldHVybiAhIXRoaXMubmF0aXZlLndpbmRvdztcblx0fVxuXG59XG4iXX0=

package/esm2022/ssv-ngx.ux.mjs

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

package/esm2022/ux.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from "@angular/core";
+import { SsvUxViewportModule } from "./viewport/viewport.module";
+import * as i0 from "@angular/core";
+const EXPORTED_IMPORTS = [
+    SsvUxViewportModule,
+];
+export class SsvUxModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: SsvUxModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.9", ngImport: i0, type: SsvUxModule, imports: [SsvUxViewportModule], exports: [SsvUxViewportModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: SsvUxModule, imports: [EXPORTED_IMPORTS, SsvUxViewportModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: SsvUxModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [EXPORTED_IMPORTS],
+                    exports: [EXPORTED_IMPORTS]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXgubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbGlicy9uZ3gudXgvc3JjL3V4Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDRCQUE0QixDQUFDOztBQUVqRSxNQUFNLGdCQUFnQixHQUFHO0lBQ3hCLG1CQUFtQjtDQUNuQixDQUFDO0FBTUYsTUFBTSxPQUFPLFdBQVc7dUdBQVgsV0FBVzt3R0FBWCxXQUFXLFlBUHZCLG1CQUFtQixhQUFuQixtQkFBbUI7d0dBT1AsV0FBVyxZQUhiLGdCQUFnQixFQUoxQixtQkFBbUI7OzJGQU9QLFdBQVc7a0JBSnZCLFFBQVE7bUJBQUM7b0JBQ1QsT0FBTyxFQUFFLENBQUMsZ0JBQWdCLENBQUM7b0JBQzNCLE9BQU8sRUFBRSxDQUFDLGdCQUFnQixDQUFDO2lCQUMzQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcblxuaW1wb3J0IHsgU3N2VXhWaWV3cG9ydE1vZHVsZSB9IGZyb20gXCIuL3ZpZXdwb3J0L3ZpZXdwb3J0Lm1vZHVsZVwiO1xuXG5jb25zdCBFWFBPUlRFRF9JTVBPUlRTID0gW1xuXHRTc3ZVeFZpZXdwb3J0TW9kdWxlLFxuXTtcblxuQE5nTW9kdWxlKHtcblx0aW1wb3J0czogW0VYUE9SVEVEX0lNUE9SVFNdLFxuXHRleHBvcnRzOiBbRVhQT1JURURfSU1QT1JUU11cbn0pXG5leHBvcnQgY2xhc3MgU3N2VXhNb2R1bGUge1xuXG59Il19

package/esm2022/version.mjs

@@ -0,0 +1,2 @@
+export const VERSION = "3.0.0-dev.40";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnMvbmd4LnV4L3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiMy4wLjAtZGV2LjQwXCI7XG4iXX0=

package/esm2022/viewport/index.mjs

@@ -0,0 +1,10 @@
+export * from "./viewport-data/index";
+export { SsvUxViewportModule } from "./viewport.module";
+export { provideSsvUxViewportOptions, VIEWPORT_OPTIONS, withViewportSsrDevice } from "./viewport.options";
+export { SsvViewportMatcherVarDirective, SsvViewportMatcherVarContext } from "./viewport-matcher-var.directive";
+export { SsvViewportMatcherDirective, SsvViewportMatcherContext } from "./viewport-matcher.directive";
+export { VIEWPORT_SSR_DEVICE, ViewportServerSizeService } from "./viewport-server-size.service";
+export { ComparisonOperation, DeviceType, ViewportSizeType, } from "./viewport.model";
+export { ViewportService } from "./viewport.service";
+export { generateViewportSizeType } from "./viewport.util";
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/viewport/viewport-data/index.mjs

@@ -0,0 +1,4 @@
+export { ViewportDataService } from "./viewport-data.service";
+export { ViewportDataPipe } from "./viewport-data.pipe";
+export { ViewportDataMatchStrategy } from "./viewport-data-matcher";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL25neC51eC9zcmMvdmlld3BvcnQvdmlld3BvcnQtZGF0YS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM5RCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN4RCxPQUFPLEVBQTJCLHlCQUF5QixFQUF5QyxNQUFNLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgVmlld3BvcnREYXRhU2VydmljZSB9IGZyb20gXCIuL3ZpZXdwb3J0LWRhdGEuc2VydmljZVwiO1xuZXhwb3J0IHsgVmlld3BvcnREYXRhUGlwZSB9IGZyb20gXCIuL3ZpZXdwb3J0LWRhdGEucGlwZVwiO1xuZXhwb3J0IHsgdHlwZSBWaWV3cG9ydERhdGFDb25maWcsIFZpZXdwb3J0RGF0YU1hdGNoU3RyYXRlZ3ksIHR5cGUgVmlld3BvcnREYXRhTWF0Y2hTdHJhdGVneUxpdGVyYWwgfSBmcm9tIFwiLi92aWV3cG9ydC1kYXRhLW1hdGNoZXJcIjtcbiJdfQ==

package/esm2022/viewport/viewport-data/viewport-data-matcher.mjs

@@ -0,0 +1,107 @@
+export var ViewportDataMatchStrategy;
+(function (ViewportDataMatchStrategy) {
+    /** Indicates that size should match exact or default. */
+    ViewportDataMatchStrategy[ViewportDataMatchStrategy["exact"] = 0] = "exact";
+    /** Indicates that size matches when exact match, first match smaller (down) or default. */
+    ViewportDataMatchStrategy[ViewportDataMatchStrategy["smaller"] = 1] = "smaller";
+    /** Indicates that size matches when exact match, first match larger (up) or default. */
+    ViewportDataMatchStrategy[ViewportDataMatchStrategy["larger"] = 2] = "larger";
+    /** Indicates that size matches when exact match, or it tries both smaller/larger (smaller is preferred) until match or default. */
+    ViewportDataMatchStrategy[ViewportDataMatchStrategy["closestSmallerFirst"] = 3] = "closestSmallerFirst";
+    /** Indicates that size matches when exact match, or it tries both larger/smaller (larger is preferred) until match or default. */
+    ViewportDataMatchStrategy[ViewportDataMatchStrategy["closestLargerFirst"] = 4] = "closestLargerFirst";
+})(ViewportDataMatchStrategy || (ViewportDataMatchStrategy = {}));
+/**
+ * Utility function to match data based on strategy and size.
+ *
+ * @param dataConfig Data config to generate rules based on.
+ * @param sizeType Size type to get data for.
+ * @param strategy Strategy to use when building rules.
+ * @param sizeTypes Available size types ordered by index type. (Can be obtained from `ViewportService`)
+ * @param sizeTypeMap Available size type map. (Can be obtained from `ViewportService`)
+ * @returns Returns the matched data value.
+ */
+export function matchViewportData(dataConfig, sizeType, strategy, sizeTypes, sizeTypeMap) {
+    const matchFn = matchStrategyHandlerMap[strategy];
+    if (!matchFn) {
+        throw Error(`matchViewportData: Viewport Data strategy not implemented. Strategy: '${strategy}'`);
+    }
+    const data = matchFn(dataConfig, sizeType, sizeTypes, sizeTypeMap);
+    if (data !== undefined) {
+        return data;
+    }
+    return dataConfig.default;
+}
+const matchStrategyHandlerMap = {
+    [ViewportDataMatchStrategy.exact]: matchWithExact,
+    [ViewportDataMatchStrategy.larger]: matchWithLargerMatch,
+    [ViewportDataMatchStrategy.smaller]: matchWithSmallerMatch,
+    [ViewportDataMatchStrategy.closestSmallerFirst]: matchWithClosestSmallerFirstMatch,
+    [ViewportDataMatchStrategy.closestLargerFirst]: matchWithClosestLargerFirstMatch,
+};
+function matchWithExact(dataConfig, currentSizeType) {
+    return dataConfig[currentSizeType.name];
+}
+function matchWithLargerMatch(dataConfig, currentSizeType, sizeTypes) {
+    let data = dataConfig[currentSizeType.name];
+    if (data !== undefined) {
+        return data;
+    }
+    const largestTypeIdx = sizeTypes[sizeTypes.length - 1].type;
+    if (currentSizeType.type >= largestTypeIdx) {
+        return undefined;
+    }
+    for (let index = currentSizeType.type; index < sizeTypes.length; index++) {
+        const sizeType = sizeTypes[index];
+        data = dataConfig[sizeType.name];
+        if (data !== undefined) {
+            return data;
+        }
+    }
+    return undefined;
+}
+function matchWithSmallerMatch(dataConfig, currentSizeType, sizeTypes) {
+    let data = dataConfig[currentSizeType.name];
+    if (data !== undefined) {
+        return data;
+    }
+    if (currentSizeType.type <= 0) {
+        return undefined;
+    }
+    // eslint-disable-next-line for-direction
+    for (let index = currentSizeType.type; index < sizeTypes.length; index--) {
+        const sizeType = sizeTypes[index];
+        data = dataConfig[sizeType.name];
+        if (data !== undefined) {
+            return data;
+        }
+    }
+    return undefined;
+}
+function matchWithClosestSmallerFirstMatch(dataConfig, currentSizeType, sizeTypes) {
+    return closestMatch(dataConfig, currentSizeType, sizeTypes, true);
+}
+function matchWithClosestLargerFirstMatch(dataConfig, currentSizeType, sizeTypes) {
+    return closestMatch(dataConfig, currentSizeType, sizeTypes, false);
+}
+function closestMatch(dataConfig, currentSizeType, sizeTypes, isSmallerFirst) {
+    let data = dataConfig[currentSizeType.name];
+    if (data !== undefined) {
+        return data;
+    }
+    let downIndex = currentSizeType.type;
+    let upIndex = currentSizeType.type;
+    for (let index = 0; index < sizeTypes.length; index++) {
+        for (const idx of isSmallerFirst ? [--downIndex, ++upIndex] : [++upIndex, --downIndex]) {
+            const sizeType = sizeTypes[idx];
+            if (sizeType) {
+                data = dataConfig[sizeType.name];
+                if (data !== undefined) {
+                    return data;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"viewport-data-matcher.js","sourceRoot":"","sources":["../../../../../../libs/ngx.ux/src/viewport/viewport-data/viewport-data-matcher.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Dictionary } from \"../../internal/internal.model\";\nimport type { ViewportSizeTypeInfo } from \"../viewport.model\";\n\nexport type ViewportDataConfig<TValue = unknown, TData = Dictionary<TValue>> = TData & {\n\tdefault?: TValue\n};\n\nexport enum ViewportDataMatchStrategy {\n\t/** Indicates that size should match exact or default. */\n\texact,\n\n\t/** Indicates that size matches when exact match, first match smaller (down) or default. */\n\tsmaller,\n\n\t/** Indicates that size matches when exact match, first match larger (up) or default. */\n\tlarger,\n\n\t/** Indicates that size matches when exact match, or it tries both smaller/larger (smaller is preferred) until match or default. */\n\tclosestSmallerFirst,\n\n\t/** Indicates that size matches when exact match, or it tries both larger/smaller (larger is preferred) until match or default. */\n\tclosestLargerFirst,\n}\nexport type ViewportDataMatchStrategyLiteral = keyof typeof ViewportDataMatchStrategy;\n\nexport interface ViewportDataMatcher<T = unknown> {\n\t(\n\t\tdataConfig: ViewportDataConfig<T>,\n\t\tcurrentSizeType: ViewportSizeTypeInfo,\n\t\tsizeTypes: ViewportSizeTypeInfo[],\n\t\tsizeTypeMap: Dictionary<ViewportSizeTypeInfo>,\n\t): T | undefined;\n}\n\n/**\n * Utility function to match data based on strategy and size.\n *\n * @param dataConfig Data config to generate rules based on.\n * @param sizeType Size type to get data for.\n * @param strategy Strategy to use when building rules.\n * @param sizeTypes Available size types ordered by index type. (Can be obtained from `ViewportService`)\n * @param sizeTypeMap Available size type map. (Can be obtained from `ViewportService`)\n * @returns Returns the matched data value.\n */\nexport function matchViewportData<T>(\n\tdataConfig: ViewportDataConfig<T>,\n\tsizeType: ViewportSizeTypeInfo,\n\tstrategy: ViewportDataMatchStrategy,\n\tsizeTypes: ViewportSizeTypeInfo[],\n\tsizeTypeMap: Dictionary<ViewportSizeTypeInfo>,\n): T | undefined {\n\tconst matchFn = matchStrategyHandlerMap[strategy];\n\tif (!matchFn) {\n\t\tthrow Error(`matchViewportData: Viewport Data strategy not implemented. Strategy: '${strategy}'`);\n\t}\n\tconst data = matchFn(dataConfig, sizeType, sizeTypes, sizeTypeMap) as T;\n\tif (data !== undefined) {\n\t\treturn data;\n\t}\n\treturn dataConfig.default;\n}\n\n\nconst matchStrategyHandlerMap: Dictionary<ViewportDataMatcher> = {\n\t[ViewportDataMatchStrategy.exact]: matchWithExact,\n\t[ViewportDataMatchStrategy.larger]: matchWithLargerMatch,\n\t[ViewportDataMatchStrategy.smaller]: matchWithSmallerMatch,\n\t[ViewportDataMatchStrategy.closestSmallerFirst]: matchWithClosestSmallerFirstMatch,\n\t[ViewportDataMatchStrategy.closestLargerFirst]: matchWithClosestLargerFirstMatch,\n};\n\nfunction matchWithExact<T>(\n\tdataConfig: ViewportDataConfig<T>,\n\tcurrentSizeType: ViewportSizeTypeInfo,\n): T | undefined {\n\treturn dataConfig[currentSizeType.name];\n}\n\nfunction matchWithLargerMatch<T>(\n\tdataConfig: ViewportDataConfig<T>,\n\tcurrentSizeType: ViewportSizeTypeInfo,\n\tsizeTypes: ViewportSizeTypeInfo[],\n): T | undefined {\n\tlet data = dataConfig[currentSizeType.name];\n\tif (data !== undefined) {\n\t\treturn data;\n\t}\n\n\tconst largestTypeIdx = sizeTypes[sizeTypes.length - 1].type;\n\tif (currentSizeType.type >= largestTypeIdx) {\n\t\treturn undefined;\n\t}\n\n\tfor (let index = currentSizeType.type; index < sizeTypes.length; index++) {\n\t\tconst sizeType = sizeTypes[index];\n\t\tdata = dataConfig[sizeType.name];\n\t\tif (data !== undefined) {\n\t\t\treturn data;\n\t\t}\n\t}\n\n\treturn undefined;\n}\n\nfunction matchWithSmallerMatch<T>(\n\tdataConfig: ViewportDataConfig<T>,\n\tcurrentSizeType: ViewportSizeTypeInfo,\n\tsizeTypes: ViewportSizeTypeInfo[],\n): T | undefined {\n\tlet data = dataConfig[currentSizeType.name];\n\tif (data !== undefined) {\n\t\treturn data;\n\t}\n\n\tif (currentSizeType.type <= 0) {\n\t\treturn undefined;\n\t}\n\n\t// eslint-disable-next-line for-direction\n\tfor (let index = currentSizeType.type; index < sizeTypes.length; index--) {\n\t\tconst sizeType = sizeTypes[index];\n\t\tdata = dataConfig[sizeType.name];\n\t\tif (data !== undefined) {\n\t\t\treturn data;\n\t\t}\n\t}\n\n\treturn undefined;\n}\n\nfunction matchWithClosestSmallerFirstMatch<T>(\n\tdataConfig: ViewportDataConfig<T>,\n\tcurrentSizeType: ViewportSizeTypeInfo,\n\tsizeTypes: ViewportSizeTypeInfo[],\n): T | undefined {\n\treturn closestMatch(dataConfig, currentSizeType, sizeTypes, true);\n}\n\nfunction matchWithClosestLargerFirstMatch<T>(\n\tdataConfig: ViewportDataConfig<T>,\n\tcurrentSizeType: ViewportSizeTypeInfo,\n\tsizeTypes: ViewportSizeTypeInfo[],\n): T | undefined {\n\treturn closestMatch(dataConfig, currentSizeType, sizeTypes, false);\n}\n\nfunction closestMatch<T>(\n\tdataConfig: ViewportDataConfig<T>,\n\tcurrentSizeType: ViewportSizeTypeInfo,\n\tsizeTypes: ViewportSizeTypeInfo[],\n\tisSmallerFirst: boolean\n): T | undefined {\n\tlet data = dataConfig[currentSizeType.name];\n\tif (data !== undefined) {\n\t\treturn data;\n\t}\n\n\tlet downIndex = currentSizeType.type;\n\tlet upIndex = currentSizeType.type;\n\n\t \n\tfor (let index = 0; index < sizeTypes.length; index++) {\n\t\tfor (const idx of isSmallerFirst ? [--downIndex, ++upIndex] : [++upIndex, --downIndex]) {\n\t\t\tconst sizeType = sizeTypes[idx];\n\t\t\tif (sizeType) {\n\t\t\t\tdata = dataConfig[sizeType.name];\n\t\t\t\tif (data !== undefined) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn undefined;\n}\n"]}

package/esm2022/viewport/viewport-data/viewport-data.pipe.mjs

@@ -0,0 +1,48 @@
+import { Subscription, tap } from "rxjs";
+import { Pipe, ChangeDetectorRef } from "@angular/core";
+import { ViewportDataMatchStrategy } from "./viewport-data-matcher";
+import { ViewportDataService } from "./viewport-data.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./viewport-data.service";
+export class ViewportDataPipe {
+    viewportData;
+    cdr;
+    markForTransform = true;
+    value;
+    data;
+    strategy;
+    data$$ = Subscription.EMPTY;
+    constructor(viewportData, cdr) {
+        this.viewportData = viewportData;
+        this.cdr = cdr;
+    }
+    transform(data, strategy) {
+        if (!this.markForTransform && data === this.data && strategy === this.strategy) {
+            return this.value;
+        }
+        this.data = data;
+        this.strategy = strategy;
+        this.data$$.unsubscribe();
+        this.data$$ = this.viewportData.get$(data, ViewportDataMatchStrategy[strategy]).pipe(tap(value => {
+            this.markForTransform = true;
+            this.value = value;
+            this.cdr.markForCheck();
+        })).subscribe();
+        this.markForTransform = false;
+        return this.value;
+    }
+    ngOnDestroy() {
+        this.data$$.unsubscribe();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: ViewportDataPipe, deps: [{ token: i1.ViewportDataService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.9", ngImport: i0, type: ViewportDataPipe, isStandalone: true, name: "ssvViewportData", pure: false });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: ViewportDataPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "ssvViewportData",
+                    pure: false,
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.ViewportDataService }, { type: i0.ChangeDetectorRef }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/viewport/viewport-data/viewport-data.service.mjs

@@ -0,0 +1,32 @@
+import { inject, Injectable } from "@angular/core";
+import { distinctUntilChanged, map } from "rxjs";
+import { ViewportService } from "../viewport.service";
+import { matchViewportData } from "./viewport-data-matcher";
+import { generateViewportRulesRangeFromDataMatcher } from "./viewport-data.utils";
+import { VIEWPORT_OPTIONS } from "../viewport.options";
+import * as i0 from "@angular/core";
+export class ViewportDataService {
+    viewport = inject(ViewportService);
+    config = inject(VIEWPORT_OPTIONS);
+    /** Get data for match. */
+    get(dataConfig, strategy = this.config.defaultDataMatchStrategy, sizeType = this.viewport.sizeTypeSnapshot) {
+        return matchViewportData(dataConfig, sizeType, strategy, this.viewport.sizeTypes, this.viewport.sizeTypeMap);
+    }
+    /** Get data for match as observable. */
+    get$(dataConfig, strategy, throttle = true) {
+        return (throttle ? this.viewport.sizeType$ : this.viewport.sizeTypeSnap$).pipe(map(sizeType => this.get(dataConfig, strategy, sizeType)), distinctUntilChanged());
+    }
+    /** Generate rules based on strategies for data. */
+    generateRules(dataConfig, strategy = this.config.defaultDataMatchStrategy) {
+        return generateViewportRulesRangeFromDataMatcher(dataConfig, strategy, this.viewport.sizeTypes, this.viewport.sizeTypeMap);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: ViewportDataService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: ViewportDataService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: ViewportDataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/viewport/viewport-data/viewport-data.utils.mjs

@@ -0,0 +1,100 @@
+import { ViewportDataMatchStrategy } from "./viewport-data-matcher";
+/**
+ * Utility function to generate rules based on strategies.
+ *
+ * @param dataConfig Data config to generate rules based on.
+ * @param strategy Strategy to use when building rules.
+ * @param sizeTypes Available size types ordered by index type. (Can be obtained from `ViewportService`)
+ * @param sizeTypeMap Available size type map. (Can be obtained from `ViewportService`)
+ * @returns Returns a collection of rules (ordered).
+ */
+export function generateViewportRulesRangeFromDataMatcher(dataConfig, strategy, sizeTypes, sizeTypeMap) {
+    const ruleBuilderFn = matchStrategyHandlerMap[strategy];
+    if (!ruleBuilderFn) {
+        throw Error(`generateViewportRulesRangeFromDataMatcher: Viewport Data strategy not implemented. Strategy: '${strategy}'`);
+    }
+    let dataSizes = [];
+    for (const key in dataConfig) {
+        if (Object.prototype.hasOwnProperty.call(dataConfig, key)) {
+            const data = dataConfig[key];
+            if (data === undefined) {
+                continue;
+            }
+            const size = sizeTypeMap[key];
+            if (size) {
+                dataSizes.push(size);
+            }
+        }
+    }
+    dataSizes = dataSizes.sort(({ type: typeA }, { type: typeB }) => typeA - typeB);
+    const rules = [];
+    if (dataConfig.default) {
+        rules.push({ value: dataConfig.default, min: undefined, max: undefined });
+    }
+    let prevRule;
+    for (let index = 0; index < dataSizes.length; index++) {
+        const prevDataSize = dataSizes[index - 1];
+        const nextDataSize = dataSizes[index + 1];
+        const dataSize = dataSizes[index];
+        const prevSize = sizeTypes[dataSize.type - 1];
+        // const nextSize = sizeTypes[dataSize.type + 1];
+        const data = dataConfig[dataSize.name];
+        const rule = {
+            value: data,
+            min: undefined,
+            max: undefined,
+        };
+        ruleBuilderFn(rule, dataSize, nextDataSize, prevDataSize, prevSize, prevRule, sizeTypes);
+        prevRule = rule;
+        rules.push(rule);
+    }
+    return rules;
+}
+const matchStrategyHandlerMap = {
+    [ViewportDataMatchStrategy.exact]: (rule, dataSize, _nextDataSize, _prevDataSize, prevSize) => {
+        rule.max = dataSize.widthThreshold;
+        if (prevSize) {
+            rule.min = prevSize.widthThreshold + 1;
+        }
+    },
+    [ViewportDataMatchStrategy.smaller]: (rule, dataSize, nextDataSize, _prevDataSize, prevSize) => {
+        if (nextDataSize) {
+            rule.max = dataSize.widthThreshold;
+        }
+        if (prevSize) {
+            rule.min = prevSize.widthThreshold + 1;
+        }
+    },
+    [ViewportDataMatchStrategy.larger]: (rule, dataSize, _nextDataSize, prevDataSize) => {
+        if (dataSize) {
+            rule.max = dataSize.widthThreshold;
+        }
+        if (prevDataSize) {
+            rule.min = prevDataSize.widthThreshold + 1;
+        }
+    },
+    [ViewportDataMatchStrategy.closestSmallerFirst]: (rule, dataSize, nextDataSize, _prevDataSize, _prevSize, prevRule, sizeTypes) => {
+        if (nextDataSize) {
+            rule.max = calculateClosestWidthThreshold(nextDataSize, dataSize, sizeTypes, true);
+        }
+        if (prevRule?.max) {
+            rule.min = prevRule.max + 1;
+        }
+    },
+    [ViewportDataMatchStrategy.closestLargerFirst]: (rule, dataSize, nextDataSize, _prevDataSize, _prevSize, prevRule, sizeTypes) => {
+        if (nextDataSize) {
+            rule.max = calculateClosestWidthThreshold(nextDataSize, dataSize, sizeTypes, false);
+        }
+        if (prevRule?.max) {
+            rule.min = prevRule.max + 1;
+        }
+    },
+};
+function calculateClosestWidthThreshold(nextDataSize, dataSize, sizeTypes, isSmallerPreferred) {
+    const fn = isSmallerPreferred ? Math.ceil : Math.floor;
+    // get closest between curr and next
+    const diffIndex = fn((nextDataSize.type - dataSize.type - 1) / 2);
+    const diffNextSize = sizeTypes[dataSize.type + diffIndex];
+    return (diffNextSize || dataSize).widthThreshold;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"viewport-data.utils.js","sourceRoot":"","sources":["../../../../../../libs/ngx.ux/src/viewport/viewport-data/viewport-data.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { Dictionary } from \"../../internal/internal.model\";\nimport { ViewportSizeTypeInfo } from \"../viewport.model\";\nimport { ViewportDataConfig, ViewportDataMatchStrategy } from \"./viewport-data-matcher\";\n\nexport interface ViewportDataRule<T> {\n\tmin?: number;\n\tmax?: number;\n\tvalue: T;\n}\n\n/**\n * Utility function to generate rules based on strategies.\n *\n * @param dataConfig Data config to generate rules based on.\n * @param strategy Strategy to use when building rules.\n * @param sizeTypes Available size types ordered by index type. (Can be obtained from `ViewportService`)\n * @param sizeTypeMap Available size type map. (Can be obtained from `ViewportService`)\n * @returns Returns a collection of rules (ordered).\n */\nexport function generateViewportRulesRangeFromDataMatcher<T>(\n\tdataConfig: ViewportDataConfig<T>,\n\tstrategy: ViewportDataMatchStrategy,\n\tsizeTypes: ViewportSizeTypeInfo[],\n\tsizeTypeMap: Dictionary<ViewportSizeTypeInfo>,\n): ViewportDataRule<T>[] {\n\tconst ruleBuilderFn = matchStrategyHandlerMap[strategy];\n\tif (!ruleBuilderFn) {\n\t\tthrow Error(`generateViewportRulesRangeFromDataMatcher: Viewport Data strategy not implemented. Strategy: '${strategy}'`);\n\t}\n\n\tlet dataSizes: ViewportSizeTypeInfo[] = [];\n\tfor (const key in dataConfig) {\n\t\tif (Object.prototype.hasOwnProperty.call(dataConfig, key)) {\n\t\t\tconst data = dataConfig[key];\n\t\t\tif (data === undefined) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst size = sizeTypeMap[key];\n\t\t\tif (size) {\n\t\t\t\tdataSizes.push(size);\n\t\t\t}\n\t\t}\n\t}\n\tdataSizes = dataSizes.sort(({ type: typeA }, { type: typeB }) => typeA - typeB);\n\n\tconst rules: ViewportDataRule<T>[] = [];\n\tif (dataConfig.default) {\n\t\trules.push({ value: dataConfig.default, min: undefined, max: undefined });\n\t}\n\n\tlet prevRule: ViewportDataRule<T> | undefined;\n\tfor (let index = 0; index < dataSizes.length; index++) {\n\t\tconst prevDataSize = dataSizes[index - 1];\n\t\tconst nextDataSize = dataSizes[index + 1];\n\t\tconst dataSize = dataSizes[index];\n\t\tconst prevSize = sizeTypes[dataSize.type - 1];\n\t\t// const nextSize = sizeTypes[dataSize.type + 1];\n\t\tconst data = dataConfig[dataSize.name];\n\t\tconst rule: ViewportDataRule<T> = {\n\t\t\tvalue: data,\n\t\t\tmin: undefined,\n\t\t\tmax: undefined,\n\t\t};\n\n\t\truleBuilderFn(rule, dataSize, nextDataSize, prevDataSize, prevSize, prevRule, sizeTypes);\n\n\t\tprevRule = rule;\n\t\trules.push(rule);\n\t}\n\treturn rules;\n}\n\nexport interface ViewportRuleRangeBuilder<T = unknown> {\n\t(\n\t\trule: ViewportDataRule<T>,\n\t\tdataSize: ViewportSizeTypeInfo,\n\t\tnextDataSize: ViewportSizeTypeInfo | undefined,\n\t\tprevDataSize: ViewportSizeTypeInfo | undefined,\n\t\tprevSize: ViewportSizeTypeInfo | undefined,\n\t\tprevRule: ViewportDataRule<T> | undefined,\n\t\tsizeTypes: ViewportSizeTypeInfo[],\n\t): void;\n}\n\nconst matchStrategyHandlerMap: Dictionary<ViewportRuleRangeBuilder> = {\n\t[ViewportDataMatchStrategy.exact]: (rule, dataSize, _nextDataSize, _prevDataSize, prevSize) => {\n\t\trule.max = dataSize.widthThreshold;\n\t\tif (prevSize) {\n\t\t\trule.min = prevSize.widthThreshold + 1;\n\t\t}\n\t},\n\t[ViewportDataMatchStrategy.smaller]: (rule, dataSize, nextDataSize, _prevDataSize, prevSize) => {\n\t\tif (nextDataSize) {\n\t\t\trule.max = dataSize.widthThreshold;\n\t\t}\n\t\tif (prevSize) {\n\t\t\trule.min = prevSize.widthThreshold + 1;\n\t\t}\n\t},\n\t[ViewportDataMatchStrategy.larger]: (rule, dataSize, _nextDataSize, prevDataSize) => {\n\t\tif (dataSize) {\n\t\t\trule.max = dataSize.widthThreshold;\n\t\t}\n\t\tif (prevDataSize) {\n\t\t\trule.min = prevDataSize.widthThreshold + 1;\n\t\t}\n\t},\n\t[ViewportDataMatchStrategy.closestSmallerFirst]: (rule, dataSize, nextDataSize, _prevDataSize, _prevSize, prevRule, sizeTypes) => {\n\t\tif (nextDataSize) {\n\t\t\trule.max = calculateClosestWidthThreshold(nextDataSize, dataSize, sizeTypes, true);\n\t\t}\n\t\tif (prevRule?.max) {\n\t\t\trule.min = prevRule.max + 1;\n\t\t}\n\t},\n\t[ViewportDataMatchStrategy.closestLargerFirst]: (rule, dataSize, nextDataSize, _prevDataSize, _prevSize, prevRule, sizeTypes) => {\n\t\tif (nextDataSize) {\n\t\t\trule.max = calculateClosestWidthThreshold(nextDataSize, dataSize, sizeTypes, false);\n\t\t}\n\t\tif (prevRule?.max) {\n\t\t\trule.min = prevRule.max + 1;\n\t\t}\n\t},\n};\n\nfunction calculateClosestWidthThreshold(\n\tnextDataSize: ViewportSizeTypeInfo,\n\tdataSize: ViewportSizeTypeInfo,\n\tsizeTypes: ViewportSizeTypeInfo[],\n\tisSmallerPreferred: boolean,\n) {\n\tconst fn = isSmallerPreferred ? Math.ceil : Math.floor;\n\t// get closest between curr and next\n\tconst diffIndex = fn((nextDataSize.type - dataSize.type - 1) / 2);\n\tconst diffNextSize = sizeTypes[dataSize.type + diffIndex];\n\treturn (diffNextSize || dataSize).widthThreshold;\n}\n"]}

package/esm2022/viewport/viewport-matcher-var.directive.mjs

@@ -0,0 +1,69 @@
+import { Directive, Input, TemplateRef, ViewContainerRef, } from "@angular/core";
+import { combineLatest, ReplaySubject, Subject, tap, map, takeUntil } from "rxjs";
+import { ViewportService } from "./viewport.service";
+import { isViewportSizeMatcherExpression, isViewportSizeMatcherTupleExpression, isViewportConditionMatch } from "./viewport.util";
+import * as i0 from "@angular/core";
+import * as i1 from "./viewport.service";
+const NAME_CAMEL = "ssvViewportMatcherVar";
+export class SsvViewportMatcherVarContext {
+    $implicit;
+    constructor($implicit = false) {
+        this.$implicit = $implicit;
+    }
+}
+export class SsvViewportMatcherVarDirective {
+    viewport;
+    viewContainer;
+    templateRef;
+    _matchConditions = {};
+    _context = new SsvViewportMatcherVarContext();
+    _destroy$ = new Subject();
+    _update$ = new ReplaySubject(1);
+    _viewRef;
+    set condition(value) {
+        if (isViewportSizeMatcherExpression(value)) {
+            this._matchConditions.expression = value;
+        }
+        else if (isViewportSizeMatcherTupleExpression(value)) {
+            const [op, size] = value;
+            this._matchConditions.expression = {
+                operation: op,
+                size
+            };
+        }
+        else {
+            this._matchConditions.sizeType = value;
+        }
+        this._update$.next();
+    }
+    constructor(viewport, viewContainer, templateRef) {
+        this.viewport = viewport;
+        this.viewContainer = viewContainer;
+        this.templateRef = templateRef;
+    }
+    ngOnInit() {
+        this.updateView();
+        combineLatest([this.viewport.sizeType$, this._update$]).pipe(map(([sizeType]) => isViewportConditionMatch(sizeType, this._matchConditions, this.viewport.sizeTypeMap)), tap(x => this._context.$implicit = x), tap(() => this._viewRef.markForCheck()), takeUntil(this._destroy$)).subscribe();
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    updateView() {
+        this.viewContainer.clear();
+        this._viewRef = this.viewContainer.createEmbeddedView(this.templateRef, this._context);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: SsvViewportMatcherVarDirective, deps: [{ token: i1.ViewportService }, { token: i0.ViewContainerRef }, { token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.9", type: SsvViewportMatcherVarDirective, isStandalone: true, selector: "[ssvViewportMatcherVar]", inputs: { condition: ["ssvViewportMatcherVarWhen", "condition"] }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: SsvViewportMatcherVarDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `[${NAME_CAMEL}]`,
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.ViewportService }, { type: i0.ViewContainerRef }, { type: i0.TemplateRef }], propDecorators: { condition: [{
+                type: Input,
+                args: [`${NAME_CAMEL}When`]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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