@dugararchit/flex-layout 13.0.0-dugararchit

package/extended/class/class.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @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 { DoCheck, ElementRef, IterableDiffers, KeyValueDiffers, Renderer2 } from '@angular/core';
+import { NgClass } from '@angular/common';
+import { BaseDirective2, StyleUtils, MediaMarshaller } from '@angular/flex-layout/core';
+import * as i0 from "@angular/core";
+export declare class ClassDirective extends BaseDirective2 implements DoCheck {
+    protected readonly ngClassInstance: NgClass;
+    protected DIRECTIVE_KEY: string;
+    /**
+     * Capture class assignments so we cache the default classes
+     * which are merged with activated styles and used as fallbacks.
+     */
+    set klass(val: string);
+    constructor(elementRef: ElementRef, styler: StyleUtils, marshal: MediaMarshaller, iterableDiffers: IterableDiffers, keyValueDiffers: KeyValueDiffers, renderer2: Renderer2, ngClassInstance: NgClass);
+    protected updateWithValue(value: any): void;
+    /**
+     * For ChangeDetectionStrategy.onPush and ngOnChanges() updates
+     */
+    ngDoCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClassDirective, [null, null, null, null, null, null, { optional: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClassDirective, never, never, { "klass": "class"; }, {}, never>;
+}
+/**
+ * Directive to add responsive support for ngClass.
+ * This maintains the core functionality of 'ngClass' and adds responsive API
+ * Note: this class is a no-op when rendered on the server
+ */
+export declare class DefaultClassDirective extends ClassDirective {
+    protected inputs: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultClassDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultClassDirective, "  [ngClass], [ngClass.xs], [ngClass.sm], [ngClass.md], [ngClass.lg], [ngClass.xl],  [ngClass.lt-sm], [ngClass.lt-md], [ngClass.lt-lg], [ngClass.lt-xl],  [ngClass.gt-xs], [ngClass.gt-sm], [ngClass.gt-md], [ngClass.gt-lg]", never, { "ngClass": "ngClass"; "ngClass.xs": "ngClass.xs"; "ngClass.sm": "ngClass.sm"; "ngClass.md": "ngClass.md"; "ngClass.lg": "ngClass.lg"; "ngClass.xl": "ngClass.xl"; "ngClass.lt-sm": "ngClass.lt-sm"; "ngClass.lt-md": "ngClass.lt-md"; "ngClass.lt-lg": "ngClass.lt-lg"; "ngClass.lt-xl": "ngClass.lt-xl"; "ngClass.gt-xs": "ngClass.gt-xs"; "ngClass.gt-sm": "ngClass.gt-sm"; "ngClass.gt-md": "ngClass.gt-md"; "ngClass.gt-lg": "ngClass.gt-lg"; }, {}, never>;
+}

package/extended/img-src/img-src.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @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 { ElementRef } from '@angular/core';
+import { MediaMarshaller, BaseDirective2, StyleBuilder, StyleDefinition, StyleUtils } from '@angular/flex-layout/core';
+import * as i0 from "@angular/core";
+export declare class ImgSrcStyleBuilder extends StyleBuilder {
+    buildStyles(url: string): {
+        content: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImgSrcStyleBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImgSrcStyleBuilder>;
+}
+export declare class ImgSrcDirective extends BaseDirective2 {
+    protected platformId: Object;
+    protected serverModuleLoaded: boolean;
+    protected DIRECTIVE_KEY: string;
+    protected defaultSrc: string;
+    set src(val: string);
+    constructor(elementRef: ElementRef, styleBuilder: ImgSrcStyleBuilder, styler: StyleUtils, marshal: MediaMarshaller, platformId: Object, serverModuleLoaded: boolean);
+    /**
+     * Use the [responsively] activated input value to update
+     * the host img src attribute or assign a default `img.src=''`
+     * if the src has not been defined.
+     *
+     * Do nothing to standard `<img src="">` usages, only when responsive
+     * keys are present do we actually call `setAttribute()`
+     */
+    protected updateWithValue(value?: string): void;
+    protected styleCache: Map<string, StyleDefinition>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImgSrcDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ImgSrcDirective, never, never, { "src": "src"; }, {}, never>;
+}
+/**
+ * This directive provides a responsive API for the HTML <img> 'src' attribute
+ * and will update the img.src property upon each responsive activation.
+ *
+ * e.g.
+ *      <img src="defaultScene.jpg" src.xs="mobileScene.jpg"></img>
+ *
+ * @see https://css-tricks.com/responsive-images-youre-just-changing-resolutions-use-src/
+ */
+export declare class DefaultImgSrcDirective extends ImgSrcDirective {
+    protected inputs: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultImgSrcDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultImgSrcDirective, "  img[src.xs],    img[src.sm],    img[src.md],    img[src.lg],   img[src.xl],  img[src.lt-sm], img[src.lt-md], img[src.lt-lg], img[src.lt-xl],  img[src.gt-xs], img[src.gt-sm], img[src.gt-md], img[src.gt-lg]", never, { "src.xs": "src.xs"; "src.sm": "src.sm"; "src.md": "src.md"; "src.lg": "src.lg"; "src.xl": "src.xl"; "src.lt-sm": "src.lt-sm"; "src.lt-md": "src.lt-md"; "src.lt-lg": "src.lt-lg"; "src.lt-xl": "src.lt-xl"; "src.gt-xs": "src.gt-xs"; "src.gt-sm": "src.gt-sm"; "src.gt-md": "src.gt-md"; "src.gt-lg": "src.gt-lg"; }, {}, never>;
+}

package/extended/module.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./show-hide/show-hide";
+import * as i2 from "./class/class";
+import * as i3 from "./style/style";
+import * as i4 from "./img-src/img-src";
+import * as i5 from "@angular/flex-layout/core";
+/**
+ * *****************************************************************
+ * Define module for the Extended API
+ * *****************************************************************
+ */
+export declare class ExtendedModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExtendedModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ExtendedModule, [typeof i1.DefaultShowHideDirective, typeof i2.DefaultClassDirective, typeof i3.DefaultStyleDirective, typeof i4.DefaultImgSrcDirective], [typeof i5.CoreModule], [typeof i1.DefaultShowHideDirective, typeof i2.DefaultClassDirective, typeof i3.DefaultStyleDirective, typeof i4.DefaultImgSrcDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ExtendedModule>;
+}

package/extended/package.json

@@ -0,0 +1,10 @@
+{
+  "module": "../fesm2015/angular-flex-layout-extended.mjs",
+  "es2020": "../fesm2020/angular-flex-layout-extended.mjs",
+  "esm2020": "../esm2020/extended/angular-flex-layout-extended.mjs",
+  "fesm2020": "../fesm2020/angular-flex-layout-extended.mjs",
+  "fesm2015": "../fesm2015/angular-flex-layout-extended.mjs",
+  "typings": "angular-flex-layout-extended.d.ts",
+  "sideEffects": false,
+  "name": "@angular/flex-layout/extended"
+}

package/extended/public-api.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @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 './module';
+export * from './class/class';
+export * from './img-src/img-src';
+export * from './show-hide/show-hide';
+export * from './style/style';

package/extended/show-hide/show-hide.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @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 { ElementRef, OnChanges, SimpleChanges, AfterViewInit } from '@angular/core';
+import { BaseDirective2, LayoutConfigOptions, MediaMarshaller, StyleUtils, StyleBuilder } from '@angular/flex-layout/core';
+import * as i0 from "@angular/core";
+export interface ShowHideParent {
+    display: string;
+    isServer: boolean;
+}
+export declare class ShowHideStyleBuilder extends StyleBuilder {
+    buildStyles(show: string, parent: ShowHideParent): {
+        display: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowHideStyleBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShowHideStyleBuilder>;
+}
+export declare class ShowHideDirective extends BaseDirective2 implements AfterViewInit, OnChanges {
+    protected layoutConfig: LayoutConfigOptions;
+    protected platformId: Object;
+    protected serverModuleLoaded: boolean;
+    protected DIRECTIVE_KEY: string;
+    /** Original DOM Element CSS display style */
+    protected display: string;
+    protected hasLayout: boolean;
+    protected hasFlexChild: boolean;
+    constructor(elementRef: ElementRef, styleBuilder: ShowHideStyleBuilder, styler: StyleUtils, marshal: MediaMarshaller, layoutConfig: LayoutConfigOptions, platformId: Object, serverModuleLoaded: boolean);
+    ngAfterViewInit(): void;
+    /**
+     * On changes to any @Input properties...
+     * Default to use the non-responsive Input value ('fxShow')
+     * Then conditionally override with the mq-activated Input's current value
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     *  Watch for these extra triggers to update fxShow, fxHide stylings
+     */
+    protected trackExtraTriggers(): void;
+    /**
+     * Override accessor to the current HTMLElement's `display` style
+     * Note: Show/Hide will not change the display to 'flex' but will set it to 'block'
+     * unless it was already explicitly specified inline or in a CSS stylesheet.
+     */
+    protected getDisplayStyle(): string;
+    /** Validate the visibility value and then update the host's inline display style */
+    protected updateWithValue(value?: boolean | string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowHideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ShowHideDirective, never, never, {}, {}, never>;
+}
+/**
+ * 'show' Layout API directive
+ */
+export declare class DefaultShowHideDirective extends ShowHideDirective {
+    protected inputs: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultShowHideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultShowHideDirective, "  [fxShow], [fxShow.print],  [fxShow.xs], [fxShow.sm], [fxShow.md], [fxShow.lg], [fxShow.xl],  [fxShow.lt-sm], [fxShow.lt-md], [fxShow.lt-lg], [fxShow.lt-xl],  [fxShow.gt-xs], [fxShow.gt-sm], [fxShow.gt-md], [fxShow.gt-lg],  [fxHide], [fxHide.print],  [fxHide.xs], [fxHide.sm], [fxHide.md], [fxHide.lg], [fxHide.xl],  [fxHide.lt-sm], [fxHide.lt-md], [fxHide.lt-lg], [fxHide.lt-xl],  [fxHide.gt-xs], [fxHide.gt-sm], [fxHide.gt-md], [fxHide.gt-lg]", never, { "fxShow": "fxShow"; "fxShow.print": "fxShow.print"; "fxShow.xs": "fxShow.xs"; "fxShow.sm": "fxShow.sm"; "fxShow.md": "fxShow.md"; "fxShow.lg": "fxShow.lg"; "fxShow.xl": "fxShow.xl"; "fxShow.lt-sm": "fxShow.lt-sm"; "fxShow.lt-md": "fxShow.lt-md"; "fxShow.lt-lg": "fxShow.lt-lg"; "fxShow.lt-xl": "fxShow.lt-xl"; "fxShow.gt-xs": "fxShow.gt-xs"; "fxShow.gt-sm": "fxShow.gt-sm"; "fxShow.gt-md": "fxShow.gt-md"; "fxShow.gt-lg": "fxShow.gt-lg"; "fxHide": "fxHide"; "fxHide.print": "fxHide.print"; "fxHide.xs": "fxHide.xs"; "fxHide.sm": "fxHide.sm"; "fxHide.md": "fxHide.md"; "fxHide.lg": "fxHide.lg"; "fxHide.xl": "fxHide.xl"; "fxHide.lt-sm": "fxHide.lt-sm"; "fxHide.lt-md": "fxHide.lt-md"; "fxHide.lt-lg": "fxHide.lt-lg"; "fxHide.lt-xl": "fxHide.lt-xl"; "fxHide.gt-xs": "fxHide.gt-xs"; "fxHide.gt-sm": "fxHide.gt-sm"; "fxHide.gt-md": "fxHide.gt-md"; "fxHide.gt-lg": "fxHide.gt-lg"; }, {}, never>;
+}

package/extended/style/style-transforms.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @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 declare type NgStyleRawList = string[];
+export declare type NgStyleMap = {
+    [klass: string]: string;
+};
+export declare type NgStyleType = string | Set<string> | NgStyleRawList | NgStyleMap;
+/**
+ * Callback function for SecurityContext.STYLE sanitization
+ */
+export declare type NgStyleSanitizer = (val: any) => string;
+/** NgStyle allowed inputs */
+export declare class NgStyleKeyValue {
+    key: string;
+    value: string;
+    constructor(key: string, value: string, noQuotes?: boolean);
+}
+export declare function getType(target: any): string;
+/**
+ * Split string of key:value pairs into Array of k-v pairs
+ * e.g.  'key:value; key:value; key:value;' -> ['key:value',...]
+ */
+export declare function buildRawList(source: any, delimiter?: string): NgStyleRawList;
+/** Convert array of key:value strings to a iterable map object */
+export declare function buildMapFromList(styles: NgStyleRawList, sanitize?: NgStyleSanitizer): NgStyleMap;
+/** Convert Set<string> or raw Object to an iterable NgStyleMap */
+export declare function buildMapFromSet(source: NgStyleType, sanitize?: NgStyleSanitizer): NgStyleMap;
+/** Convert 'key:value' -> [key, value] */
+export declare function stringToKeyValue(it: string): NgStyleKeyValue;
+/** Convert [ [key,value] ] -> { key : value } */
+export declare function keyValuesToMap(map: NgStyleMap, entry: NgStyleKeyValue): NgStyleMap;

package/extended/style/style.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @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 { DoCheck, ElementRef, KeyValueDiffers, Renderer2 } from '@angular/core';
+import { NgStyle } from '@angular/common';
+import { DomSanitizer } from '@angular/platform-browser';
+import { BaseDirective2, StyleUtils, MediaMarshaller } from '@angular/flex-layout/core';
+import { NgStyleType, NgStyleMap } from './style-transforms';
+import * as i0 from "@angular/core";
+export declare class StyleDirective extends BaseDirective2 implements DoCheck {
+    protected sanitizer: DomSanitizer;
+    private readonly ngStyleInstance;
+    protected DIRECTIVE_KEY: string;
+    protected fallbackStyles: NgStyleMap;
+    protected isServer: boolean;
+    constructor(elementRef: ElementRef, styler: StyleUtils, marshal: MediaMarshaller, sanitizer: DomSanitizer, differs: KeyValueDiffers, renderer2: Renderer2, ngStyleInstance: NgStyle, serverLoaded: boolean, platformId: Object);
+    /** Add generated styles */
+    protected updateWithValue(value: any): void;
+    /** Remove generated styles */
+    protected clearStyles(): void;
+    /**
+     * Convert raw strings to ngStyleMap; which is required by ngStyle
+     * NOTE: Raw string key-value pairs MUST be delimited by `;`
+     *       Comma-delimiters are not supported due to complexities of
+     *       possible style values such as `rgba(x,x,x,x)` and others
+     */
+    protected buildStyleMap(styles: NgStyleType): NgStyleMap;
+    /** For ChangeDetectionStrategy.onPush and ngOnChanges() updates */
+    ngDoCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StyleDirective, [null, null, null, null, null, null, { optional: true; self: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StyleDirective, never, never, {}, {}, never>;
+}
+/**
+ * Directive to add responsive support for ngStyle.
+ *
+ */
+export declare class DefaultStyleDirective extends StyleDirective implements DoCheck {
+    protected inputs: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultStyleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultStyleDirective, "  [ngStyle],  [ngStyle.xs], [ngStyle.sm], [ngStyle.md], [ngStyle.lg], [ngStyle.xl],  [ngStyle.lt-sm], [ngStyle.lt-md], [ngStyle.lt-lg], [ngStyle.lt-xl],  [ngStyle.gt-xs], [ngStyle.gt-sm], [ngStyle.gt-md], [ngStyle.gt-lg]", never, { "ngStyle": "ngStyle"; "ngStyle.xs": "ngStyle.xs"; "ngStyle.sm": "ngStyle.sm"; "ngStyle.md": "ngStyle.md"; "ngStyle.lg": "ngStyle.lg"; "ngStyle.xl": "ngStyle.xl"; "ngStyle.lt-sm": "ngStyle.lt-sm"; "ngStyle.lt-md": "ngStyle.lt-md"; "ngStyle.lt-lg": "ngStyle.lt-lg"; "ngStyle.lt-xl": "ngStyle.lt-xl"; "ngStyle.gt-xs": "ngStyle.gt-xs"; "ngStyle.gt-sm": "ngStyle.gt-sm"; "ngStyle.gt-md": "ngStyle.gt-md"; "ngStyle.gt-lg": "ngStyle.gt-lg"; }, {}, never>;
+}

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

@@ -0,0 +1,357 @@
+import { extendObject, applyCssPrefixes } from '@angular/flex-layout/_private-utils';
+import { TestBed } from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+
+/**
+ * @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
+ */
+/**
+ * Exported DOM accessor utility functions
+ */
+const _dom = {
+    hasStyle,
+    getDistributedNodes,
+    getShadowRoot,
+    getText,
+    getStyle,
+    childNodes,
+    childNodesAsList,
+    hasClass,
+    hasAttribute,
+    getAttribute,
+    hasShadowRoot,
+    isCommentNode,
+    isElementNode,
+    isPresent,
+    isShadowRoot,
+    tagName,
+    lastElementChild
+};
+// ******************************************************************************************
+// These functions are cloned from
+//  *  @angular/platform-browser/src/browser/GenericBrowserDomAdapter
+// and are to be used ONLY internally in custom-matchers.ts and Unit Tests
+// ******************************************************************************************
+function getStyle(element, stylename) {
+    return element.style[stylename];
+}
+function hasStyle(element, styleName, styleValue = '', inlineOnly = true) {
+    let value = getStyle(element, styleName) || '';
+    if (!value && !inlineOnly) {
+        // Search stylesheets
+        value = typeof getComputedStyle === 'function' &&
+            getComputedStyle(element).getPropertyValue(styleName) || '';
+    }
+    return styleValue ? value == styleValue : value.length > 0;
+}
+function getDistributedNodes(el) {
+    return el.getDistributedNodes();
+}
+function getShadowRoot(el) {
+    return el.shadowRoot;
+}
+function getText(el) {
+    return el.textContent || '';
+}
+function childNodesAsList(el) {
+    const list = el.childNodes;
+    const res = new Array(list.length);
+    for (let i = 0; i < list.length; i++) {
+        res[i] = list[i];
+    }
+    return res;
+}
+function hasClass(element, className) {
+    return element.classList.contains(className);
+}
+function hasAttribute(element, attributeName) {
+    return element.hasAttribute(attributeName);
+}
+function getAttribute(element, attributeName) {
+    return element.getAttribute(attributeName);
+}
+function childNodes(el) {
+    return el.childNodes;
+}
+function hasShadowRoot(node) {
+    return isPresent(node.shadowRoot) && node instanceof HTMLElement;
+}
+function isCommentNode(node) {
+    return node.nodeType === Node.COMMENT_NODE;
+}
+function isElementNode(node) {
+    return node.nodeType === Node.ELEMENT_NODE;
+}
+function isShadowRoot(node) {
+    return node instanceof DocumentFragment;
+}
+function isPresent(obj) {
+    return obj != null;
+}
+function tagName(element) {
+    return element.tagName;
+}
+// ******************************************************************************************
+// These functions are part of the DOM API
+// and are to be used ONLY internally in custom-matchers.ts and Unit Tests
+// ******************************************************************************************
+function lastElementChild(element) {
+    return element.lastElementChild;
+}
+
+const _global = (typeof window === 'undefined' ? global : window);
+const expect$1 = _global.expect;
+/**
+ * NOTE: These custom JASMINE Matchers are used only
+ *       in the Karma/Jasmine testing for the Layout Directives
+ *       in `src/lib/flex/api`
+ */
+const customMatchers = {
+    toEqual: function (util) {
+        return {
+            compare: function (actual, expected) {
+                return { pass: util.equals(actual, expected, [compareMap]) };
+            }
+        };
+        function compareMap(actual, expected) {
+            if (actual instanceof Map) {
+                let pass = actual.size === expected.size;
+                if (pass) {
+                    actual.forEach((v, k) => {
+                        pass = pass && util.equals(v, expected.get(k));
+                    });
+                }
+                return pass;
+            }
+            else {
+                return undefined;
+            }
+        }
+    },
+    toHaveText: function () {
+        return {
+            compare: function (actual, expectedText) {
+                const actualText = elementText(actual);
+                return {
+                    pass: actualText == expectedText,
+                    get message() {
+                        return 'Expected ' + actualText + ' to be equal to ' + expectedText;
+                    }
+                };
+            }
+        };
+    },
+    toHaveCssClass: function () {
+        return { compare: buildError(false), negativeCompare: buildError(true) };
+        function buildError(isNot) {
+            return function (actual, className) {
+                return {
+                    pass: _dom.hasClass(actual, className) == !isNot,
+                    get message() {
+                        return `
+              Expected ${actual.outerHTML} ${isNot ? 'not ' : ''}
+              to contain the CSS class '${className}'
+            `;
+                    }
+                };
+            };
+        }
+    },
+    toHaveMap: function () {
+        return {
+            compare: function (actual, map) {
+                let allPassed;
+                allPassed = Object.keys(map).length !== 0;
+                Object.keys(map).forEach(key => {
+                    allPassed = allPassed && (actual[key] === map[key]);
+                });
+                return {
+                    pass: allPassed,
+                    get message() {
+                        return `
+              Expected ${JSON.stringify(actual)} ${!allPassed ? ' ' : 'not '} to contain the
+              '${JSON.stringify(map)}'
+            `;
+                    }
+                };
+            }
+        };
+    },
+    toHaveAttributes: function () {
+        return {
+            compare: function (actual, map) {
+                let allPassed;
+                let attributeNames = Object.keys(map);
+                allPassed = attributeNames.length !== 0;
+                attributeNames.forEach(name => {
+                    allPassed = allPassed && _dom.hasAttribute(actual, name)
+                        && _dom.getAttribute(actual, name) === map[name];
+                });
+                return {
+                    pass: allPassed,
+                    get message() {
+                        return `
+              Expected ${actual.outerHTML} ${allPassed ? 'not ' : ''} attributes to contain
+              '${JSON.stringify(map)}'
+            `;
+                    }
+                };
+            }
+        };
+    },
+    /**
+     * Check element's inline styles only
+     */
+    toHaveStyle: function () {
+        return {
+            compare: buildCompareStyleFunction(true)
+        };
+    },
+    /**
+     * Check element's css stylesheet only (if not present inline)
+     */
+    toHaveCSS: function () {
+        return {
+            compare: buildCompareStyleFunction(false)
+        };
+    }
+};
+/**
+ * Curried value to function to check styles that are inline or in a stylesheet for the
+ * specified DOM element.
+ */
+function buildCompareStyleFunction(inlineOnly = true) {
+    return function (actual, styles, styler) {
+        const found = {};
+        const styleMap = {};
+        if (typeof styles === 'string') {
+            styleMap[styles] = '';
+        }
+        else {
+            Object.assign(styleMap, styles);
+        }
+        let allPassed = Object.keys(styleMap).length !== 0;
+        Object.keys(styleMap).forEach(prop => {
+            let { elHasStyle, current } = hasPrefixedStyles(actual, prop, styleMap[prop], inlineOnly, styler);
+            allPassed = allPassed && elHasStyle;
+            if (!elHasStyle) {
+                extendObject(found, current);
+            }
+        });
+        return {
+            pass: allPassed,
+            get message() {
+                const expectedValueStr = (typeof styles === 'string') ? styleMap :
+                    JSON.stringify(styleMap, null, 2);
+                const foundValueStr = inlineOnly ? actual.outerHTML : JSON.stringify(found);
+                return `
+          Expected ${foundValueStr}${!allPassed ? '' : ' not'} to contain the
+          CSS ${typeof styles === 'string' ? 'property' : 'styles'} '${expectedValueStr}'
+        `;
+            }
+        };
+    };
+}
+/**
+ * Validate presence of requested style or use fallback
+ * to possible `prefixed` styles. Useful when some browsers
+ * (Safari, IE, etc) will use prefixed style instead of defaults.
+ */
+function hasPrefixedStyles(actual, key, value, inlineOnly, styler) {
+    const current = {};
+    if (value === '*') {
+        return { elHasStyle: styler.lookupStyle(actual, key, inlineOnly) !== '', current };
+    }
+    value = value.trim();
+    let elHasStyle = styler.lookupStyle(actual, key, inlineOnly) === value;
+    if (!elHasStyle) {
+        let prefixedStyles = applyCssPrefixes({ [key]: value });
+        Object.keys(prefixedStyles).forEach(prop => {
+            // Search for optional prefixed values
+            elHasStyle = elHasStyle ||
+                styler.lookupStyle(actual, prop, inlineOnly) === prefixedStyles[prop];
+        });
+    }
+    // Return BOTH confirmation and current computed key values (if confirmation == false)
+    return { elHasStyle, current };
+}
+function elementText(n) {
+    const hasNodes = (m) => {
+        const children = _dom.childNodes(m);
+        return children && children['length'];
+    };
+    if (n instanceof Array) {
+        return n.map(elementText).join('');
+    }
+    if (_dom.isCommentNode(n)) {
+        return '';
+    }
+    if (_dom.isElementNode(n) && _dom.tagName(n) == 'CONTENT') {
+        return elementText(Array.prototype.slice.apply(_dom.getDistributedNodes(n)));
+    }
+    if (_dom.hasShadowRoot(n)) {
+        return elementText(_dom.childNodesAsList(_dom.getShadowRoot(n)));
+    }
+    if (hasNodes(n)) {
+        return elementText(_dom.childNodesAsList(n));
+    }
+    return _dom.getText(n);
+}
+
+/**
+ * Function generator that captures a Component Type accessor and enables
+ * `createTestComponent()` to be reusable for *any* captured Component class.
+ */
+function makeCreateTestComponent(getClass) {
+    let componentAny;
+    // Return actual `createTestComponent()` function
+    return function createTestComponent(template, styles) {
+        if (!componentAny) {
+            // Defer access to Component class to enable metadata to be configured properly...
+            componentAny = getClass();
+        }
+        return TestBed
+            .overrideComponent(componentAny, {
+            set: {
+                template: template,
+                styles: styles || [],
+            }
+        })
+            .createComponent(componentAny);
+    };
+}
+/**
+ *
+ */
+function expectNativeEl(fixture, instanceOptions) {
+    extendObject(fixture.componentInstance, instanceOptions || {});
+    fixture.detectChanges();
+    return expect(fixture.debugElement.children[0].nativeElement);
+}
+/**
+ *
+ */
+function expectEl(debugEl) {
+    return expect(debugEl.nativeElement);
+}
+function queryFor(fixture, selector) {
+    return fixture.debugElement.queryAll(By.css(selector));
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { _dom, customMatchers, expect$1 as expect, expectEl, expectNativeEl, makeCreateTestComponent, queryFor };