init

node_modules/@angular/cdk/overlay/_index-deprecated.scss

@@ -0,0 +1,13 @@
+@use './index' as overlay;
+
+// @deprecated Use `$overlay-container-z-index`.
+$z-index-overlay-container: overlay.$overlay-container-z-index;
+
+// @deprecated Use `$overlay-z-index`.
+$z-index-overlay: overlay.$overlay-z-index;
+
+// @deprecated Use `$overlay-backdrop-color`.
+$dark-backdrop-background: overlay.$overlay-backdrop-color;
+
+// @deprecated Use `$overlay-backdrop-z-index`.
+$z-index-overlay-backdrop: overlay.$overlay-backdrop-z-index;

node_modules/@angular/cdk/overlay/_index.scss

@@ -0,0 +1,193 @@
+// We want overlays to always appear over user content, so set a baseline
+// very high z-index for the overlay container, which is where we create the new
+// stacking context for all overlays.
+$overlay-container-z-index: 1000 !default;
+$overlay-z-index: 1000 !default;
+$overlay-backdrop-z-index: 1000 !default;
+
+// Background color for all of the backdrops
+$overlay-backdrop-color: rgba(0, 0, 0, 0.32) !default;
+
+// Default backdrop animation is based on the Material Design swift-ease-out.
+$backdrop-animation-duration: 400ms !default;
+$backdrop-animation-timing-function: cubic-bezier(0.25, 0.8, 0.25, 1) !default;
+
+// Conditionally wraps some styles in a layer depending on a flag.
+@mixin _conditional-layer($should-wrap) {
+  @if ($should-wrap) {
+    @layer cdk-overlay {
+      @content;
+    }
+  } @else {
+    @content;
+  }
+}
+
+// Structural styles for the overlay. Pass `$wrap-customizable-styles` to emit
+// the styles that support customization in a way that makes them easier to change.
+@mixin private-overlay-structure($wrap-customizable-styles) {
+  .cdk-overlay-container, .cdk-global-overlay-wrapper {
+    // Disable events from being captured on the overlay container.
+    pointer-events: none;
+
+    // The container should be the size of the viewport.
+    top: 0;
+    left: 0;
+    height: 100%;
+    width: 100%;
+  }
+
+  // The overlay-container is an invisible element which contains all individual overlays.
+  .cdk-overlay-container {
+    position: fixed;
+
+    @include _conditional-layer($wrap-customizable-styles) {
+      z-index: $overlay-container-z-index;
+    }
+
+    &:empty {
+      // Hide the element when it doesn't have any child nodes. This doesn't
+      // include overlays that have been detached, rather than disposed.
+      display: none;
+    }
+  }
+
+  // We use an extra wrapper element in order to use make the overlay itself a flex item.
+  // This makes centering the overlay easy without running into the subpixel rendering
+  // problems tied to using `transform` and without interfering with the other position
+  // strategies.
+  .cdk-global-overlay-wrapper {
+    display: flex;
+    position: absolute;
+
+    @include _conditional-layer($wrap-customizable-styles) {
+      z-index: $overlay-z-index;
+    }
+  }
+
+  // A single overlay pane.
+  .cdk-overlay-pane {
+    // Note: it's important for this one to start off `absolute`,
+    // in order for us to be able to measure it correctly.
+    position: absolute;
+    pointer-events: auto;
+    box-sizing: border-box;
+
+    // For connected-position overlays, we set `display: flex` in
+    // order to force `max-width` and `max-height` to take effect.
+    display: flex;
+    max-width: 100%;
+    max-height: 100%;
+
+    @include _conditional-layer($wrap-customizable-styles) {
+      z-index: $overlay-z-index;
+    }
+  }
+
+  .cdk-overlay-backdrop {
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    left: 0;
+    right: 0;
+
+    pointer-events: auto;
+    -webkit-tap-highlight-color: transparent;
+    opacity: 0;
+
+    // Removes the tap delay on touch devices (see #30965).
+    touch-action: manipulation;
+
+    @include _conditional-layer($wrap-customizable-styles) {
+      z-index: $overlay-backdrop-z-index;
+      transition: opacity $backdrop-animation-duration $backdrop-animation-timing-function;
+    }
+
+    @media (prefers-reduced-motion) {
+      transition-duration: 1ms;
+    }
+  }
+
+  .cdk-overlay-backdrop-showing {
+    opacity: 1;
+
+    // Note that we can't import and use the `high-contrast` mixin from `_a11y.scss`, because
+    // this file will be copied to the top-level `cdk` package when putting together the files
+    // for npm. Any relative import paths we use here will become invalid once the file is copied.
+    @media (forced-colors: active) {
+      // In high contrast mode the rgba background will become solid
+      // so we need to fall back to making it opaque using `opacity`.
+      opacity: 0.6;
+    }
+  }
+
+  .cdk-overlay-dark-backdrop {
+    @include _conditional-layer($wrap-customizable-styles) {
+      background: $overlay-backdrop-color;
+    }
+  }
+
+  .cdk-overlay-transparent-backdrop {
+    // Define a transition on the visibility so that the `transitionend` event can fire immediately.
+    transition: visibility 1ms linear, opacity 1ms linear;
+    visibility: hidden;
+    opacity: 1;
+
+    // Note: as of Firefox 57, having the backdrop be `background: none` will prevent it from
+    // capturing the user's mouse scroll events. Since we also can't use something like
+    // `rgba(0, 0, 0, 0)`, we work around the inconsistency by not setting the background at
+    // all and using `opacity` to make the element transparent.
+    &.cdk-overlay-backdrop-showing,
+    .cdk-high-contrast-active & {
+      opacity: 0;
+      visibility: visible;
+    }
+  }
+
+  .cdk-overlay-backdrop-noop-animation {
+    transition: none;
+  }
+
+  // Overlay parent element used with the connected position strategy. Used to constrain the
+  // overlay element's size to fit within the viewport.
+  .cdk-overlay-connected-position-bounding-box {
+    position: absolute;
+
+    // We use `display: flex` on this element exclusively for centering connected overlays.
+    // When *not* centering, a top/left/bottom/right will be set which overrides the normal
+    // flex layout.
+    display: flex;
+
+    // We use the `column` direction here to avoid some flexbox issues in Edge
+    // when using the "grow after open" options.
+    flex-direction: column;
+
+    // Add some dimensions so the element has an `innerText` which some people depend on in tests.
+    min-width: 1px;
+    min-height: 1px;
+
+    @include _conditional-layer($wrap-customizable-styles) {
+      z-index: $overlay-z-index;
+    }
+  }
+
+  // Used when disabling global scrolling.
+  .cdk-global-scrollblock {
+    position: fixed;
+
+    // Necessary for the content not to lose its width. Note that we're using 100%, instead of
+    // 100vw, because 100vw includes the width plus the scrollbar, whereas 100% is the width
+    // that the element had before we made it `fixed`.
+    width: 100%;
+
+    // Note: this will always add a scrollbar to whatever element it is on, which can
+    // potentially result in double scrollbars. It shouldn't be an issue, because we won't
+    // block scrolling on a page that doesn't have a scrollbar in the first place.
+    overflow-y: scroll;
+  }
+}
+
+/// Emits structural styles required for cdk/overlay to function.
+@mixin overlay {
+  @include private-overlay-structure(false);
+}

node_modules/@angular/cdk/overlay/index.d.ts

@@ -0,0 +1,328 @@
+import { ScrollStrategy, OverlayRef, PositionStrategy, FlexibleConnectedPositionStrategyOrigin, FlexibleConnectedPositionStrategy, OverlayConfig, OverlayContainer } from '../overlay-module.d.js';
+export { CdkConnectedOverlay, CdkOverlayOrigin, ConnectedOverlayPositionChange, ConnectedPosition, ConnectionPositionPair, HorizontalConnectionPos, OriginConnectionPosition, OverlayConnectionPosition, OverlayKeyboardDispatcher, OverlayModule, OverlayOutsideClickDispatcher, OverlaySizeConfig, STANDARD_DROPDOWN_ADJACENT_POSITIONS, STANDARD_DROPDOWN_BELOW_POSITIONS, ScrollingVisibility, VerticalConnectionPos, createFlexibleConnectedPositionStrategy, validateHorizontalPosition, validateVerticalPosition } from '../overlay-module.d.js';
+import { ScrollDispatcher } from '../scrolling-module.d.js';
+export { CdkScrollable, CdkFixedSizeVirtualScroll as ɵɵCdkFixedSizeVirtualScroll, CdkScrollableModule as ɵɵCdkScrollableModule, CdkVirtualForOf as ɵɵCdkVirtualForOf, CdkVirtualScrollViewport as ɵɵCdkVirtualScrollViewport, CdkVirtualScrollableElement as ɵɵCdkVirtualScrollableElement, CdkVirtualScrollableWindow as ɵɵCdkVirtualScrollableWindow } from '../scrolling-module.d.js';
+import { ViewportRuler } from '../scrolling/index.js';
+import * as i0 from '@angular/core';
+import { Injector, NgZone, OnDestroy } from '@angular/core';
+export { ComponentType } from '../portal-directives.d.js';
+export { Dir as ɵɵDir } from '../bidi-module.d.js';
+import '@angular/common';
+import 'rxjs';
+import '../platform.d.js';
+import '../style-loader.d.js';
+import '../data-source.d.js';
+import '../number-property.d.js';
+
+/**
+ * Config options for the RepositionScrollStrategy.
+ */
+interface RepositionScrollStrategyConfig {
+    /** Time in milliseconds to throttle the scroll events. */
+    scrollThrottle?: number;
+    /** Whether to close the overlay once the user has scrolled away completely. */
+    autoClose?: boolean;
+}
+/**
+ * Creates a scroll strategy that updates the overlay's position when the user scrolls.
+ * @param injector Injector used to resolve dependencies of the scroll strategy.
+ * @param config Configuration options for the scroll strategy.
+ */
+declare function createRepositionScrollStrategy(injector: Injector, config?: RepositionScrollStrategyConfig): RepositionScrollStrategy;
+/**
+ * Strategy that will update the element position as the user is scrolling.
+ */
+declare class RepositionScrollStrategy implements ScrollStrategy {
+    private _scrollDispatcher;
+    private _viewportRuler;
+    private _ngZone;
+    private _config?;
+    private _scrollSubscription;
+    private _overlayRef;
+    constructor(_scrollDispatcher: ScrollDispatcher, _viewportRuler: ViewportRuler, _ngZone: NgZone, _config?: RepositionScrollStrategyConfig | undefined);
+    /** Attaches this scroll strategy to an overlay. */
+    attach(overlayRef: OverlayRef): void;
+    /** Enables repositioning of the attached overlay on scroll. */
+    enable(): void;
+    /** Disables repositioning of the attached overlay on scroll. */
+    disable(): void;
+    detach(): void;
+}
+
+/**
+ * Creates a scroll strategy that prevents the user from scrolling while the overlay is open.
+ * @param injector Injector used to resolve dependencies of the scroll strategy.
+ * @param config Configuration options for the scroll strategy.
+ */
+declare function createBlockScrollStrategy(injector: Injector): BlockScrollStrategy;
+/**
+ * Strategy that will prevent the user from scrolling while the overlay is visible.
+ */
+declare class BlockScrollStrategy implements ScrollStrategy {
+    private _viewportRuler;
+    private _previousHTMLStyles;
+    private _previousScrollPosition;
+    private _isEnabled;
+    private _document;
+    constructor(_viewportRuler: ViewportRuler, document: any);
+    /** Attaches this scroll strategy to an overlay. */
+    attach(): void;
+    /** Blocks page-level scroll while the attached overlay is open. */
+    enable(): void;
+    /** Unblocks page-level scroll while the attached overlay is open. */
+    disable(): void;
+    private _canBeEnabled;
+}
+
+/**
+ * Config options for the CloseScrollStrategy.
+ */
+interface CloseScrollStrategyConfig {
+    /** Amount of pixels the user has to scroll before the overlay is closed. */
+    threshold?: number;
+}
+/**
+ * Creates a scroll strategy that closes the overlay when the user starts to scroll.
+ * @param injector Injector used to resolve dependencies of the scroll strategy.
+ * @param config Configuration options for the scroll strategy.
+ */
+declare function createCloseScrollStrategy(injector: Injector, config?: CloseScrollStrategyConfig): CloseScrollStrategy;
+/**
+ * Strategy that will close the overlay as soon as the user starts scrolling.
+ */
+declare class CloseScrollStrategy implements ScrollStrategy {
+    private _scrollDispatcher;
+    private _ngZone;
+    private _viewportRuler;
+    private _config?;
+    private _scrollSubscription;
+    private _overlayRef;
+    private _initialScrollPosition;
+    constructor(_scrollDispatcher: ScrollDispatcher, _ngZone: NgZone, _viewportRuler: ViewportRuler, _config?: CloseScrollStrategyConfig | undefined);
+    /** Attaches this scroll strategy to an overlay. */
+    attach(overlayRef: OverlayRef): void;
+    /** Enables the closing of the attached overlay on scroll. */
+    enable(): void;
+    /** Disables the closing the attached overlay on scroll. */
+    disable(): void;
+    detach(): void;
+    /** Detaches the overlay ref and disables the scroll strategy. */
+    private _detach;
+}
+
+/** Creates a scroll strategy that does nothing. */
+declare function createNoopScrollStrategy(): NoopScrollStrategy;
+/** Scroll strategy that doesn't do anything. */
+declare class NoopScrollStrategy implements ScrollStrategy {
+    /** Does nothing, as this scroll strategy is a no-op. */
+    enable(): void;
+    /** Does nothing, as this scroll strategy is a no-op. */
+    disable(): void;
+    /** Does nothing, as this scroll strategy is a no-op. */
+    attach(): void;
+}
+
+/**
+ * Options for how an overlay will handle scrolling.
+ *
+ * Users can provide a custom value for `ScrollStrategyOptions` to replace the default
+ * behaviors. This class primarily acts as a factory for ScrollStrategy instances.
+ */
+declare class ScrollStrategyOptions {
+    private _injector;
+    constructor(...args: unknown[]);
+    /** Do nothing on scroll. */
+    noop: () => NoopScrollStrategy;
+    /**
+     * Close the overlay as soon as the user scrolls.
+     * @param config Configuration to be used inside the scroll strategy.
+     */
+    close: (config?: CloseScrollStrategyConfig) => CloseScrollStrategy;
+    /** Block scrolling. */
+    block: () => BlockScrollStrategy;
+    /**
+     * Update the overlay's position on scroll.
+     * @param config Configuration to be used inside the scroll strategy.
+     * Allows debouncing the reposition calls.
+     */
+    reposition: (config?: RepositionScrollStrategyConfig) => RepositionScrollStrategy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollStrategyOptions, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollStrategyOptions>;
+}
+
+/**
+ * Creates a global position strategy.
+ * @param injector Injector used to resolve dependencies for the strategy.
+ */
+declare function createGlobalPositionStrategy(_injector: Injector): GlobalPositionStrategy;
+/**
+ * A strategy for positioning overlays. Using this strategy, an overlay is given an
+ * explicit position relative to the browser's viewport. We use flexbox, instead of
+ * transforms, in order to avoid issues with subpixel rendering which can cause the
+ * element to become blurry.
+ */
+declare class GlobalPositionStrategy implements PositionStrategy {
+    /** The overlay to which this strategy is attached. */
+    private _overlayRef;
+    private _cssPosition;
+    private _topOffset;
+    private _bottomOffset;
+    private _alignItems;
+    private _xPosition;
+    private _xOffset;
+    private _width;
+    private _height;
+    private _isDisposed;
+    attach(overlayRef: OverlayRef): void;
+    /**
+     * Sets the top position of the overlay. Clears any previously set vertical position.
+     * @param value New top offset.
+     */
+    top(value?: string): this;
+    /**
+     * Sets the left position of the overlay. Clears any previously set horizontal position.
+     * @param value New left offset.
+     */
+    left(value?: string): this;
+    /**
+     * Sets the bottom position of the overlay. Clears any previously set vertical position.
+     * @param value New bottom offset.
+     */
+    bottom(value?: string): this;
+    /**
+     * Sets the right position of the overlay. Clears any previously set horizontal position.
+     * @param value New right offset.
+     */
+    right(value?: string): this;
+    /**
+     * Sets the overlay to the start of the viewport, depending on the overlay direction.
+     * This will be to the left in LTR layouts and to the right in RTL.
+     * @param offset Offset from the edge of the screen.
+     */
+    start(value?: string): this;
+    /**
+     * Sets the overlay to the end of the viewport, depending on the overlay direction.
+     * This will be to the right in LTR layouts and to the left in RTL.
+     * @param offset Offset from the edge of the screen.
+     */
+    end(value?: string): this;
+    /**
+     * Sets the overlay width and clears any previously set width.
+     * @param value New width for the overlay
+     * @deprecated Pass the `width` through the `OverlayConfig`.
+     * @breaking-change 8.0.0
+     */
+    width(value?: string): this;
+    /**
+     * Sets the overlay height and clears any previously set height.
+     * @param value New height for the overlay
+     * @deprecated Pass the `height` through the `OverlayConfig`.
+     * @breaking-change 8.0.0
+     */
+    height(value?: string): this;
+    /**
+     * Centers the overlay horizontally with an optional offset.
+     * Clears any previously set horizontal position.
+     *
+     * @param offset Overlay offset from the horizontal center.
+     */
+    centerHorizontally(offset?: string): this;
+    /**
+     * Centers the overlay vertically with an optional offset.
+     * Clears any previously set vertical position.
+     *
+     * @param offset Overlay offset from the vertical center.
+     */
+    centerVertically(offset?: string): this;
+    /**
+     * Apply the position to the element.
+     * @docs-private
+     */
+    apply(): void;
+    /**
+     * Cleans up the DOM changes from the position strategy.
+     * @docs-private
+     */
+    dispose(): void;
+}
+
+/** Builder for overlay position strategy. */
+declare class OverlayPositionBuilder {
+    private _injector;
+    constructor(...args: unknown[]);
+    /**
+     * Creates a global position strategy.
+     */
+    global(): GlobalPositionStrategy;
+    /**
+     * Creates a flexible position strategy.
+     * @param origin Origin relative to which to position the overlay.
+     */
+    flexibleConnectedTo(origin: FlexibleConnectedPositionStrategyOrigin): FlexibleConnectedPositionStrategy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayPositionBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayPositionBuilder>;
+}
+
+/**
+ * Creates an overlay.
+ * @param injector Injector to use when resolving the overlay's dependencies.
+ * @param config Configuration applied to the overlay.
+ * @returns Reference to the created overlay.
+ */
+declare function createOverlayRef(injector: Injector, config?: OverlayConfig): OverlayRef;
+/**
+ * Service to create Overlays. Overlays are dynamically added pieces of floating UI, meant to be
+ * used as a low-level building block for other components. Dialogs, tooltips, menus,
+ * selects, etc. can all be built using overlays. The service should primarily be used by authors
+ * of re-usable components rather than developers building end-user applications.
+ *
+ * An overlay *is* a PortalOutlet, so any kind of Portal can be loaded into one.
+ */
+declare class Overlay {
+    scrollStrategies: ScrollStrategyOptions;
+    private _positionBuilder;
+    private _injector;
+    constructor(...args: unknown[]);
+    /**
+     * Creates an overlay.
+     * @param config Configuration applied to the overlay.
+     * @returns Reference to the created overlay.
+     */
+    create(config?: OverlayConfig): OverlayRef;
+    /**
+     * Gets a position builder that can be used, via fluent API,
+     * to construct and configure a position strategy.
+     * @returns An overlay position builder.
+     */
+    position(): OverlayPositionBuilder;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Overlay, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Overlay>;
+}
+
+/**
+ * Alternative to OverlayContainer that supports correct displaying of overlay elements in
+ * Fullscreen mode
+ * https://developer.mozilla.org/en-US/docs/Web/API/Element/requestFullScreen
+ *
+ * Should be provided in the root component.
+ */
+declare class FullscreenOverlayContainer extends OverlayContainer implements OnDestroy {
+    private _renderer;
+    private _fullScreenEventName;
+    private _cleanupFullScreenListener;
+    constructor(...args: unknown[]);
+    ngOnDestroy(): void;
+    protected _createContainer(): void;
+    private _adjustParentForFullscreenChange;
+    private _getEventName;
+    /**
+     * When the page is put into fullscreen mode, a specific element is specified.
+     * Only that element and its children are visible when in fullscreen mode.
+     */
+    getFullscreenElement(): Element;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FullscreenOverlayContainer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FullscreenOverlayContainer>;
+}
+
+export { BlockScrollStrategy, CloseScrollStrategy, FlexibleConnectedPositionStrategy, FlexibleConnectedPositionStrategyOrigin, FullscreenOverlayContainer, GlobalPositionStrategy, NoopScrollStrategy, Overlay, OverlayConfig, OverlayContainer, OverlayPositionBuilder, OverlayRef, PositionStrategy, RepositionScrollStrategy, ScrollDispatcher, ScrollStrategy, ScrollStrategyOptions, ViewportRuler, createBlockScrollStrategy, createCloseScrollStrategy, createGlobalPositionStrategy, createNoopScrollStrategy, createOverlayRef, createRepositionScrollStrategy };
+export type { RepositionScrollStrategyConfig };