@dugararchit/flex-layout 13.0.0-dugararchit

package/core/sass/_layout-bp.scss

@@ -0,0 +1,76 @@
+@charset "UTF-8";
+
+// Non-overlapping Material Design breakpoints
+// @type map
+$breakpoints: (
+  xs: (
+    begin: 0,
+    end: 599.9px
+  ),
+  sm: (
+    begin: 600px,
+    end: 959.9px
+  ),
+  md: (
+    begin: 960px,
+    end: 1279.9px
+  ),
+  lg: (
+    begin: 1280px,
+    end: 1919.9px
+  ),
+  xl: (
+    begin: 1920px,
+    end: 4999.99px
+  ),
+) !default;
+
+// Overlapping breakpoints that are greater than defined
+// Material Design breakpoints
+// @type map
+$overlapping-gt: (
+  gt-xs: 600px,
+  gt-sm: 960px,
+  gt-md: 1280px,
+  gt-lg: 1920px,
+) !default;
+
+// Overlapping breakpoints that are less than defined
+// Material Design breakpoints
+// @type map
+$overlapping-lt: (
+  lt-sm: 599.9px,
+  lt-md: 959.9px,
+  lt-lg: 1279.9px,
+  lt-xl: 1919.9px,
+) !default;
+
+
+// Media Query Mixin, takes a breakpoint and returns a wrapping
+// media query statement
+// e.g.
+//
+// @include layout-bp(xs) {
+//   background-color: red;
+// }
+//
+// becomes
+//
+// @media (min-width: 0px) and (max-width: 599px) {
+//   background-color: red;
+// }
+@mixin layout-bp($bp) {
+  @if map-has-key($breakpoints, $bp) {
+    $min: map-get(map-get($breakpoints, $bp), begin);
+    $max: map-get(map-get($breakpoints, $bp), end);
+    @media (min-width: $min) and (max-width: $max) { @content; }
+  }
+  @else if map-has-key($overlapping-gt, $bp) {
+    $min: map-get($overlapping-gt, $bp);
+    @media (min-width: $min) { @content; }
+  }
+  @else if map-has-key($overlapping-lt, $bp) {
+    $max: map-get($overlapping-lt, $bp);
+    @media (max-width: $max) { @content; }
+  }
+}

package/core/style-builder/style-builder.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { StyleDefinition } from '../style-utils/style-utils';
+/** A class that encapsulates CSS style generation for common directives */
+export declare abstract class StyleBuilder {
+    /** Whether to cache the generated output styles */
+    shouldCache: boolean;
+    /** Build the styles given an input string and configuration object from a host */
+    abstract buildStyles(input: string, parent?: Object): StyleDefinition;
+    /**
+     * Run a side effect computation given the input string and the computed styles
+     * from the build task and the host configuration object
+     * NOTE: This should be a no-op unless an algorithm is provided in a subclass
+     */
+    sideEffect(_input: string, _styles: StyleDefinition, _parent?: Object): void;
+}

package/core/style-utils/style-utils.d.ts

@@ -0,0 +1,53 @@
+import { StylesheetMap } from '../stylesheet-map/stylesheet-map';
+import { LayoutConfigOptions } from '../tokens/library-config';
+import * as i0 from "@angular/core";
+export declare class StyleUtils {
+    private _serverStylesheet;
+    private _serverModuleLoaded;
+    private _platformId;
+    private layoutConfig;
+    constructor(_serverStylesheet: StylesheetMap, _serverModuleLoaded: boolean, _platformId: Object, layoutConfig: LayoutConfigOptions);
+    /**
+     * Applies styles given via string pair or object map to the directive element
+     */
+    applyStyleToElement(element: HTMLElement, style: StyleDefinition | string, value?: string | number | null): void;
+    /**
+     * Applies styles given via string pair or object map to the directive's element
+     */
+    applyStyleToElements(style: StyleDefinition, elements?: HTMLElement[]): void;
+    /**
+     * Determine the DOM element's Flexbox flow (flex-direction)
+     *
+     * Check inline style first then check computed (stylesheet) style
+     */
+    getFlowDirection(target: HTMLElement): [string, string];
+    hasWrap(target: HTMLElement): boolean;
+    /**
+     * Find the DOM element's raw attribute value (if any)
+     */
+    lookupAttributeValue(element: HTMLElement, attribute: string): string;
+    /**
+     * Find the DOM element's inline style value (if any)
+     */
+    lookupInlineStyle(element: HTMLElement, styleName: string): string;
+    /**
+     * Determine the inline or inherited CSS style
+     * NOTE: platform-server has no implementation for getComputedStyle
+     */
+    lookupStyle(element: HTMLElement, styleName: string, inlineOnly?: boolean): string;
+    /**
+     * Applies the styles to the element. The styles object map may contain an array of values
+     * Each value will be added as element style
+     * Keys are sorted to add prefixed styles (like -webkit-x) first, before the standard ones
+     */
+    private _applyMultiValueStyleToElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StyleUtils, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StyleUtils>;
+}
+/**
+ * Definition of a css style. Either a property name (e.g. "flex-basis") or an object
+ * map of property name and value (e.g. {display: 'none', flex-order: 5})
+ */
+export declare type StyleDefinition = {
+    [property: string]: string | number | null;
+};

package/core/stylesheet-map/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './stylesheet-map';

package/core/stylesheet-map/stylesheet-map.d.ts

@@ -0,0 +1,24 @@
+import * as i0 from "@angular/core";
+/**
+ * Utility to emulate a CSS stylesheet
+ *
+ * This utility class stores all of the styles for a given HTML element
+ * as a readonly `stylesheet` map.
+ */
+export declare class StylesheetMap {
+    readonly stylesheet: Map<HTMLElement, Map<string, string | number>>;
+    /**
+     * Add an individual style to an HTML element
+     */
+    addStyleToElement(element: HTMLElement, style: string, value: string | number): void;
+    /**
+     * Clear the virtual stylesheet
+     */
+    clearStyles(): void;
+    /**
+     * Retrieve a given style for an HTML element
+     */
+    getStyleForElement(el: HTMLElement, styleName: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StylesheetMap, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StylesheetMap>;
+}

package/core/tokens/breakpoint-token.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { InjectionToken } from '@angular/core';
+import { BreakPoint } from '../breakpoints/break-point';
+export declare const BREAKPOINT: InjectionToken<BreakPoint | BreakPoint[] | null>;

package/core/tokens/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './library-config';
+export * from './server-token';
+export * from './breakpoint-token';

package/core/tokens/library-config.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { InjectionToken } from '@angular/core';
+import { Multiplier } from '../multiply/multiplier';
+/** a set of configuration options for FlexLayoutModule */
+export interface LayoutConfigOptions {
+    addFlexToParent?: boolean;
+    addOrientationBps?: boolean;
+    disableDefaultBps?: boolean;
+    disableVendorPrefixes?: boolean;
+    serverLoaded?: boolean;
+    useColumnBasisZero?: boolean;
+    printWithBreakpoints?: string[];
+    mediaTriggerAutoRestore?: boolean;
+    ssrObserveBreakpoints?: string[];
+    multiplier?: Multiplier;
+    defaultUnit?: string;
+    detectLayoutDisplay?: boolean;
+}
+export declare const DEFAULT_CONFIG: Required<LayoutConfigOptions>;
+export declare const LAYOUT_CONFIG: InjectionToken<LayoutConfigOptions>;

package/core/tokens/server-token.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { InjectionToken } from '@angular/core';
+/**
+ * Token that is provided to tell whether the FlexLayoutServerModule
+ * has been included in the bundle
+ *
+ * NOTE: This can be manually provided to disable styles when using SSR
+ */
+export declare const SERVER_TOKEN: InjectionToken<boolean>;

package/core/utils/array.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/** Wraps the provided value in an array, unless the provided value is an array. */
+export declare function coerceArray<T>(value: T | T[]): T[];

package/core/utils/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './sort';
+export * from './array';

package/core/utils/sort.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+interface WithPriority {
+    priority?: number;
+}
+/** HOF to sort the breakpoints by descending priority */
+export declare function sortDescendingPriority<T extends WithPriority>(a: T | null, b: T | null): number;
+/** HOF to sort the breakpoints by ascending priority */
+export declare function sortAscendingPriority<T extends WithPriority>(a: T, b: T): number;
+export {};

package/esm2020/_private-utils/angular-flex-layout-_private-utils.mjs

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

package/esm2020/_private-utils/auto-prefixer.mjs

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Applies CSS prefixes to appropriate style keys.
+ *
+ * Note: `-ms-`, `-moz` and `-webkit-box` are no longer supported. e.g.
+ *    {
+ *      display: -webkit-flex;     NEW - Safari 6.1+. iOS 7.1+, BB10
+ *      display: flex;             NEW, Spec - Firefox, Chrome, Opera
+ *      // display: -webkit-box;   OLD - iOS 6-, Safari 3.1-6, BB7
+ *      // display: -ms-flexbox;   TWEENER - IE 10
+ *      // display: -moz-flexbox;  OLD - Firefox
+ *    }
+ */
+export function applyCssPrefixes(target) {
+    for (let key in target) {
+        let value = target[key] || '';
+        switch (key) {
+            case 'display':
+                if (value === 'flex') {
+                    target['display'] = [
+                        '-webkit-flex',
+                        'flex'
+                    ];
+                }
+                else if (value === 'inline-flex') {
+                    target['display'] = [
+                        '-webkit-inline-flex',
+                        'inline-flex'
+                    ];
+                }
+                else {
+                    target['display'] = value;
+                }
+                break;
+            case 'align-items':
+            case 'align-self':
+            case 'align-content':
+            case 'flex':
+            case 'flex-basis':
+            case 'flex-flow':
+            case 'flex-grow':
+            case 'flex-shrink':
+            case 'flex-wrap':
+            case 'justify-content':
+                target['-webkit-' + key] = value;
+                break;
+            case 'flex-direction':
+                value = value || 'row';
+                target['-webkit-flex-direction'] = value;
+                target['flex-direction'] = value;
+                break;
+            case 'order':
+                target['order'] = target['-webkit-' + key] = isNaN(+value) ? '0' : value;
+                break;
+        }
+    }
+    return target;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/_private-utils/index.mjs

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './auto-prefixer';
+export * from './layout-validator';
+export * from './object-extend';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saWJzL2ZsZXgtbGF5b3V0L19wcml2YXRlLXV0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vYXV0by1wcmVmaXhlcic7XG5leHBvcnQgKiBmcm9tICcuL2xheW91dC12YWxpZGF0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9vYmplY3QtZXh0ZW5kJztcbiJdfQ==

package/esm2020/_private-utils/layout-validator.mjs

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export const INLINE = 'inline';
+export const LAYOUT_VALUES = ['row', 'column', 'row-reverse', 'column-reverse'];
+/**
+ * Validate the direction|'direction wrap' value and then update the host's inline flexbox styles
+ */
+export function buildLayoutCSS(value) {
+    let [direction, wrap, isInline] = validateValue(value);
+    return buildCSS(direction, wrap, isInline);
+}
+/**
+  * Validate the value to be one of the acceptable value options
+  * Use default fallback of 'row'
+  */
+export function validateValue(value) {
+    value = value?.toLowerCase() ?? '';
+    let [direction, wrap, inline] = value.split(' ');
+    // First value must be the `flex-direction`
+    if (!LAYOUT_VALUES.find(x => x === direction)) {
+        direction = LAYOUT_VALUES[0];
+    }
+    if (wrap === INLINE) {
+        wrap = (inline !== INLINE) ? inline : '';
+        inline = INLINE;
+    }
+    return [direction, validateWrapValue(wrap), !!inline];
+}
+/**
+ * Determine if the validated, flex-direction value specifies
+ * a horizontal/row flow.
+ */
+export function isFlowHorizontal(value) {
+    let [flow,] = validateValue(value);
+    return flow.indexOf('row') > -1;
+}
+/**
+ * Convert layout-wrap='<value>' to expected flex-wrap style
+ */
+export function validateWrapValue(value) {
+    if (!!value) {
+        switch (value.toLowerCase()) {
+            case 'reverse':
+            case 'wrap-reverse':
+            case 'reverse-wrap':
+                value = 'wrap-reverse';
+                break;
+            case 'no':
+            case 'none':
+            case 'nowrap':
+                value = 'nowrap';
+                break;
+            // All other values fallback to 'wrap'
+            default:
+                value = 'wrap';
+                break;
+        }
+    }
+    return value;
+}
+/**
+ * Build the CSS that should be assigned to the element instance
+ * BUG:
+ *   1) min-height on a column flex container won’t apply to its flex item children in IE 10-11.
+ *      Use height instead if possible; height : <xxx>vh;
+ *
+ *  This way any padding or border specified on the child elements are
+ *  laid out and drawn inside that element's specified width and height.
+ */
+function buildCSS(direction, wrap = null, inline = false) {
+    return {
+        display: inline ? 'inline-flex' : 'flex',
+        'box-sizing': 'border-box',
+        'flex-direction': direction,
+        'flex-wrap': wrap || null,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/_private-utils/object-extend.mjs

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Extends an object with the *enumerable* and *own* properties of one or more source objects,
+ * similar to Object.assign.
+ *
+ * @param dest The object which will have properties copied to it.
+ * @param sources The source objects from which properties will be copied.
+ */
+export function extendObject(dest, ...sources) {
+    if (dest == null) {
+        throw TypeError('Cannot convert undefined or null to object');
+    }
+    for (let source of sources) {
+        if (source != null) {
+            for (let key in source) {
+                if (source.hasOwnProperty(key)) {
+                    dest[key] = source[key];
+                }
+            }
+        }
+    }
+    return dest;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0LWV4dGVuZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2xpYnMvZmxleC1sYXlvdXQvX3ByaXZhdGUtdXRpbHMvb2JqZWN0LWV4dGVuZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFDSDs7Ozs7O0dBTUc7QUFDSCxNQUFNLFVBQVUsWUFBWSxDQUFDLElBQVMsRUFBRSxHQUFHLE9BQWM7SUFDdkQsSUFBSSxJQUFJLElBQUksSUFBSSxFQUFFO1FBQ2hCLE1BQU0sU0FBUyxDQUFDLDRDQUE0QyxDQUFDLENBQUM7S0FDL0Q7SUFFRCxLQUFLLElBQUksTUFBTSxJQUFJLE9BQU8sRUFBRTtRQUMxQixJQUFJLE1BQU0sSUFBSSxJQUFJLEVBQUU7WUFDbEIsS0FBSyxJQUFJLEdBQUcsSUFBSSxNQUFNLEVBQUU7Z0JBQ3RCLElBQUksTUFBTSxDQUFDLGNBQWMsQ0FBQyxHQUFHLENBQUMsRUFBRTtvQkFDOUIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztpQkFDekI7YUFDRjtTQUNGO0tBQ0Y7SUFFRCxPQUFPLElBQUksQ0FBQztBQUNkLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbi8qKlxuICogRXh0ZW5kcyBhbiBvYmplY3Qgd2l0aCB0aGUgKmVudW1lcmFibGUqIGFuZCAqb3duKiBwcm9wZXJ0aWVzIG9mIG9uZSBvciBtb3JlIHNvdXJjZSBvYmplY3RzLFxuICogc2ltaWxhciB0byBPYmplY3QuYXNzaWduLlxuICpcbiAqIEBwYXJhbSBkZXN0IFRoZSBvYmplY3Qgd2hpY2ggd2lsbCBoYXZlIHByb3BlcnRpZXMgY29waWVkIHRvIGl0LlxuICogQHBhcmFtIHNvdXJjZXMgVGhlIHNvdXJjZSBvYmplY3RzIGZyb20gd2hpY2ggcHJvcGVydGllcyB3aWxsIGJlIGNvcGllZC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGV4dGVuZE9iamVjdChkZXN0OiBhbnksIC4uLnNvdXJjZXM6IGFueVtdKTogYW55IHtcbiAgaWYgKGRlc3QgPT0gbnVsbCkge1xuICAgIHRocm93IFR5cGVFcnJvcignQ2Fubm90IGNvbnZlcnQgdW5kZWZpbmVkIG9yIG51bGwgdG8gb2JqZWN0Jyk7XG4gIH1cblxuICBmb3IgKGxldCBzb3VyY2Ugb2Ygc291cmNlcykge1xuICAgIGlmIChzb3VyY2UgIT0gbnVsbCkge1xuICAgICAgZm9yIChsZXQga2V5IGluIHNvdXJjZSkge1xuICAgICAgICBpZiAoc291cmNlLmhhc093blByb3BlcnR5KGtleSkpIHtcbiAgICAgICAgICBkZXN0W2tleV0gPSBzb3VyY2Vba2V5XTtcbiAgICAgICAgfVxuICAgICAgfVxuICAgIH1cbiAgfVxuXG4gIHJldHVybiBkZXN0O1xufVxuIl19

package/esm2020/_private-utils/testing/angular-flex-layout-_private-utils-testing.mjs

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