@dugararchit/flex-layout 13.0.0-dugararchit

package/core/match-media/match-media.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @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 { NgZone, OnDestroy } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { MediaChange } from '../media-change';
+import * as i0 from "@angular/core";
+/**
+ * MediaMonitor configures listeners to mediaQuery changes and publishes an Observable facade to
+ * convert mediaQuery change callbacks to subscriber notifications. These notifications will be
+ * performed within the ng Zone to trigger change detections and component updates.
+ *
+ * NOTE: both mediaQuery activations and de-activations are announced in notifications
+ */
+export declare class MatchMedia implements OnDestroy {
+    protected _zone: NgZone;
+    protected _platformId: Object;
+    protected _document: any;
+    /** Initialize source with 'all' so all non-responsive APIs trigger style updates */
+    readonly source: BehaviorSubject<MediaChange>;
+    registry: Map<string, MediaQueryList>;
+    private readonly pendingRemoveListenerFns;
+    constructor(_zone: NgZone, _platformId: Object, _document: any);
+    /**
+     * Publish list of all current activations
+     */
+    get activations(): string[];
+    /**
+     * For the specified mediaQuery?
+     */
+    isActive(mediaQuery: string): boolean;
+    /**
+     * External observers can watch for all (or a specific) mql changes.
+     *
+     * If a mediaQuery is not specified, then ALL mediaQuery activations will
+     * be announced.
+     */
+    observe(): Observable<MediaChange>;
+    observe(mediaQueries: string[]): Observable<MediaChange>;
+    observe(mediaQueries: string[], filterOthers: boolean): Observable<MediaChange>;
+    /**
+     * Based on the BreakPointRegistry provider, register internal listeners for each unique
+     * mediaQuery. Each listener emits specific MediaChange data to observers
+     */
+    registerQuery(mediaQuery: string | string[]): MediaChange[];
+    ngOnDestroy(): void;
+    /**
+     * Call window.matchMedia() to build a MediaQueryList; which
+     * supports 0..n listeners for activation/deactivation
+     */
+    protected buildMQL(query: string): MediaQueryList;
+    protected _observable$: Observable<MediaChange>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchMedia, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatchMedia>;
+}

package/core/match-media/mock/mock-match-media.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @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 { NgZone } from '@angular/core';
+import { MatchMedia } from '../match-media';
+import { BreakPointRegistry } from '../../breakpoints/break-point-registry';
+import * as i0 from "@angular/core";
+/**
+ * MockMatchMedia mocks calls to the Window API matchMedia with a build of a simulated
+ * MockMediaQueryListener. Methods are available to simulate an activation of a mediaQuery
+ * range and to clearAll mediaQuery listeners.
+ */
+export declare class MockMatchMedia extends MatchMedia {
+    private _breakpoints;
+    autoRegisterQueries: boolean;
+    useOverlaps: boolean;
+    constructor(_zone: NgZone, _platformId: Object, _document: any, _breakpoints: BreakPointRegistry);
+    /** Easy method to clear all listeners for all mediaQueries */
+    clearAll(): void;
+    /** Feature to support manual, simulated activation of a mediaQuery. */
+    activate(mediaQuery: string, useOverlaps?: boolean): boolean;
+    /** Converts an optional mediaQuery alias to a specific, valid mediaQuery */
+    _validateQuery(queryOrAlias: string): string;
+    /**
+     * Manually onMediaChange any overlapping mediaQueries to simulate
+     * similar functionality in the window.matchMedia()
+     */
+    private _activateWithOverlaps;
+    /**
+     *
+     */
+    private _activateByAlias;
+    /**
+     *
+     */
+    private _activateByQuery;
+    /** Deactivate all current MQLs and reset the buffer */
+    private _deactivateAll;
+    /** Insure the mediaQuery is registered with MatchMedia */
+    private _registerMediaQuery;
+    /**
+     * Call window.matchMedia() to build a MediaQueryList; which
+     * supports 0..n listeners for activation/deactivation
+     */
+    protected buildMQL(query: string): MediaQueryList;
+    protected get hasActivated(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MockMatchMedia, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MockMatchMedia>;
+}
+/**
+ * Special internal class to simulate a MediaQueryList and
+ * - supports manual activation to simulate mediaQuery matching
+ * - manages listeners
+ */
+export declare class MockMediaQueryList implements MediaQueryList {
+    private _mediaQuery;
+    private _isActive;
+    private _listeners;
+    get matches(): boolean;
+    get media(): string;
+    constructor(_mediaQuery: string);
+    /**
+     * Destroy the current list by deactivating the
+     * listeners and clearing the internal list
+     */
+    destroy(): void;
+    /** Notify all listeners that 'matches === TRUE' */
+    activate(): MockMediaQueryList;
+    /** Notify all listeners that 'matches === false' */
+    deactivate(): MockMediaQueryList;
+    /** Add a listener to our internal list to activate later */
+    addListener(listener: MediaQueryListListener): void;
+    /** Don't need to remove listeners in the testing environment */
+    removeListener(_: MediaQueryListListener | null): void;
+    addEventListener<K extends keyof MediaQueryListEventMap>(_: K, __: (this: MediaQueryList, ev: MediaQueryListEventMap[K]) => any, ___?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof MediaQueryListEventMap>(_: K, __: (this: MediaQueryList, ev: MediaQueryListEventMap[K]) => any, ___?: boolean | EventListenerOptions): void;
+    dispatchEvent(_: Event): boolean;
+    onchange: MediaQueryListListener;
+}
+/**
+ * Pre-configured provider for MockMatchMedia
+ */
+export declare const MockMatchMediaProvider: {
+    provide: typeof MatchMedia;
+    useClass: typeof MockMatchMedia;
+};
+declare type MediaQueryListListener = ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null;
+export {};

package/core/media-change.d.ts

@@ -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
+ */
+export declare type MediaQuerySubscriber = (changes: MediaChange) => void;
+/**
+ * Class instances emitted [to observers] for each mql notification
+ */
+export declare class MediaChange {
+    matches: boolean;
+    mediaQuery: string;
+    mqAlias: string;
+    suffix: string;
+    priority: number;
+    property: string;
+    value: any;
+    /**
+     * @param matches whether the mediaQuery is currently activated
+     * @param mediaQuery e.g. (min-width: 600px) and (max-width: 959px)
+     * @param mqAlias e.g. gt-sm, md, gt-lg
+     * @param suffix e.g. GtSM, Md, GtLg
+     * @param priority the priority of activation for the given breakpoint
+     */
+    constructor(matches?: boolean, mediaQuery?: string, mqAlias?: string, suffix?: string, priority?: number);
+    /** Create an exact copy of the MediaChange */
+    clone(): MediaChange;
+}

package/core/media-marshaller/media-marshaller.d.ts

@@ -0,0 +1,123 @@
+import { Observable } from 'rxjs';
+import { BreakPoint } from '../breakpoints/break-point';
+import { BreakPointRegistry } from '../breakpoints/break-point-registry';
+import { MatchMedia } from '../match-media/match-media';
+import { MediaChange } from '../media-change';
+import { PrintHook } from './print-hook';
+import * as i0 from "@angular/core";
+declare type ClearCallback = () => void;
+declare type UpdateCallback = (val: any) => void;
+export interface ElementMatcher {
+    element: HTMLElement;
+    key: string;
+    value: any;
+}
+/**
+ * MediaMarshaller - register responsive values from directives and
+ *                   trigger them based on media query events
+ */
+export declare class MediaMarshaller {
+    protected matchMedia: MatchMedia;
+    protected breakpoints: BreakPointRegistry;
+    protected hook: PrintHook;
+    private _useFallbacks;
+    private _activatedBreakpoints;
+    private elementMap;
+    private elementKeyMap;
+    private watcherMap;
+    private updateMap;
+    private clearMap;
+    private subject;
+    get activatedAlias(): string;
+    set activatedBreakpoints(bps: BreakPoint[]);
+    get activatedBreakpoints(): BreakPoint[];
+    set useFallbacks(value: boolean);
+    constructor(matchMedia: MatchMedia, breakpoints: BreakPointRegistry, hook: PrintHook);
+    /**
+     * Update styles on breakpoint activates or deactivates
+     * @param mc
+     */
+    onMediaChange(mc: MediaChange): void;
+    /**
+     * initialize the marshaller with necessary elements for delegation on an element
+     * @param element
+     * @param key
+     * @param updateFn optional callback so that custom bp directives don't have to re-provide this
+     * @param clearFn optional callback so that custom bp directives don't have to re-provide this
+     * @param extraTriggers other triggers to force style updates (e.g. layout, directionality, etc)
+     */
+    init(element: HTMLElement, key: string, updateFn?: UpdateCallback, clearFn?: ClearCallback, extraTriggers?: Observable<any>[]): void;
+    /**
+     * get the value for an element and key and optionally a given breakpoint
+     * @param element
+     * @param key
+     * @param bp
+     */
+    getValue(element: HTMLElement, key: string, bp?: string): any;
+    /**
+     * whether the element has values for a given key
+     * @param element
+     * @param key
+     */
+    hasValue(element: HTMLElement, key: string): boolean;
+    /**
+     * Set the value for an input on a directive
+     * @param element the element in question
+     * @param key the type of the directive (e.g. flex, layout-gap, etc)
+     * @param bp the breakpoint suffix (empty string = default)
+     * @param val the value for the breakpoint
+     */
+    setValue(element: HTMLElement, key: string, val: any, bp: string): void;
+    /** Track element value changes for a specific key */
+    trackValue(element: HTMLElement, key: string): Observable<ElementMatcher>;
+    /** update all styles for all elements on the current breakpoint */
+    updateStyles(): void;
+    /**
+     * clear the styles for a given element
+     * @param element
+     * @param key
+     */
+    clearElement(element: HTMLElement, key: string): void;
+    /**
+     * update a given element with the activated values for a given key
+     * @param element
+     * @param key
+     * @param value
+     */
+    updateElement(element: HTMLElement, key: string, value: any): void;
+    /**
+     * release all references to a given element
+     * @param element
+     */
+    releaseElement(element: HTMLElement): void;
+    /**
+     * trigger an update for a given element and key (e.g. layout)
+     * @param element
+     * @param key
+     */
+    triggerUpdate(element: HTMLElement, key?: string): void;
+    /** Cross-reference for HTMLElement with directive key */
+    private buildElementKeyMap;
+    /**
+     * Other triggers that should force style updates:
+     * - directionality
+     * - layout changes
+     * - mutationobserver updates
+     */
+    private watchExtraTriggers;
+    /** Breakpoint locator by mediaQuery */
+    private findByQuery;
+    /**
+     * get the fallback breakpoint for a given element, starting with the current breakpoint
+     * @param bpMap
+     * @param key
+     */
+    private getActivatedValues;
+    /**
+     * Watch for mediaQuery breakpoint activations
+     */
+    private observeActivations;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaMarshaller, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MediaMarshaller>;
+}
+export {};

package/core/media-marshaller/print-hook.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @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 { OnDestroy } from '@angular/core';
+import { MediaChange } from '../media-change';
+import { BreakPoint } from '../breakpoints/break-point';
+import { LayoutConfigOptions } from '../tokens/library-config';
+import { BreakPointRegistry, OptionalBreakPoint } from '../breakpoints/break-point-registry';
+import * as i0 from "@angular/core";
+/**
+ * Interface to apply PrintHook to call anonymous `target.updateStyles()`
+ */
+export interface HookTarget {
+    activatedBreakpoints: BreakPoint[];
+    updateStyles(): void;
+}
+export declare const BREAKPOINT_PRINT: {
+    alias: string;
+    mediaQuery: string;
+    priority: number;
+};
+/**
+ * PrintHook - Use to intercept print MediaQuery activations and force
+ *             layouts to render with the specified print alias/breakpoint
+ *
+ * Used in MediaMarshaller and MediaObserver
+ */
+export declare class PrintHook implements OnDestroy {
+    protected breakpoints: BreakPointRegistry;
+    protected layoutConfig: LayoutConfigOptions;
+    protected _document: any;
+    constructor(breakpoints: BreakPointRegistry, layoutConfig: LayoutConfigOptions, _document: any);
+    /** Add 'print' mediaQuery: to listen for matchMedia activations */
+    withPrintQuery(queries: string[]): string[];
+    /** Is the MediaChange event for any 'print' @media */
+    isPrintEvent(e: MediaChange): boolean;
+    /** What is the desired mqAlias to use while printing? */
+    get printAlias(): string[];
+    /** Lookup breakpoints associated with print aliases. */
+    get printBreakPoints(): BreakPoint[];
+    /** Lookup breakpoint associated with mediaQuery */
+    getEventBreakpoints({ mediaQuery }: MediaChange): BreakPoint[];
+    /** Update event with printAlias mediaQuery information */
+    updateEvent(event: MediaChange): MediaChange;
+    private registeredBeforeAfterPrintHooks;
+    private isPrintingBeforeAfterEvent;
+    private beforePrintEventListeners;
+    private afterPrintEventListeners;
+    private formerActivations;
+    registerBeforeAfterPrintHooks(target: HookTarget): void;
+    /**
+     * Prepare RxJS tap operator with partial application
+     * @return pipeable tap predicate
+     */
+    interceptEvents(target: HookTarget): (event: MediaChange) => void;
+    /** Stop mediaChange event propagation in event streams */
+    blockPropagation(): (event: MediaChange) => boolean;
+    /**
+     * Save current activateBreakpoints (for later restore)
+     * and substitute only the printAlias breakpoint
+     */
+    protected startPrinting(target: HookTarget, bpList: OptionalBreakPoint[]): void;
+    /** For any print de-activations, reset the entire print queue */
+    protected stopPrinting(target: HookTarget): void;
+    /**
+     * To restore pre-Print Activations, we must capture the proper
+     * list of breakpoint activations BEFORE print starts. OnBeforePrint()
+     * is supported; so 'print' mediaQuery activations are used as a fallback
+     * in browsers without `beforeprint` support.
+     *
+     * >  But activated breakpoints are deactivated BEFORE 'print' activation.
+     *
+     * Let's capture all de-activations using the following logic:
+     *
+     *  When not printing:
+     *    - clear cache when activating non-print breakpoint
+     *    - update cache (and sort) when deactivating
+     *
+     *  When printing:
+     *    - sort and save when starting print
+     *    - restore as activatedTargets and clear when stop printing
+     */
+    collectActivations(target: HookTarget, event: MediaChange): void;
+    /** Teardown logic for the service. */
+    ngOnDestroy(): void;
+    private isPrinting;
+    private queue;
+    private deactivations;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrintHook, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PrintHook>;
+}

package/core/media-observer/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 './media-observer';

package/core/media-observer/media-observer.d.ts

@@ -0,0 +1,115 @@
+/**
+ * @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 { OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import { MediaChange } from '../media-change';
+import { MatchMedia } from '../match-media/match-media';
+import { PrintHook } from '../media-marshaller/print-hook';
+import { BreakPointRegistry } from '../breakpoints/break-point-registry';
+import * as i0 from "@angular/core";
+/**
+ * MediaObserver enables applications to listen for 1..n mediaQuery activations and to determine
+ * if a mediaQuery is currently activated.
+ *
+ * Since a breakpoint change will first deactivate 1...n mediaQueries and then possibly activate
+ * 1..n mediaQueries, the MediaObserver will debounce notifications and report ALL *activations*
+ * in 1 event notification. The reported activations will be sorted in descending priority order.
+ *
+ * This class uses the BreakPoint Registry to inject alias information into the raw MediaChange
+ * notification. For custom mediaQuery notifications, alias information will not be injected and
+ * those fields will be ''.
+ *
+ * Note: Developers should note that only mediaChange activations (not de-activations)
+ *       are announced by the MediaObserver.
+ *
+ *  @usage
+ *
+ *  // RxJS
+ *  import { filter } from 'rxjs/operators';
+ *  import { MediaObserver } from '@angular/flex-layout';
+ *
+ *  @Component({ ... })
+ *  export class AppComponent {
+ *    status: string = '';
+ *
+ *    constructor(mediaObserver: MediaObserver) {
+ *      const media$ = mediaObserver.asObservable().pipe(
+ *        filter((changes: MediaChange[]) => true)   // silly noop filter
+ *      );
+ *
+ *      media$.subscribe((changes: MediaChange[]) => {
+ *        let status = '';
+ *        changes.forEach( change => {
+ *          status += `'${change.mqAlias}' = (${change.mediaQuery}) <br/>` ;
+ *        });
+ *        this.status = status;
+ *     });
+ *
+ *    }
+ *  }
+ */
+export declare class MediaObserver implements OnDestroy {
+    protected breakpoints: BreakPointRegistry;
+    protected matchMedia: MatchMedia;
+    protected hook: PrintHook;
+    /**
+     * @deprecated Use `asObservable()` instead.
+     * @breaking-change 8.0.0-beta.25
+     * @deletion-target 10.0.0
+     */
+    readonly media$: Observable<MediaChange>;
+    /** Filter MediaChange notifications for overlapping breakpoints */
+    filterOverlaps: boolean;
+    constructor(breakpoints: BreakPointRegistry, matchMedia: MatchMedia, hook: PrintHook);
+    /**
+     * Completes the active subject, signalling to all complete for all
+     * MediaObserver subscribers
+     */
+    ngOnDestroy(): void;
+    /**
+     * Observe changes to current activation 'list'
+     */
+    asObservable(): Observable<MediaChange[]>;
+    /**
+     * Allow programmatic query to determine if one or more media query/alias match
+     * the current viewport size.
+     * @param value One or more media queries (or aliases) to check.
+     * @returns Whether any of the media queries match.
+     */
+    isActive(value: string | string[]): boolean;
+    /**
+     * Register all the mediaQueries registered in the BreakPointRegistry
+     * This is needed so subscribers can be auto-notified of all standard, registered
+     * mediaQuery activations
+     */
+    private watchActivations;
+    /**
+     * Only pass/announce activations (not de-activations)
+     *
+     * Since multiple-mediaQueries can be activation in a cycle,
+     * gather all current activations into a single list of changes to observers
+     *
+     * Inject associated (if any) alias information into the MediaChange event
+     * - Exclude mediaQuery activations for overlapping mQs. List bounded mQ ranges only
+     * - Exclude print activations that do not have an associated mediaQuery
+     *
+     * NOTE: the raw MediaChange events [from MatchMedia] do not
+     *       contain important alias information; as such this info
+     *       must be injected into the MediaChange
+     */
+    private buildObservable;
+    /**
+     * Find all current activations and prepare single list of activations
+     * sorted by descending priority.
+     */
+    private findAllActivations;
+    private readonly _media$;
+    private readonly destroyed$;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaObserver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MediaObserver>;
+}

package/core/media-trigger/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 './media-trigger';

package/core/media-trigger/media-trigger.d.ts

@@ -0,0 +1,73 @@
+import { MatchMedia } from '../match-media/match-media';
+import { BreakPointRegistry } from '../breakpoints/break-point-registry';
+import { LayoutConfigOptions } from '../tokens/library-config';
+import * as i0 from "@angular/core";
+/**
+ * Class
+ */
+export declare class MediaTrigger {
+    protected breakpoints: BreakPointRegistry;
+    protected matchMedia: MatchMedia;
+    protected layoutConfig: LayoutConfigOptions;
+    protected _platformId: Object;
+    protected _document: any;
+    constructor(breakpoints: BreakPointRegistry, matchMedia: MatchMedia, layoutConfig: LayoutConfigOptions, _platformId: Object, _document: any);
+    /**
+     * Manually activate range of breakpoints
+     * @param list array of mediaQuery or alias strings
+     */
+    activate(list: string[]): void;
+    /**
+     * Restore original, 'real' breakpoints and emit events
+     * to trigger stream notification
+     */
+    restore(): void;
+    /**
+     * Whenever window resizes, immediately auto-restore original
+     * activations (if we are simulating activations)
+     */
+    private prepareAutoRestore;
+    /**
+     * Notify all matchMedia subscribers of de-activations
+     *
+     * Note: we must force 'matches' updates for
+     *       future matchMedia::activation lookups
+     */
+    private deactivateAll;
+    /**
+     * Cache current activations as sorted, prioritized list of MediaChanges
+     */
+    private saveActivations;
+    /**
+     * Force set manual activations for specified mediaQuery list
+     */
+    private setActivations;
+    /**
+     * For specified mediaQuery list manually simulate activations or deactivations
+     */
+    private simulateMediaChanges;
+    /**
+     * Replace current registry with simulated registry...
+     * Note: this is required since MediaQueryList::matches is 'readOnly'
+     */
+    private forceRegistryMatches;
+    /**
+     * Save current MatchMedia::registry items.
+     */
+    private cacheRegistryMatches;
+    /**
+     * Restore original, 'true' registry
+     */
+    private restoreRegistryMatches;
+    /**
+     * Manually emit a MediaChange event via the MatchMedia to MediaMarshaller and MediaObserver
+     */
+    private emitChangeEvent;
+    private get currentActivations();
+    private hasCachedRegistryMatches;
+    private originalActivations;
+    private originalRegistry;
+    private resizeSubscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MediaTrigger, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MediaTrigger>;
+}

package/core/module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+/**
+ * *****************************************************************
+ * Define module for common Angular Layout utilities
+ * *****************************************************************
+ */
+export declare class CoreModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CoreModule>;
+}

package/core/multiply/multiplier.d.ts

@@ -0,0 +1,5 @@
+export interface Multiplier {
+    readonly unit: string;
+    readonly value: number;
+}
+export declare function multiply(value: string, multiplier?: Multiplier): string;

package/core/package.json

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

package/core/public-api.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @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 './browser-provider';
+export * from './media-change';
+export * from './stylesheet-map/index';
+export * from './tokens/index';
+export * from './add-alias';
+export * from './base/index';
+export * from './breakpoints/index';
+export { MatchMedia as ɵMatchMedia, MockMatchMedia as ɵMockMatchMedia, MockMatchMediaProvider as ɵMockMatchMediaProvider, } from './match-media/index';
+export * from './media-observer/index';
+export * from './media-trigger/index';
+export * from './utils/index';
+export * from './style-utils/style-utils';
+export * from './style-builder/style-builder';
+export * from './basis-validator/basis-validator';
+export * from './media-marshaller/media-marshaller';
+export * from './media-marshaller/print-hook';
+export { Multiplier, multiply as ɵmultiply } from './multiply/multiplier';