@dugararchit/flex-layout 13.0.0-dugararchit

package/esm2020/core/basis-validator/basis-validator.mjs

@@ -0,0 +1,48 @@
+/**
+ * @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
+ */
+/**
+* The flex API permits 3 or 1 parts of the value:
+*    - `flex-grow flex-shrink flex-basis`, or
+*    - `flex-basis`
+*/
+export function validateBasis(basis, grow = '1', shrink = '1') {
+    let parts = [grow, shrink, basis];
+    let j = basis.indexOf('calc');
+    if (j > 0) {
+        parts[2] = _validateCalcValue(basis.substring(j).trim());
+        let matches = basis.substr(0, j).trim().split(' ');
+        if (matches.length == 2) {
+            parts[0] = matches[0];
+            parts[1] = matches[1];
+        }
+    }
+    else if (j == 0) {
+        parts[2] = _validateCalcValue(basis.trim());
+    }
+    else {
+        let matches = basis.split(' ');
+        parts = (matches.length === 3) ? matches : [
+            grow, shrink, basis
+        ];
+    }
+    return parts;
+}
+/**
+ * Calc expressions require whitespace before & after any expression operators
+ * This is a simple, crude whitespace padding solution.
+ *   - '3 3 calc(15em + 20px)'
+ *   - calc(100% / 7 * 2)
+ *   - 'calc(15em + 20px)'
+ *   - 'calc(15em+20px)'
+ *   - '37px'
+ *   = '43%'
+ */
+function _validateCalcValue(calc) {
+    return calc.replace(/[\s]/g, '').replace(/[\/\*\+\-]/g, ' $& ');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzaXMtdmFsaWRhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbGlicy9mbGV4LWxheW91dC9jb3JlL2Jhc2lzLXZhbGlkYXRvci9iYXNpcy12YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUY7Ozs7RUFJRTtBQUNILE1BQU0sVUFBVSxhQUFhLENBQUMsS0FBYSxFQUFFLElBQUksR0FBRyxHQUFHLEVBQUUsTUFBTSxHQUFHLEdBQUc7SUFDbkUsSUFBSSxLQUFLLEdBQUcsQ0FBQyxJQUFJLEVBQUUsTUFBTSxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBRWxDLElBQUksQ0FBQyxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDOUIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFO1FBQ1QsS0FBSyxDQUFDLENBQUMsQ0FBQyxHQUFHLGtCQUFrQixDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUN6RCxJQUFJLE9BQU8sR0FBRyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDbkQsSUFBSSxPQUFPLENBQUMsTUFBTSxJQUFJLENBQUMsRUFBRTtZQUN2QixLQUFLLENBQUMsQ0FBQyxDQUFDLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ3RCLEtBQUssQ0FBQyxDQUFDLENBQUMsR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUM7U0FDdkI7S0FDRjtTQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRTtRQUNqQixLQUFLLENBQUMsQ0FBQyxDQUFDLEdBQUcsa0JBQWtCLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7S0FDN0M7U0FBTTtRQUNMLElBQUksT0FBTyxHQUFHLEtBQUssQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDL0IsS0FBSyxHQUFHLENBQUMsT0FBTyxDQUFDLE1BQU0sS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQztZQUNyQyxJQUFJLEVBQUUsTUFBTSxFQUFFLEtBQUs7U0FDcEIsQ0FBQztLQUNQO0lBRUQsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDO0FBR0Q7Ozs7Ozs7OztHQVNHO0FBQ0gsU0FBUyxrQkFBa0IsQ0FBQyxJQUFZO0lBQ3RDLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLEVBQUUsRUFBRSxDQUFDLENBQUMsT0FBTyxDQUFDLGFBQWEsRUFBRSxNQUFNLENBQUMsQ0FBQztBQUNsRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbiAvKipcbiAqIFRoZSBmbGV4IEFQSSBwZXJtaXRzIDMgb3IgMSBwYXJ0cyBvZiB0aGUgdmFsdWU6XG4gKiAgICAtIGBmbGV4LWdyb3cgZmxleC1zaHJpbmsgZmxleC1iYXNpc2AsIG9yXG4gKiAgICAtIGBmbGV4LWJhc2lzYFxuICovXG5leHBvcnQgZnVuY3Rpb24gdmFsaWRhdGVCYXNpcyhiYXNpczogc3RyaW5nLCBncm93ID0gJzEnLCBzaHJpbmsgPSAnMScpOiBzdHJpbmdbXSB7XG4gIGxldCBwYXJ0cyA9IFtncm93LCBzaHJpbmssIGJhc2lzXTtcblxuICBsZXQgaiA9IGJhc2lzLmluZGV4T2YoJ2NhbGMnKTtcbiAgaWYgKGogPiAwKSB7XG4gICAgcGFydHNbMl0gPSBfdmFsaWRhdGVDYWxjVmFsdWUoYmFzaXMuc3Vic3RyaW5nKGopLnRyaW0oKSk7XG4gICAgbGV0IG1hdGNoZXMgPSBiYXNpcy5zdWJzdHIoMCwgaikudHJpbSgpLnNwbGl0KCcgJyk7XG4gICAgaWYgKG1hdGNoZXMubGVuZ3RoID09IDIpIHtcbiAgICAgIHBhcnRzWzBdID0gbWF0Y2hlc1swXTtcbiAgICAgIHBhcnRzWzFdID0gbWF0Y2hlc1sxXTtcbiAgICB9XG4gIH0gZWxzZSBpZiAoaiA9PSAwKSB7XG4gICAgcGFydHNbMl0gPSBfdmFsaWRhdGVDYWxjVmFsdWUoYmFzaXMudHJpbSgpKTtcbiAgfSBlbHNlIHtcbiAgICBsZXQgbWF0Y2hlcyA9IGJhc2lzLnNwbGl0KCcgJyk7XG4gICAgcGFydHMgPSAobWF0Y2hlcy5sZW5ndGggPT09IDMpID8gbWF0Y2hlcyA6IFtcbiAgICAgICAgICBncm93LCBzaHJpbmssIGJhc2lzXG4gICAgICAgIF07XG4gIH1cblxuICByZXR1cm4gcGFydHM7XG59XG5cblxuLyoqXG4gKiBDYWxjIGV4cHJlc3Npb25zIHJlcXVpcmUgd2hpdGVzcGFjZSBiZWZvcmUgJiBhZnRlciBhbnkgZXhwcmVzc2lvbiBvcGVyYXRvcnNcbiAqIFRoaXMgaXMgYSBzaW1wbGUsIGNydWRlIHdoaXRlc3BhY2UgcGFkZGluZyBzb2x1dGlvbi5cbiAqICAgLSAnMyAzIGNhbGMoMTVlbSArIDIwcHgpJ1xuICogICAtIGNhbGMoMTAwJSAvIDcgKiAyKVxuICogICAtICdjYWxjKDE1ZW0gKyAyMHB4KSdcbiAqICAgLSAnY2FsYygxNWVtKzIwcHgpJ1xuICogICAtICczN3B4J1xuICogICA9ICc0MyUnXG4gKi9cbmZ1bmN0aW9uIF92YWxpZGF0ZUNhbGNWYWx1ZShjYWxjOiBzdHJpbmcpOiBzdHJpbmcge1xuICByZXR1cm4gY2FsYy5yZXBsYWNlKC9bXFxzXS9nLCAnJykucmVwbGFjZSgvW1xcL1xcKlxcK1xcLV0vZywgJyAkJiAnKTtcbn1cbiJdfQ==

package/esm2020/core/breakpoints/break-point-registry.mjs

@@ -0,0 +1,76 @@
+/**
+ * @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 { Injectable, Inject } from '@angular/core';
+import { BREAKPOINTS } from './break-points-token';
+import { sortAscendingPriority } from '../utils/sort';
+import * as i0 from "@angular/core";
+/**
+ * Registry of 1..n MediaQuery breakpoint ranges
+ * This is published as a provider and may be overridden from custom, application-specific ranges
+ *
+ */
+export class BreakPointRegistry {
+    constructor(list) {
+        /**
+         * Memoized BreakPoint Lookups
+         */
+        this.findByMap = new Map();
+        this.items = [...list].sort(sortAscendingPriority);
+    }
+    /**
+     * Search breakpoints by alias (e.g. gt-xs)
+     */
+    findByAlias(alias) {
+        return !alias ? null : this.findWithPredicate(alias, (bp) => bp.alias === alias);
+    }
+    findByQuery(query) {
+        return this.findWithPredicate(query, (bp) => bp.mediaQuery === query);
+    }
+    /**
+     * Get all the breakpoints whose ranges could overlapping `normal` ranges;
+     * e.g. gt-sm overlaps md, lg, and xl
+     */
+    get overlappings() {
+        return this.items.filter(it => it.overlapping);
+    }
+    /**
+     * Get list of all registered (non-empty) breakpoint aliases
+     */
+    get aliases() {
+        return this.items.map(it => it.alias);
+    }
+    /**
+     * Aliases are mapped to properties using suffixes
+     * e.g.  'gt-sm' for property 'layout'  uses suffix 'GtSm'
+     * for property layoutGtSM.
+     */
+    get suffixes() {
+        return this.items.map(it => it?.suffix ?? '');
+    }
+    /**
+     * Memoized lookup using custom predicate function
+     */
+    findWithPredicate(key, searchFn) {
+        let response = this.findByMap.get(key);
+        if (!response) {
+            response = this.items.find(searchFn) ?? null;
+            this.findByMap.set(key, response);
+        }
+        return response ?? null;
+    }
+}
+BreakPointRegistry.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: BreakPointRegistry, deps: [{ token: BREAKPOINTS }], target: i0.ɵɵFactoryTarget.Injectable });
+BreakPointRegistry.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: BreakPointRegistry, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: BreakPointRegistry, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BREAKPOINTS]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/breakpoints/break-point.mjs

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

package/esm2020/core/breakpoints/break-points-token.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
+ */
+import { inject, InjectionToken } from '@angular/core';
+import { BREAKPOINT } from '../tokens/breakpoint-token';
+import { DEFAULT_BREAKPOINTS } from '../breakpoints/data/break-points';
+import { ORIENTATION_BREAKPOINTS } from '../breakpoints/data/orientation-break-points';
+import { mergeByAlias } from '../breakpoints/breakpoint-tools';
+import { LAYOUT_CONFIG } from '../tokens/library-config';
+/**
+ *  Injection token unique to the flex-layout library.
+ *  Use this token when build a custom provider (see below).
+ */
+export const BREAKPOINTS = new InjectionToken('Token (@angular/flex-layout) Breakpoints', {
+    providedIn: 'root',
+    factory: () => {
+        const breakpoints = inject(BREAKPOINT);
+        const layoutConfig = inject(LAYOUT_CONFIG);
+        const bpFlattenArray = [].concat.apply([], (breakpoints || [])
+            .map((v) => Array.isArray(v) ? v : [v]));
+        const builtIns = (layoutConfig.disableDefaultBps ? [] : DEFAULT_BREAKPOINTS)
+            .concat(layoutConfig.addOrientationBps ? ORIENTATION_BREAKPOINTS : []);
+        return mergeByAlias(builtIns, bpFlattenArray);
+    }
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/breakpoints/breakpoint-tools.mjs

@@ -0,0 +1,53 @@
+import { extendObject } from '@angular/flex-layout/_private-utils';
+const ALIAS_DELIMITERS = /(\.|-|_)/g;
+function firstUpperCase(part) {
+    let first = part.length > 0 ? part.charAt(0) : '';
+    let remainder = (part.length > 1) ? part.slice(1) : '';
+    return first.toUpperCase() + remainder;
+}
+/**
+ * Converts snake-case to SnakeCase.
+ * @param name Text to UpperCamelCase
+ */
+function camelCase(name) {
+    return name
+        .replace(ALIAS_DELIMITERS, '|')
+        .split('|')
+        .map(firstUpperCase)
+        .join('');
+}
+/**
+ * For each breakpoint, ensure that a Suffix is defined;
+ * fallback to UpperCamelCase the unique Alias value
+ */
+export function validateSuffixes(list) {
+    list.forEach((bp) => {
+        if (!bp.suffix) {
+            bp.suffix = camelCase(bp.alias); // create Suffix value based on alias
+            bp.overlapping = !!bp.overlapping; // ensure default value
+        }
+    });
+    return list;
+}
+/**
+ * Merge a custom breakpoint list with the default list based on unique alias values
+ *  - Items are added if the alias is not in the default list
+ *  - Items are merged with the custom override if the alias exists in the default list
+ */
+export function mergeByAlias(defaults, custom = []) {
+    const dict = {};
+    defaults.forEach(bp => {
+        dict[bp.alias] = bp;
+    });
+    // Merge custom breakpoints
+    custom.forEach((bp) => {
+        if (dict[bp.alias]) {
+            extendObject(dict[bp.alias], bp);
+        }
+        else {
+            dict[bp.alias] = bp;
+        }
+    });
+    return validateSuffixes(Object.keys(dict).map(k => dict[k]));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/breakpoints/data/break-points.mjs

@@ -0,0 +1,78 @@
+/**
+ * NOTE: Smaller ranges have HIGHER priority since the match is more specific
+ */
+export const DEFAULT_BREAKPOINTS = [
+    {
+        alias: 'xs',
+        mediaQuery: 'screen and (min-width: 0px) and (max-width: 599.98px)',
+        priority: 1000,
+    },
+    {
+        alias: 'sm',
+        mediaQuery: 'screen and (min-width: 600px) and (max-width: 959.98px)',
+        priority: 900,
+    },
+    {
+        alias: 'md',
+        mediaQuery: 'screen and (min-width: 960px) and (max-width: 1279.98px)',
+        priority: 800,
+    },
+    {
+        alias: 'lg',
+        mediaQuery: 'screen and (min-width: 1280px) and (max-width: 1919.98px)',
+        priority: 700,
+    },
+    {
+        alias: 'xl',
+        mediaQuery: 'screen and (min-width: 1920px) and (max-width: 4999.98px)',
+        priority: 600,
+    },
+    {
+        alias: 'lt-sm',
+        overlapping: true,
+        mediaQuery: 'screen and (max-width: 599.98px)',
+        priority: 950,
+    },
+    {
+        alias: 'lt-md',
+        overlapping: true,
+        mediaQuery: 'screen and (max-width: 959.98px)',
+        priority: 850,
+    },
+    {
+        alias: 'lt-lg',
+        overlapping: true,
+        mediaQuery: 'screen and (max-width: 1279.98px)',
+        priority: 750,
+    },
+    {
+        alias: 'lt-xl',
+        overlapping: true,
+        priority: 650,
+        mediaQuery: 'screen and (max-width: 1919.98px)',
+    },
+    {
+        alias: 'gt-xs',
+        overlapping: true,
+        mediaQuery: 'screen and (min-width: 600px)',
+        priority: -950,
+    },
+    {
+        alias: 'gt-sm',
+        overlapping: true,
+        mediaQuery: 'screen and (min-width: 960px)',
+        priority: -850,
+    }, {
+        alias: 'gt-md',
+        overlapping: true,
+        mediaQuery: 'screen and (min-width: 1280px)',
+        priority: -750,
+    },
+    {
+        alias: 'gt-lg',
+        overlapping: true,
+        mediaQuery: 'screen and (min-width: 1920px)',
+        priority: -650,
+    }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/breakpoints/data/orientation-break-points.mjs

@@ -0,0 +1,40 @@
+/**
+ * @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
+ */
+/* tslint:disable */
+const HANDSET_PORTRAIT = '(orientation: portrait) and (max-width: 599.98px)';
+const HANDSET_LANDSCAPE = '(orientation: landscape) and (max-width: 959.98px)';
+const TABLET_PORTRAIT = '(orientation: portrait) and (min-width: 600px) and (max-width: 839.98px)';
+const TABLET_LANDSCAPE = '(orientation: landscape) and (min-width: 960px) and (max-width: 1279.98px)';
+const WEB_PORTRAIT = '(orientation: portrait) and (min-width: 840px)';
+const WEB_LANDSCAPE = '(orientation: landscape) and (min-width: 1280px)';
+export const ScreenTypes = {
+    'HANDSET': `${HANDSET_PORTRAIT}, ${HANDSET_LANDSCAPE}`,
+    'TABLET': `${TABLET_PORTRAIT} , ${TABLET_LANDSCAPE}`,
+    'WEB': `${WEB_PORTRAIT}, ${WEB_LANDSCAPE} `,
+    'HANDSET_PORTRAIT': `${HANDSET_PORTRAIT}`,
+    'TABLET_PORTRAIT': `${TABLET_PORTRAIT} `,
+    'WEB_PORTRAIT': `${WEB_PORTRAIT}`,
+    'HANDSET_LANDSCAPE': `${HANDSET_LANDSCAPE}`,
+    'TABLET_LANDSCAPE': `${TABLET_LANDSCAPE}`,
+    'WEB_LANDSCAPE': `${WEB_LANDSCAPE}`
+};
+/**
+ * Extended Breakpoints for handset/tablets with landscape or portrait orientations
+ */
+export const ORIENTATION_BREAKPOINTS = [
+    { 'alias': 'handset', priority: 2000, 'mediaQuery': ScreenTypes.HANDSET },
+    { 'alias': 'handset.landscape', priority: 2000, 'mediaQuery': ScreenTypes.HANDSET_LANDSCAPE },
+    { 'alias': 'handset.portrait', priority: 2000, 'mediaQuery': ScreenTypes.HANDSET_PORTRAIT },
+    { 'alias': 'tablet', priority: 2100, 'mediaQuery': ScreenTypes.TABLET },
+    { 'alias': 'tablet.landscape', priority: 2100, 'mediaQuery': ScreenTypes.TABLET_LANDSCAPE },
+    { 'alias': 'tablet.portrait', priority: 2100, 'mediaQuery': ScreenTypes.TABLET_PORTRAIT },
+    { 'alias': 'web', priority: 2200, 'mediaQuery': ScreenTypes.WEB, overlapping: true },
+    { 'alias': 'web.landscape', priority: 2200, 'mediaQuery': ScreenTypes.WEB_LANDSCAPE, overlapping: true },
+    { 'alias': 'web.portrait', priority: 2200, 'mediaQuery': ScreenTypes.WEB_PORTRAIT, overlapping: true }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/breakpoints/index.mjs

@@ -0,0 +1,13 @@
+/**
+ * @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 './data/break-points';
+export * from './data/orientation-break-points';
+export * from './break-point';
+export * from './break-point-registry';
+export * from './break-points-token';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saWJzL2ZsZXgtbGF5b3V0L2NvcmUvYnJlYWtwb2ludHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGlDQUFpQyxDQUFDO0FBRWhELGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2RhdGEvYnJlYWstcG9pbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vZGF0YS9vcmllbnRhdGlvbi1icmVhay1wb2ludHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2JyZWFrLXBvaW50JztcbmV4cG9ydCAqIGZyb20gJy4vYnJlYWstcG9pbnQtcmVnaXN0cnknO1xuZXhwb3J0ICogZnJvbSAnLi9icmVhay1wb2ludHMtdG9rZW4nO1xuIl19

package/esm2020/core/browser-provider.mjs

@@ -0,0 +1,41 @@
+/**
+ * @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 { APP_BOOTSTRAP_LISTENER, PLATFORM_ID } from '@angular/core';
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
+/**
+ * Find all of the server-generated stylings, if any, and remove them
+ * This will be in the form of inline classes and the style block in the
+ * head of the DOM
+ */
+export function removeStyles(_document, platformId) {
+    return () => {
+        if (isPlatformBrowser(platformId)) {
+            const elements = Array.from(_document.querySelectorAll(`[class*=${CLASS_NAME}]`));
+            // RegExp constructor should only be used if passing a variable to the constructor.
+            // When using static regular expression it is more performant to use reg exp literal.
+            // This is also needed to provide Safari 9 compatibility, please see
+            // https://stackoverflow.com/questions/37919802 for more discussion.
+            const classRegex = /\bflex-layout-.+?\b/g;
+            elements.forEach(el => {
+                el.classList.contains(`${CLASS_NAME}ssr`) && el.parentNode ?
+                    el.parentNode.removeChild(el) : el.className.replace(classRegex, '');
+            });
+        }
+    };
+}
+/**
+ *  Provider to remove SSR styles on the browser
+ */
+export const BROWSER_PROVIDER = {
+    provide: APP_BOOTSTRAP_LISTENER,
+    useFactory: removeStyles,
+    deps: [DOCUMENT, PLATFORM_ID],
+    multi: true
+};
+export const CLASS_NAME = 'flex-layout-';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/match-media/index.mjs

@@ -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 './match-media';
+export * from './mock/mock-match-media';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saWJzL2ZsZXgtbGF5b3V0L2NvcmUvbWF0Y2gtbWVkaWEvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL21hdGNoLW1lZGlhJztcbmV4cG9ydCAqIGZyb20gJy4vbW9jay9tb2NrLW1hdGNoLW1lZGlhJztcbiJdfQ==