@skyux/core 8.6.0 → 9.0.0-alpha.0

package/esm2022/lib/modules/numeric/numeric.service.mjs

@@ -0,0 +1,205 @@
+import { Injectable } from '@angular/core';
+import { SkyIntlNumberFormatStyle } from '@skyux/i18n';
+import { SkyNumberFormatUtility } from '../shared/number-format/number-format-utility';
+import * as i0 from "@angular/core";
+import * as i1 from "@skyux/i18n";
+export class SkyNumericService {
+    #resourcesSvc;
+    #symbolIndex;
+    constructor(resourcesSvc) {
+        /**
+         * The browser's current locale.
+         * @internal
+         */
+        this.currentLocale = 'en-US';
+        /**
+         * @internal
+         */
+        this.shortSymbol = '';
+        this.#resourcesSvc = resourcesSvc;
+        this.#symbolIndex = [
+            { value: 1e12, label: this.#getSymbol('skyux_numeric_trillions_symbol') },
+            { value: 1e9, label: this.#getSymbol('skyux_numeric_billions_symbol') },
+            { value: 1e6, label: this.#getSymbol('skyux_numeric_millions_symbol') },
+            { value: 1e3, label: this.#getSymbol('skyux_numeric_thousands_symbol') },
+        ];
+    }
+    /**
+     * Formats a number based on the provided options.
+     * @param value The number to format.
+     * @param options Format options.
+     */
+    formatNumber(value, options) {
+        if (isNaN(value) || value === null) {
+            return '';
+        }
+        const numericOptions = {
+            digits: 0,
+            format: 'number',
+            currencySign: 'standard',
+            iso: 'USD',
+            truncateAfter: 1000,
+            ...options,
+        };
+        const decimalPlaceRegExp = /\.0+$|(\.[0-9]*[1-9])0+$/;
+        const locale = numericOptions.locale || this.currentLocale;
+        const digits = numericOptions.digits || 0;
+        // Get the symbol for the number after rounding, since rounding could push the number
+        // into a different symbol range.
+        let roundedNumber = this.#roundNumber(value, digits);
+        const roundedNumberAbs = Math.abs(roundedNumber);
+        let suffix = '';
+        for (let i = 0; i < this.#symbolIndex.length; i++) {
+            let symbol = this.#symbolIndex[i];
+            if (numericOptions.truncate &&
+                numericOptions.truncateAfter !== undefined &&
+                roundedNumberAbs >= numericOptions.truncateAfter &&
+                roundedNumberAbs >= symbol.value) {
+                roundedNumber = this.#roundNumber(value / symbol.value, digits);
+                if (Math.abs(roundedNumber) === 1000 && i > 0) {
+                    // Rounding caused the number to cross into the range of the next symbol.
+                    symbol = this.#symbolIndex[i - 1];
+                    roundedNumber /= 1000;
+                }
+                suffix = symbol.label;
+                break;
+            }
+        }
+        let output = roundedNumber.toString().replace(decimalPlaceRegExp, '$1') + suffix;
+        this.#storeShortenSymbol(output);
+        let digitsFormatted;
+        let isDecimal = false;
+        // Checks the string entered for format. Using toLowerCase to ignore case.
+        switch (numericOptions.format?.toLowerCase()) {
+            // In a case where a decimal value was not shortened and
+            // the digit input is 2 or higher, it forces 2 digits.
+            // For example, this prevents a value like $15.50 from displaying as $15.5.
+            // Note: This will need to be reviewed if we support currencies with
+            // three decimal digits.
+            case 'currency':
+                isDecimal = value % 1 !== 0;
+                if (numericOptions.minDigits) {
+                    digitsFormatted = `1.${numericOptions.minDigits}-${digits}`;
+                }
+                else if (isDecimal && digits >= 2) {
+                    digitsFormatted = `1.2-${digits}`;
+                }
+                else {
+                    digitsFormatted = `1.0-${digits}`;
+                }
+                output = SkyNumberFormatUtility.formatNumber(locale, parseFloat(output), SkyIntlNumberFormatStyle.Currency, digitsFormatted, numericOptions.iso, 
+                // Angular 5+ needs a string for this parameter, but Angular 4 needs a boolean.
+                // To support both versions we can supply 'symbol' which will evaluate truthy for Angular 4
+                // and the appropriate string value for Angular 5+.
+                // See: https://angular.io/api/common/CurrencyPipe#parameters
+                'symbol', numericOptions.currencySign);
+                //   ^^^^^^ Result can't be null since the sanitized input is always a number.
+                break;
+            // The following is a catch-all to ensure that if
+            // anything but currency (or a future option) are entered,
+            // it will be treated like a number.
+            default:
+                // Ensures localization of the number to ensure comma and
+                // decimal separator
+                if (numericOptions.minDigits) {
+                    digitsFormatted = `1.${numericOptions.minDigits}-${digits}`;
+                }
+                else if (numericOptions.truncate) {
+                    digitsFormatted = `1.0-${digits}`;
+                }
+                else {
+                    digitsFormatted = `1.${digits}-${digits}`;
+                }
+                output = SkyNumberFormatUtility.formatNumber(locale, parseFloat(output), SkyIntlNumberFormatStyle.Decimal, digitsFormatted);
+                //   ^^^^^^ Result can't be null since the sanitized input is always a number.
+                break;
+        }
+        if (numericOptions.truncate) {
+            output = this.#replaceShortenSymbol(output);
+        }
+        return output;
+    }
+    /**
+     * Rounds a given number
+     *
+     * JS's limitation - numbers bigger than Number.MIN_SAFE_INTEGER or Number.MAX_SAFE_INTEGER
+     * are not guaranteed to be represented or rounded correctly
+     * @param value - value to round
+     * @param precision - what precision to round with, defaults to 0 decimal places
+     */
+    #roundNumber(value, precision) {
+        if (precision < 0) {
+            throw new Error('SkyInvalidArgument: precision must be >= 0');
+        }
+        /* Sanity check - ignoring coverage but should not ignore if we make this method public */
+        /* istanbul ignore next */
+        if (isNaN(value) || value === null) {
+            return 0;
+        }
+        const scaledValue = this.#scaleNumberByPowerOfTen(value, precision, true);
+        const scaledRoundedValue = Math.round(scaledValue);
+        const unscaledRoundedValue = this.#scaleNumberByPowerOfTen(scaledRoundedValue, precision, false);
+        return unscaledRoundedValue;
+    }
+    /**
+     * Scales a given number by a power of 10
+     * @param value - value to scale
+     * @param scalar - 10^scalar
+     * @param scaleUp - whether to increase or decrease the value
+     */
+    #scaleNumberByPowerOfTen(value, scalar, scaleUp) {
+        const valueStr = value.toString().toLowerCase();
+        const isExponentFormat = valueStr.includes('e');
+        if (isExponentFormat) {
+            const [base, exp] = valueStr.split('e');
+            const newExp = scaleUp ? Number(exp) + scalar : Number(exp) - scalar;
+            return Number(`${base}e${newExp}`);
+        }
+        else {
+            const e = scaleUp ? 'e' : 'e-';
+            return Number(`${value}${e}${scalar}`);
+        }
+    }
+    /**
+     * Stores the symbol added from shortening to reapply later.
+     * @param value The string to derive the shorten symbol from.
+     */
+    #storeShortenSymbol(value) {
+        const symbols = this.#symbolIndex.map((s) => s.label);
+        const regexp = new RegExp(symbols.join('|'), 'ig');
+        const match = value.match(regexp);
+        this.shortSymbol = match ? match.toString() : '';
+    }
+    /**
+     * Must have previously called storeShortenSymbol to have something to replace.
+     * Finds the last number in the formatted number, gets the index of the position
+     * after that character and re-inserts the symbol.
+     * Works regardless of currency symbol position.
+     * @param value The string to modify.
+     */
+    #replaceShortenSymbol(value) {
+        const result = /(\d)(?!.*\d)/g.exec(value);
+        /*istanbul ignore else*/
+        if (result) {
+            const pos = result.index + result.length;
+            const output = value.substring(0, pos) + this.shortSymbol + value.substring(pos);
+            return output;
+        }
+        else {
+            return value;
+        }
+    }
+    #getSymbol(key) {
+        // TODO: Need to implement the async `getString` method in a breaking change.
+        return this.#resourcesSvc.getStringForLocale({ locale: 'en_US' }, key);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyNumericService, deps: [{ token: i1.SkyLibResourcesService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyNumericService, providedIn: 'any' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyNumericService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'any',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkyLibResourcesService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"numeric.service.js","sourceRoot":"","sources":["../../../../../../../../libs/components/core/src/lib/modules/numeric/numeric.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { SkyIntlNumberFormatStyle, SkyLibResourcesService } from '@skyux/i18n';\n\nimport { SkyNumberFormatUtility } from '../shared/number-format/number-format-utility';\n\nimport { SkyNumericSymbol } from './numeric-symbol';\nimport { SkyNumericOptions } from './numeric.options';\n\n@Injectable({\n  providedIn: 'any',\n})\nexport class SkyNumericService {\n  /**\n   * The browser's current locale.\n   * @internal\n   */\n  public currentLocale = 'en-US';\n\n  /**\n   * @internal\n   */\n  public shortSymbol = '';\n\n  #resourcesSvc: SkyLibResourcesService;\n\n  #symbolIndex: SkyNumericSymbol[];\n\n  constructor(resourcesSvc: SkyLibResourcesService) {\n    this.#resourcesSvc = resourcesSvc;\n\n    this.#symbolIndex = [\n      { value: 1e12, label: this.#getSymbol('skyux_numeric_trillions_symbol') },\n      { value: 1e9, label: this.#getSymbol('skyux_numeric_billions_symbol') },\n      { value: 1e6, label: this.#getSymbol('skyux_numeric_millions_symbol') },\n      { value: 1e3, label: this.#getSymbol('skyux_numeric_thousands_symbol') },\n    ];\n  }\n\n  /**\n   * Formats a number based on the provided options.\n   * @param value The number to format.\n   * @param options Format options.\n   */\n  public formatNumber(value: number, options: SkyNumericOptions): string {\n    if (isNaN(value) || value === null) {\n      return '';\n    }\n\n    const numericOptions: SkyNumericOptions = {\n      digits: 0,\n      format: 'number',\n      currencySign: 'standard',\n      iso: 'USD',\n      truncateAfter: 1000,\n      ...options,\n    };\n\n    const decimalPlaceRegExp = /\\.0+$|(\\.[0-9]*[1-9])0+$/;\n    const locale = numericOptions.locale || this.currentLocale;\n    const digits = numericOptions.digits || 0;\n\n    // Get the symbol for the number after rounding, since rounding could push the number\n    // into a different symbol range.\n    let roundedNumber = this.#roundNumber(value, digits);\n    const roundedNumberAbs = Math.abs(roundedNumber);\n\n    let suffix = '';\n\n    for (let i = 0; i < this.#symbolIndex.length; i++) {\n      let symbol = this.#symbolIndex[i];\n\n      if (\n        numericOptions.truncate &&\n        numericOptions.truncateAfter !== undefined &&\n        roundedNumberAbs >= numericOptions.truncateAfter &&\n        roundedNumberAbs >= symbol.value\n      ) {\n        roundedNumber = this.#roundNumber(value / symbol.value, digits);\n\n        if (Math.abs(roundedNumber) === 1000 && i > 0) {\n          // Rounding caused the number to cross into the range of the next symbol.\n          symbol = this.#symbolIndex[i - 1];\n          roundedNumber /= 1000;\n        }\n\n        suffix = symbol.label;\n\n        break;\n      }\n    }\n\n    let output: string =\n      roundedNumber.toString().replace(decimalPlaceRegExp, '$1') + suffix;\n\n    this.#storeShortenSymbol(output);\n\n    let digitsFormatted: string | undefined;\n    let isDecimal = false;\n\n    // Checks the string entered for format. Using toLowerCase to ignore case.\n    switch (numericOptions.format?.toLowerCase()) {\n      // In a case where a decimal value was not shortened and\n      // the digit input is 2 or higher, it forces 2 digits.\n      // For example, this prevents a value like $15.50 from displaying as $15.5.\n      // Note: This will need to be reviewed if we support currencies with\n      // three decimal digits.\n      case 'currency':\n        isDecimal = value % 1 !== 0;\n\n        if (numericOptions.minDigits) {\n          digitsFormatted = `1.${numericOptions.minDigits}-${digits}`;\n        } else if (isDecimal && digits >= 2) {\n          digitsFormatted = `1.2-${digits}`;\n        } else {\n          digitsFormatted = `1.0-${digits}`;\n        }\n\n        output = SkyNumberFormatUtility.formatNumber(\n          locale,\n          parseFloat(output),\n          SkyIntlNumberFormatStyle.Currency,\n          digitsFormatted,\n          numericOptions.iso,\n          // Angular 5+ needs a string for this parameter, but Angular 4 needs a boolean.\n          // To support both versions we can supply 'symbol' which will evaluate truthy for Angular 4\n          // and the appropriate string value for Angular 5+.\n          // See: https://angular.io/api/common/CurrencyPipe#parameters\n          'symbol' as any,\n          numericOptions.currencySign\n        ) as string;\n        //   ^^^^^^ Result can't be null since the sanitized input is always a number.\n        break;\n\n      // The following is a catch-all to ensure that if\n      // anything but currency (or a future option) are entered,\n      // it will be treated like a number.\n      default:\n        // Ensures localization of the number to ensure comma and\n        // decimal separator\n        if (numericOptions.minDigits) {\n          digitsFormatted = `1.${numericOptions.minDigits}-${digits}`;\n        } else if (numericOptions.truncate) {\n          digitsFormatted = `1.0-${digits}`;\n        } else {\n          digitsFormatted = `1.${digits}-${digits}`;\n        }\n\n        output = SkyNumberFormatUtility.formatNumber(\n          locale,\n          parseFloat(output),\n          SkyIntlNumberFormatStyle.Decimal,\n          digitsFormatted\n        ) as string;\n        //   ^^^^^^ Result can't be null since the sanitized input is always a number.\n        break;\n    }\n\n    if (numericOptions.truncate) {\n      output = this.#replaceShortenSymbol(output);\n    }\n\n    return output;\n  }\n\n  /**\n   * Rounds a given number\n   *\n   * JS's limitation - numbers bigger than Number.MIN_SAFE_INTEGER or Number.MAX_SAFE_INTEGER\n   * are not guaranteed to be represented or rounded correctly\n   * @param value - value to round\n   * @param precision - what precision to round with, defaults to 0 decimal places\n   */\n  #roundNumber(value: number, precision: number): number {\n    if (precision < 0) {\n      throw new Error('SkyInvalidArgument: precision must be >= 0');\n    }\n\n    /* Sanity check - ignoring coverage but should not ignore if we make this method public */\n    /* istanbul ignore next */\n    if (isNaN(value) || value === null) {\n      return 0;\n    }\n\n    const scaledValue: number = this.#scaleNumberByPowerOfTen(\n      value,\n      precision,\n      true\n    );\n    const scaledRoundedValue: number = Math.round(scaledValue);\n    const unscaledRoundedValue: number = this.#scaleNumberByPowerOfTen(\n      scaledRoundedValue,\n      precision,\n      false\n    );\n\n    return unscaledRoundedValue;\n  }\n\n  /**\n   * Scales a given number by a power of 10\n   * @param value - value to scale\n   * @param scalar - 10^scalar\n   * @param scaleUp - whether to increase or decrease the value\n   */\n  #scaleNumberByPowerOfTen(\n    value: number,\n    scalar: number,\n    scaleUp: boolean\n  ): number {\n    const valueStr: string = value.toString().toLowerCase();\n    const isExponentFormat: boolean = valueStr.includes('e');\n\n    if (isExponentFormat) {\n      const [base, exp] = valueStr.split('e');\n      const newExp = scaleUp ? Number(exp) + scalar : Number(exp) - scalar;\n      return Number(`${base}e${newExp}`);\n    } else {\n      const e = scaleUp ? 'e' : 'e-';\n      return Number(`${value}${e}${scalar}`);\n    }\n  }\n\n  /**\n   * Stores the symbol added from shortening to reapply later.\n   * @param value The string to derive the shorten symbol from.\n   */\n  #storeShortenSymbol(value: string): void {\n    const symbols: string[] = this.#symbolIndex.map((s) => s.label);\n    const regexp = new RegExp(symbols.join('|'), 'ig');\n    const match = value.match(regexp);\n    this.shortSymbol = match ? match.toString() : '';\n  }\n\n  /**\n   * Must have previously called storeShortenSymbol to have something to replace.\n   * Finds the last number in the formatted number, gets the index of the position\n   * after that character and re-inserts the symbol.\n   * Works regardless of currency symbol position.\n   * @param value The string to modify.\n   */\n  #replaceShortenSymbol(value: string): string {\n    const result = /(\\d)(?!.*\\d)/g.exec(value);\n    /*istanbul ignore else*/\n    if (result) {\n      const pos = result.index + result.length;\n      const output =\n        value.substring(0, pos) + this.shortSymbol + value.substring(pos);\n\n      return output;\n    } else {\n      return value;\n    }\n  }\n\n  #getSymbol(key: string): string {\n    // TODO: Need to implement the async `getString` method in a breaking change.\n    return this.#resourcesSvc.getStringForLocale({ locale: 'en_US' }, key);\n  }\n}\n"]}

package/esm2022/lib/modules/overlay/overlay-adapter.service.mjs

@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @internal
+ */
+export class SkyOverlayAdapterService {
+    #renderer;
+    #styleElement;
+    constructor(rendererFactory) {
+        this.#renderer = rendererFactory.createRenderer(undefined, null);
+    }
+    restrictBodyScroll() {
+        // Create a style element to avoid overwriting any existing inline body styles.
+        const styleElement = this.#renderer.createElement('style');
+        const textNode = this.#renderer.createText('body { overflow: hidden }');
+        // Apply a `data-` attribute to make unit testing easier.
+        this.#renderer.setAttribute(styleElement, 'data-test-selector', 'sky-overlay-restrict-scroll-styles');
+        this.#renderer.appendChild(styleElement, textNode);
+        this.#renderer.appendChild(document.head, styleElement);
+        if (this.#styleElement) {
+            this.#destroyStyleElement();
+        }
+        this.#styleElement = styleElement;
+    }
+    releaseBodyScroll() {
+        this.#destroyStyleElement();
+    }
+    #destroyStyleElement() {
+        /* istanbul ignore else */
+        if (this.#styleElement &&
+            this.#styleElement.parentElement === document.head) {
+            this.#renderer.removeChild(document.head, this.#styleElement);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyOverlayAdapterService, deps: [{ token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyOverlayAdapterService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyOverlayAdapterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.RendererFactory2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modules/overlay/overlay-instance.mjs

@@ -0,0 +1,62 @@
+import { Subject } from 'rxjs';
+/**
+ * Represents a new overlay instance. It is used to manage the "closed" state of the overlay,
+ * and access any public members on the appended content component instance.
+ */
+export class SkyOverlayInstance {
+    /**
+     * Emits when the overlay is clicked (but not its content).
+     */
+    get backdropClick() {
+        return this.#backdropClickObs;
+    }
+    /**
+     * Emits after the overlay is closed.
+     */
+    get closed() {
+        return this.#closedObs;
+    }
+    #backdropClick;
+    #backdropClickObs;
+    #closed;
+    #closedObs;
+    constructor(
+    /**
+     * The configuration for the overlay.
+     */
+    config, componentRef) {
+        this.config = config;
+        this.componentRef = componentRef;
+        this.id = this.componentRef.instance.id;
+        this.componentRef.instance.closed.subscribe(() => {
+            this.#closed.next();
+            this.#closed.complete();
+            this.#backdropClick.complete();
+        });
+        this.componentRef.instance.backdropClick.subscribe(() => {
+            this.#backdropClick.next();
+        });
+        this.#backdropClick = new Subject();
+        this.#closed = new Subject();
+        this.#backdropClickObs = this.#backdropClick.asObservable();
+        this.#closedObs = this.#closed.asObservable();
+    }
+    /**
+     * Creates and attaches a component to the overlay.
+     * @param component The component to attach.
+     * @param providers Custom providers to apply to the component.
+     */
+    attachComponent(component, providers) {
+        const componentRef = this.componentRef.instance.attachComponent(component, providers);
+        return componentRef.instance;
+    }
+    /**
+     * Attaches a `TemplateRef` to the overlay.
+     * @param templateRef The `TemplateRef` to attach.
+     * @param context The context to provide to the template.
+     */
+    attachTemplate(templateRef, context) {
+        this.componentRef.instance.attachTemplate(templateRef, context);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modules/overlay/overlay.component.mjs

@@ -0,0 +1,193 @@
+import { ChangeDetectionStrategy, Component, ElementRef, HostBinding, Injector, Optional, ViewChild, ViewContainerRef, } from '@angular/core';
+import { NavigationStart } from '@angular/router';
+import { BehaviorSubject, ReplaySubject, Subject, fromEvent, } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { SKY_STACKING_CONTEXT } from '../stacking-context/stacking-context-token';
+import * as i0 from "@angular/core";
+import * as i1 from "../adapter-service/adapter.service";
+import * as i2 from "./overlay-context";
+import * as i3 from "../id/id.service";
+import * as i4 from "@angular/router";
+import * as i5 from "@angular/common";
+const POSITION_DEFAULT = 'fixed';
+/**
+ * Omnibar is 1000.
+ * See: https://github.com/blackbaud/auth-client/blob/master/src/omnibar/omnibar.ts#L139
+ * ---
+ * Modals start their z-indexes at 1040. However, each modal's z-index is a multiple of 10, so it
+ * will be difficult to reliably predict a z-index that will always appear above all other
+ * layers. Starting the z-index for overlays at a number much greater than modals will accommodate
+ * the most reasonable of scenarios.
+ * See: https://github.com/blackbaud/skyux-modals/blob/master/src/app/public/modules/modal/modal-host.service.ts#L22
+ * (NOTE: It should be noted that modals do not use the overlay service, which is something we
+ * should do in the near future to make sure z-indexes are predictable across all component
+ * libraries.)
+ */
+let uniqueZIndex = 5000;
+/**
+ * @internal
+ */
+export class SkyOverlayComponent {
+    get backdropClick() {
+        return this.#backdropClickObs;
+    }
+    get closed() {
+        return this.#closedObs;
+    }
+    #backdropClick;
+    #backdropClickObs;
+    #changeDetector;
+    #closed;
+    #closedObs;
+    #context;
+    #coreAdapter;
+    #injector;
+    #ngUnsubscribe;
+    #router;
+    #routerSubscription;
+    constructor(changeDetector, injector, coreAdapter, context, idSvc, router) {
+        this.wrapperClass = '';
+        this.enablePointerEvents = false;
+        this.showBackdrop = false;
+        this.zIndex = `${++uniqueZIndex}`;
+        this.clipPath$ = new ReplaySubject(1);
+        this.position = POSITION_DEFAULT;
+        this.#ngUnsubscribe = new Subject();
+        this.#changeDetector = changeDetector;
+        this.#injector = injector;
+        this.#coreAdapter = coreAdapter;
+        this.#context = context;
+        this.#router = router;
+        this.id = idSvc.generateId();
+        this.#backdropClick = new Subject();
+        this.#closed = new Subject();
+        this.#backdropClickObs = this.#backdropClick.asObservable();
+        this.#closedObs = this.#closed.asObservable();
+    }
+    ngOnInit() {
+        this.#applyConfig(this.#context.config);
+        setTimeout(() => {
+            this.#addBackdropClickListener();
+        });
+        if (this.#context.config.closeOnNavigation) {
+            this.#addRouteListener();
+        }
+    }
+    ngOnDestroy() {
+        this.#removeRouteListener();
+        this.#ngUnsubscribe.next();
+        this.#ngUnsubscribe.complete();
+        this.#backdropClick.complete();
+        this.#closed.next();
+        this.#closed.complete();
+    }
+    attachComponent(component, providers = []) {
+        /*istanbul ignore if: untestable*/
+        if (!this.targetRef) {
+            throw new Error('[SkyOverlayComponent] Could not attach the component because the target element could not be found.');
+        }
+        this.targetRef.clear();
+        const injector = Injector.create({
+            providers: [
+                {
+                    provide: SKY_STACKING_CONTEXT,
+                    useValue: {
+                        zIndex: new BehaviorSubject(parseInt(this.zIndex, 10))
+                            .asObservable()
+                            .pipe(takeUntil(this.#ngUnsubscribe)),
+                    },
+                },
+                ...providers,
+            ],
+            parent: this.#injector,
+        });
+        const componentRef = this.targetRef.createComponent(component, {
+            injector,
+        });
+        // Run an initial change detection cycle after the component has been created.
+        componentRef.changeDetectorRef.detectChanges();
+        return componentRef;
+    }
+    attachTemplate(templateRef, context) {
+        /*istanbul ignore if: untestable*/
+        if (!this.targetRef) {
+            throw new Error('[SkyOverlayComponent] Could not attach the template because the target element could not be found.');
+        }
+        this.targetRef.clear();
+        return this.targetRef.createEmbeddedView(templateRef, context);
+    }
+    updateClipPath(clipPath) {
+        this.clipPath$.next(clipPath);
+    }
+    #applyConfig(config) {
+        this.wrapperClass = config.wrapperClass || '';
+        this.showBackdrop = !!config.showBackdrop;
+        this.enablePointerEvents = !!config.enablePointerEvents;
+        this.position = config.position || POSITION_DEFAULT;
+        this.#changeDetector.markForCheck();
+    }
+    #addBackdropClickListener() {
+        fromEvent(window.document, 'click')
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe((event) => {
+            if (event.target && this.overlayContentRef && this.overlayRef) {
+                const isChild = this.overlayContentRef.nativeElement.contains(event.target);
+                const isAbove = this.#coreAdapter.isTargetAboveElement(event.target, this.overlayRef.nativeElement);
+                /* istanbul ignore else */
+                if (!isChild && !isAbove) {
+                    this.#backdropClick.next();
+                    if (this.#context.config.enableClose) {
+                        this.#closed.next();
+                    }
+                }
+            }
+        });
+    }
+    #addRouteListener() {
+        /*istanbul ignore else*/
+        if (this.#router) {
+            this.#routerSubscription = this.#router.events.subscribe((event) => {
+                /* istanbul ignore else */
+                if (event instanceof NavigationStart) {
+                    this.#closed.next();
+                }
+            });
+        }
+    }
+    #removeRouteListener() {
+        if (this.#routerSubscription) {
+            this.#routerSubscription.unsubscribe();
+            this.#routerSubscription = undefined;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyOverlayComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.Injector }, { token: i1.SkyCoreAdapterService }, { token: i2.SkyOverlayContext }, { token: i3.SkyIdService }, { token: i4.Router, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: SkyOverlayComponent, selector: "sky-overlay", host: { properties: { "id": "this.id" } }, viewQueries: [{ propertyName: "overlayContentRef", first: true, predicate: ["overlayContentRef"], descendants: true, read: ElementRef, static: true }, { propertyName: "overlayRef", first: true, predicate: ["overlayRef"], descendants: true, read: ElementRef, static: true }, { propertyName: "targetRef", first: true, predicate: ["target"], descendants: true, read: ViewContainerRef, static: true }], ngImport: i0, template: "<div\n  [class]=\"'sky-overlay-position-' + position + ' ' + wrapperClass\"\n  [style.z-index]=\"zIndex\"\n  [style.clip-path]=\"clipPath$ | async\"\n  [ngClass]=\"{\n    'enable-pointer-events-pass-through': enablePointerEvents,\n    'sky-overlay': true\n  }\"\n  #overlayRef\n>\n  <div class=\"sky-overlay-content\" #overlayContentRef>\n    <ng-template #target> </ng-template>\n  </div>\n  <div *ngIf=\"showBackdrop\" class=\"sky-overlay-backdrop\"></div>\n</div>\n", styles: [".sky-overlay{inset:0;width:100%;height:100%;display:flex;pointer-events:auto}.sky-overlay-position-absolute{position:absolute}.sky-overlay-position-fixed{position:fixed}.sky-overlay-content{position:relative;z-index:1;display:inline-flex;align-self:start;pointer-events:auto}.sky-overlay-backdrop{background:rgba(0,0,0,.5);inset:0;width:100%;height:100%;position:absolute}.enable-pointer-events-pass-through,.enable-pointer-events-pass-through .sky-overlay-backdrop{pointer-events:none}.enable-pointer-events-pass-through .sky-overlay-content{pointer-events:auto}\n"], dependencies: [{ kind: "directive", type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyOverlayComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sky-overlay', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div\n  [class]=\"'sky-overlay-position-' + position + ' ' + wrapperClass\"\n  [style.z-index]=\"zIndex\"\n  [style.clip-path]=\"clipPath$ | async\"\n  [ngClass]=\"{\n    'enable-pointer-events-pass-through': enablePointerEvents,\n    'sky-overlay': true\n  }\"\n  #overlayRef\n>\n  <div class=\"sky-overlay-content\" #overlayContentRef>\n    <ng-template #target> </ng-template>\n  </div>\n  <div *ngIf=\"showBackdrop\" class=\"sky-overlay-backdrop\"></div>\n</div>\n", styles: [".sky-overlay{inset:0;width:100%;height:100%;display:flex;pointer-events:auto}.sky-overlay-position-absolute{position:absolute}.sky-overlay-position-fixed{position:fixed}.sky-overlay-content{position:relative;z-index:1;display:inline-flex;align-self:start;pointer-events:auto}.sky-overlay-backdrop{background:rgba(0,0,0,.5);inset:0;width:100%;height:100%;position:absolute}.enable-pointer-events-pass-through,.enable-pointer-events-pass-through .sky-overlay-backdrop{pointer-events:none}.enable-pointer-events-pass-through .sky-overlay-content{pointer-events:auto}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.Injector }, { type: i1.SkyCoreAdapterService }, { type: i2.SkyOverlayContext }, { type: i3.SkyIdService }, { type: i4.Router, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { id: [{
+                type: HostBinding,
+                args: ['id']
+            }], overlayContentRef: [{
+                type: ViewChild,
+                args: ['overlayContentRef', {
+                        read: ElementRef,
+                        static: true,
+                    }]
+            }], overlayRef: [{
+                type: ViewChild,
+                args: ['overlayRef', {
+                        read: ElementRef,
+                        static: true,
+                    }]
+            }], targetRef: [{
+                type: ViewChild,
+                args: ['target', {
+                        read: ViewContainerRef,
+                        static: true,
+                    }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay.component.js","sourceRoot":"","sources":["../../../../../../../../libs/components/core/src/lib/modules/overlay/overlay.component.ts","../../../../../../../../libs/components/core/src/lib/modules/overlay/overlay.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ComponentRef,\n  ElementRef,\n  EmbeddedViewRef,\n  HostBinding,\n  Injector,\n  OnDestroy,\n  OnInit,\n  Optional,\n  StaticProvider,\n  TemplateRef,\n  Type,\n  ViewChild,\n  ViewContainerRef,\n} from '@angular/core';\nimport { NavigationStart, Router } from '@angular/router';\n\nimport {\n  BehaviorSubject,\n  Observable,\n  ReplaySubject,\n  Subject,\n  Subscription,\n  fromEvent,\n} from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { SkyCoreAdapterService } from '../adapter-service/adapter.service';\nimport { SkyIdService } from '../id/id.service';\nimport { SKY_STACKING_CONTEXT } from '../stacking-context/stacking-context-token';\n\nimport { SkyOverlayConfig } from './overlay-config';\nimport { SkyOverlayContext } from './overlay-context';\nimport { SkyOverlayPosition } from './overlay-position';\n\nconst POSITION_DEFAULT: SkyOverlayPosition = 'fixed';\n\n/**\n * Omnibar is 1000.\n * See: https://github.com/blackbaud/auth-client/blob/master/src/omnibar/omnibar.ts#L139\n * ---\n * Modals start their z-indexes at 1040. However, each modal's z-index is a multiple of 10, so it\n * will be difficult to reliably predict a z-index that will always appear above all other\n * layers. Starting the z-index for overlays at a number much greater than modals will accommodate\n * the most reasonable of scenarios.\n * See: https://github.com/blackbaud/skyux-modals/blob/master/src/app/public/modules/modal/modal-host.service.ts#L22\n * (NOTE: It should be noted that modals do not use the overlay service, which is something we\n * should do in the near future to make sure z-indexes are predictable across all component\n * libraries.)\n */\nlet uniqueZIndex = 5000;\n\n/**\n * @internal\n */\n@Component({\n  selector: 'sky-overlay',\n  templateUrl: './overlay.component.html',\n  styleUrls: ['./overlay.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class SkyOverlayComponent implements OnInit, OnDestroy {\n  public wrapperClass = '';\n\n  public get backdropClick(): Observable<void> {\n    return this.#backdropClickObs;\n  }\n\n  public get closed(): Observable<void> {\n    return this.#closedObs;\n  }\n\n  public enablePointerEvents = false;\n\n  @HostBinding('id')\n  public id: string;\n\n  public showBackdrop = false;\n\n  public zIndex = `${++uniqueZIndex}`;\n\n  protected clipPath$ = new ReplaySubject<string | undefined>(1);\n\n  protected position = POSITION_DEFAULT;\n\n  @ViewChild('overlayContentRef', {\n    read: ElementRef,\n    static: true,\n  })\n  public overlayContentRef: ElementRef | undefined;\n\n  @ViewChild('overlayRef', {\n    read: ElementRef,\n    static: true,\n  })\n  public overlayRef: ElementRef | undefined;\n\n  @ViewChild('target', {\n    read: ViewContainerRef,\n    static: true,\n  })\n  public targetRef: ViewContainerRef | undefined;\n\n  #backdropClick: Subject<void>;\n\n  #backdropClickObs: Observable<void>;\n\n  #changeDetector: ChangeDetectorRef;\n\n  #closed: Subject<void>;\n\n  #closedObs: Observable<void>;\n\n  #context: SkyOverlayContext;\n\n  #coreAdapter: SkyCoreAdapterService;\n\n  #injector: Injector;\n\n  #ngUnsubscribe = new Subject<void>();\n\n  #router: Router | undefined;\n\n  #routerSubscription: Subscription | undefined;\n\n  constructor(\n    changeDetector: ChangeDetectorRef,\n    injector: Injector,\n    coreAdapter: SkyCoreAdapterService,\n    context: SkyOverlayContext,\n    idSvc: SkyIdService,\n    @Optional() router?: Router\n  ) {\n    this.#changeDetector = changeDetector;\n    this.#injector = injector;\n    this.#coreAdapter = coreAdapter;\n    this.#context = context;\n    this.#router = router;\n\n    this.id = idSvc.generateId();\n\n    this.#backdropClick = new Subject<void>();\n    this.#closed = new Subject<void>();\n\n    this.#backdropClickObs = this.#backdropClick.asObservable();\n    this.#closedObs = this.#closed.asObservable();\n  }\n\n  public ngOnInit(): void {\n    this.#applyConfig(this.#context.config);\n\n    setTimeout(() => {\n      this.#addBackdropClickListener();\n    });\n\n    if (this.#context.config.closeOnNavigation) {\n      this.#addRouteListener();\n    }\n  }\n\n  public ngOnDestroy(): void {\n    this.#removeRouteListener();\n    this.#ngUnsubscribe.next();\n    this.#ngUnsubscribe.complete();\n\n    this.#backdropClick.complete();\n\n    this.#closed.next();\n    this.#closed.complete();\n  }\n\n  public attachComponent<C>(\n    component: Type<C>,\n    providers: StaticProvider[] = []\n  ): ComponentRef<C> {\n    /*istanbul ignore if: untestable*/\n    if (!this.targetRef) {\n      throw new Error(\n        '[SkyOverlayComponent] Could not attach the component because the target element could not be found.'\n      );\n    }\n\n    this.targetRef.clear();\n\n    const injector = Injector.create({\n      providers: [\n        {\n          provide: SKY_STACKING_CONTEXT,\n          useValue: {\n            zIndex: new BehaviorSubject(parseInt(this.zIndex, 10))\n              .asObservable()\n              .pipe(takeUntil(this.#ngUnsubscribe)),\n          },\n        },\n        ...providers,\n      ],\n      parent: this.#injector,\n    });\n\n    const componentRef = this.targetRef.createComponent<C>(component, {\n      injector,\n    });\n\n    // Run an initial change detection cycle after the component has been created.\n    componentRef.changeDetectorRef.detectChanges();\n\n    return componentRef;\n  }\n\n  public attachTemplate<T>(\n    templateRef: TemplateRef<T>,\n    context: T\n  ): EmbeddedViewRef<T> {\n    /*istanbul ignore if: untestable*/\n    if (!this.targetRef) {\n      throw new Error(\n        '[SkyOverlayComponent] Could not attach the template because the target element could not be found.'\n      );\n    }\n\n    this.targetRef.clear();\n\n    return this.targetRef.createEmbeddedView(templateRef, context);\n  }\n\n  public updateClipPath(clipPath: string | undefined): void {\n    this.clipPath$.next(clipPath);\n  }\n\n  #applyConfig(config: SkyOverlayConfig): void {\n    this.wrapperClass = config.wrapperClass || '';\n    this.showBackdrop = !!config.showBackdrop;\n    this.enablePointerEvents = !!config.enablePointerEvents;\n    this.position = config.position || POSITION_DEFAULT;\n    this.#changeDetector.markForCheck();\n  }\n\n  #addBackdropClickListener(): void {\n    fromEvent<MouseEvent>(window.document, 'click')\n      .pipe(takeUntil(this.#ngUnsubscribe))\n      .subscribe((event) => {\n        if (event.target && this.overlayContentRef && this.overlayRef) {\n          const isChild = this.overlayContentRef.nativeElement.contains(\n            event.target\n          );\n\n          const isAbove = this.#coreAdapter.isTargetAboveElement(\n            event.target,\n            this.overlayRef.nativeElement\n          );\n\n          /* istanbul ignore else */\n          if (!isChild && !isAbove) {\n            this.#backdropClick.next();\n            if (this.#context.config.enableClose) {\n              this.#closed.next();\n            }\n          }\n        }\n      });\n  }\n\n  #addRouteListener(): void {\n    /*istanbul ignore else*/\n    if (this.#router) {\n      this.#routerSubscription = this.#router.events.subscribe((event) => {\n        /* istanbul ignore else */\n        if (event instanceof NavigationStart) {\n          this.#closed.next();\n        }\n      });\n    }\n  }\n\n  #removeRouteListener(): void {\n    if (this.#routerSubscription) {\n      this.#routerSubscription.unsubscribe();\n      this.#routerSubscription = undefined;\n    }\n  }\n}\n","<div\n  [class]=\"'sky-overlay-position-' + position + ' ' + wrapperClass\"\n  [style.z-index]=\"zIndex\"\n  [style.clip-path]=\"clipPath$ | async\"\n  [ngClass]=\"{\n    'enable-pointer-events-pass-through': enablePointerEvents,\n    'sky-overlay': true\n  }\"\n  #overlayRef\n>\n  <div class=\"sky-overlay-content\" #overlayContentRef>\n    <ng-template #target> </ng-template>\n  </div>\n  <div *ngIf=\"showBackdrop\" class=\"sky-overlay-backdrop\"></div>\n</div>\n"]}

package/{esm2020 → esm2022}/lib/modules/overlay/overlay.module.mjs

@@ -3,15 +3,15 @@ import { NgModule } from '@angular/core';
 import { SkyOverlayComponent } from './overlay.component';
 import * as i0 from "@angular/core";
 export class SkyOverlayModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyOverlayModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: SkyOverlayModule, declarations: [SkyOverlayComponent], imports: [CommonModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyOverlayModule, imports: [CommonModule] }); }
 }
-SkyOverlayModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyOverlayModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-SkyOverlayModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: SkyOverlayModule, declarations: [SkyOverlayComponent], imports: [CommonModule] });
-SkyOverlayModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyOverlayModule, imports: [CommonModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SkyOverlayModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyOverlayModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [CommonModule],
                     declarations: [SkyOverlayComponent],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvY29yZS9zcmMvbGliL21vZHVsZXMvb3ZlcmxheS9vdmVybGF5Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQzs7QUFNMUQsTUFBTSxPQUFPLGdCQUFnQjs7NkdBQWhCLGdCQUFnQjs4R0FBaEIsZ0JBQWdCLGlCQUZaLG1CQUFtQixhQUR4QixZQUFZOzhHQUdYLGdCQUFnQixZQUhqQixZQUFZOzJGQUdYLGdCQUFnQjtrQkFKNUIsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7b0JBQ3ZCLFlBQVksRUFBRSxDQUFDLG1CQUFtQixDQUFDO2lCQUNwQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBTa3lPdmVybGF5Q29tcG9uZW50IH0gZnJvbSAnLi9vdmVybGF5LmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICBkZWNsYXJhdGlvbnM6IFtTa3lPdmVybGF5Q29tcG9uZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgU2t5T3ZlcmxheU1vZHVsZSB7fVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvY29yZS9zcmMvbGliL21vZHVsZXMvb3ZlcmxheS9vdmVybGF5Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQzs7QUFNMUQsTUFBTSxPQUFPLGdCQUFnQjs4R0FBaEIsZ0JBQWdCOytHQUFoQixnQkFBZ0IsaUJBRlosbUJBQW1CLGFBRHhCLFlBQVk7K0dBR1gsZ0JBQWdCLFlBSGpCLFlBQVk7OzJGQUdYLGdCQUFnQjtrQkFKNUIsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7b0JBQ3ZCLFlBQVksRUFBRSxDQUFDLG1CQUFtQixDQUFDO2lCQUNwQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBTa3lPdmVybGF5Q29tcG9uZW50IH0gZnJvbSAnLi9vdmVybGF5LmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICBkZWNsYXJhdGlvbnM6IFtTa3lPdmVybGF5Q29tcG9uZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgU2t5T3ZlcmxheU1vZHVsZSB7fVxuIl19