@angular/material 13.0.0-next.4 → 13.0.0-next.8

package/esm2020/input/testing/input-harness.mjs

@@ -0,0 +1,113 @@
+/**
+ * @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 { HarnessPredicate, parallel } from '@angular/cdk/testing';
+import { MatFormFieldControlHarness } from '@angular/material/form-field/testing/control';
+/** Harness for interacting with a standard Material inputs in tests. */
+export class MatInputHarness extends MatFormFieldControlHarness {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatInputHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which input instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return new HarnessPredicate(MatInputHarness, options)
+            .addOption('value', options.value, (harness, value) => {
+            return HarnessPredicate.stringMatches(harness.getValue(), value);
+        })
+            .addOption('placeholder', options.placeholder, (harness, placeholder) => {
+            return HarnessPredicate.stringMatches(harness.getPlaceholder(), placeholder);
+        });
+    }
+    /** Whether the input is disabled. */
+    async isDisabled() {
+        return (await this.host()).getProperty('disabled');
+    }
+    /** Whether the input is required. */
+    async isRequired() {
+        return (await this.host()).getProperty('required');
+    }
+    /** Whether the input is readonly. */
+    async isReadonly() {
+        return (await this.host()).getProperty('readOnly');
+    }
+    /** Gets the value of the input. */
+    async getValue() {
+        // The "value" property of the native input is never undefined.
+        return (await (await this.host()).getProperty('value'));
+    }
+    /** Gets the name of the input. */
+    async getName() {
+        // The "name" property of the native input is never undefined.
+        return (await (await this.host()).getProperty('name'));
+    }
+    /**
+     * Gets the type of the input. Returns "textarea" if the input is
+     * a textarea.
+     */
+    async getType() {
+        // The "type" property of the native input is never undefined.
+        return (await (await this.host()).getProperty('type'));
+    }
+    /** Gets the placeholder of the input. */
+    async getPlaceholder() {
+        const host = await this.host();
+        const [nativePlaceholder, fallback] = await parallel(() => [
+            host.getProperty('placeholder'),
+            host.getAttribute('data-placeholder')
+        ]);
+        return nativePlaceholder || fallback || '';
+    }
+    /** Gets the id of the input. */
+    async getId() {
+        // The input directive always assigns a unique id to the input in
+        // case no id has been explicitly specified.
+        return (await (await this.host()).getProperty('id'));
+    }
+    /**
+     * Focuses the input and returns a promise that indicates when the
+     * action is complete.
+     */
+    async focus() {
+        return (await this.host()).focus();
+    }
+    /**
+     * Blurs the input and returns a promise that indicates when the
+     * action is complete.
+     */
+    async blur() {
+        return (await this.host()).blur();
+    }
+    /** Whether the input is focused. */
+    async isFocused() {
+        return (await this.host()).isFocused();
+    }
+    /**
+     * Sets the value of the input. The value will be set by simulating
+     * keypresses that correspond to the given value.
+     */
+    async setValue(newValue) {
+        const inputEl = await this.host();
+        await inputEl.clear();
+        // We don't want to send keys for the value if the value is an empty
+        // string in order to clear the value. Sending keys with an empty string
+        // still results in unnecessary focus events.
+        if (newValue) {
+            await inputEl.sendKeys(newValue);
+        }
+        // Some input types won't respond to key presses (e.g. `color`) so to be sure that the
+        // value is set, we also set the property after the keyboard sequence. Note that we don't
+        // want to do it before, because it can cause the value to be entered twice.
+        await inputEl.setInputValue(newValue);
+    }
+}
+// TODO: We do not want to handle `select` elements with `matNativeControl` because
+// not all methods of this harness work reasonably for native select elements.
+// For more details. See: https://github.com/angular/components/pull/18221.
+MatInputHarness.hostSelector = '[matInput], input[matNativeControl], textarea[matNativeControl]';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-harness.js","sourceRoot":"","sources":["../../../../../../../src/material/input/testing/input-harness.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {HarnessPredicate, parallel} from '@angular/cdk/testing';\nimport {MatFormFieldControlHarness} from '@angular/material/form-field/testing/control';\nimport {InputHarnessFilters} from './input-harness-filters';\n\n/** Harness for interacting with a standard Material inputs in tests. */\nexport class MatInputHarness extends MatFormFieldControlHarness {\n  // TODO: We do not want to handle `select` elements with `matNativeControl` because\n  // not all methods of this harness work reasonably for native select elements.\n  // For more details. See: https://github.com/angular/components/pull/18221.\n  static hostSelector = '[matInput], input[matNativeControl], textarea[matNativeControl]';\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a `MatInputHarness` that meets\n   * certain criteria.\n   * @param options Options for filtering which input instances are considered a match.\n   * @return a `HarnessPredicate` configured with the given options.\n   */\n  static with(options: InputHarnessFilters = {}): HarnessPredicate<MatInputHarness> {\n    return new HarnessPredicate(MatInputHarness, options)\n        .addOption('value', options.value, (harness, value) => {\n          return HarnessPredicate.stringMatches(harness.getValue(), value);\n        })\n        .addOption('placeholder', options.placeholder, (harness, placeholder) => {\n          return HarnessPredicate.stringMatches(harness.getPlaceholder(), placeholder);\n        });\n  }\n\n  /** Whether the input is disabled. */\n  async isDisabled(): Promise<boolean> {\n    return (await this.host()).getProperty<boolean>('disabled');\n  }\n\n  /** Whether the input is required. */\n  async isRequired(): Promise<boolean> {\n    return (await this.host()).getProperty<boolean>('required');\n  }\n\n  /** Whether the input is readonly. */\n  async isReadonly(): Promise<boolean> {\n    return (await this.host()).getProperty<boolean>('readOnly');\n  }\n\n  /** Gets the value of the input. */\n  async getValue(): Promise<string> {\n    // The \"value\" property of the native input is never undefined.\n    return (await (await this.host()).getProperty<string>('value'));\n  }\n\n  /** Gets the name of the input. */\n  async getName(): Promise<string> {\n    // The \"name\" property of the native input is never undefined.\n    return (await (await this.host()).getProperty<string>('name'));\n  }\n\n  /**\n   * Gets the type of the input. Returns \"textarea\" if the input is\n   * a textarea.\n   */\n  async getType(): Promise<string> {\n    // The \"type\" property of the native input is never undefined.\n    return (await (await this.host()).getProperty<string>('type'));\n  }\n\n  /** Gets the placeholder of the input. */\n  async getPlaceholder(): Promise<string> {\n    const host = await this.host();\n    const [nativePlaceholder, fallback] = await parallel(() => [\n      host.getProperty('placeholder'),\n      host.getAttribute('data-placeholder')\n    ]);\n    return nativePlaceholder || fallback || '';\n  }\n\n  /** Gets the id of the input. */\n  async getId(): Promise<string> {\n    // The input directive always assigns a unique id to the input in\n    // case no id has been explicitly specified.\n    return (await (await this.host()).getProperty<string>('id'));\n  }\n\n  /**\n   * Focuses the input and returns a promise that indicates when the\n   * action is complete.\n   */\n  async focus(): Promise<void> {\n    return (await this.host()).focus();\n  }\n\n  /**\n   * Blurs the input and returns a promise that indicates when the\n   * action is complete.\n   */\n  async blur(): Promise<void> {\n    return (await this.host()).blur();\n  }\n\n  /** Whether the input is focused. */\n  async isFocused(): Promise<boolean> {\n    return (await this.host()).isFocused();\n  }\n\n  /**\n   * Sets the value of the input. The value will be set by simulating\n   * keypresses that correspond to the given value.\n   */\n  async setValue(newValue: string): Promise<void> {\n    const inputEl = await this.host();\n    await inputEl.clear();\n    // We don't want to send keys for the value if the value is an empty\n    // string in order to clear the value. Sending keys with an empty string\n    // still results in unnecessary focus events.\n    if (newValue) {\n      await inputEl.sendKeys(newValue);\n    }\n\n    // Some input types won't respond to key presses (e.g. `color`) so to be sure that the\n    // value is set, we also set the property after the keyboard sequence. Note that we don't\n    // want to do it before, because it can cause the value to be entered twice.\n    await inputEl.setInputValue(newValue);\n  }\n}\n"]}

package/esm2020/input/testing/native-option-harness.mjs

@@ -0,0 +1,42 @@
+/**
+ * @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 { ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+/** Harness for interacting with a native `option` in tests. */
+export class MatNativeOptionHarness extends ComponentHarness {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatNativeOptionHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which option instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return new HarnessPredicate(MatNativeOptionHarness, options)
+            .addOption('text', options.text, async (harness, title) => HarnessPredicate.stringMatches(await harness.getText(), title))
+            .addOption('index', options.index, async (harness, index) => await harness.getIndex() === index)
+            .addOption('isSelected', options.isSelected, async (harness, isSelected) => await harness.isSelected() === isSelected);
+    }
+    /** Gets the option's label text. */
+    async getText() {
+        return (await this.host()).getProperty('label');
+    }
+    /** Index of the option within the native `select` element. */
+    async getIndex() {
+        return (await this.host()).getProperty('index');
+    }
+    /** Gets whether the option is disabled. */
+    async isDisabled() {
+        return (await this.host()).getProperty('disabled');
+    }
+    /** Gets whether the option is selected. */
+    async isSelected() {
+        return (await this.host()).getProperty('selected');
+    }
+}
+/** Selector used to locate option instances. */
+MatNativeOptionHarness.hostSelector = 'select[matNativeControl] option';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/input/testing/native-select-harness.mjs

@@ -0,0 +1,79 @@
+/**
+ * @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 { HarnessPredicate, parallel } from '@angular/cdk/testing';
+import { MatFormFieldControlHarness } from '@angular/material/form-field/testing/control';
+import { MatNativeOptionHarness } from './native-option-harness';
+/** Harness for interacting with a native `select` in tests. */
+export class MatNativeSelectHarness extends MatFormFieldControlHarness {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatNativeSelectHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which select instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return new HarnessPredicate(MatNativeSelectHarness, options);
+    }
+    /** Gets a boolean promise indicating if the select is disabled. */
+    async isDisabled() {
+        return (await this.host()).getProperty('disabled');
+    }
+    /** Gets a boolean promise indicating if the select is required. */
+    async isRequired() {
+        return (await this.host()).getProperty('required');
+    }
+    /** Gets a boolean promise indicating if the select is in multi-selection mode. */
+    async isMultiple() {
+        return (await this.host()).getProperty('multiple');
+    }
+    /** Gets the name of the select. */
+    async getName() {
+        // The "name" property of the native select is never undefined.
+        return (await (await this.host()).getProperty('name'));
+    }
+    /** Gets the id of the select. */
+    async getId() {
+        // We're guaranteed to have an id, because the `matNativeControl` always assigns one.
+        return (await (await this.host()).getProperty('id'));
+    }
+    /** Focuses the select and returns a void promise that indicates when the action is complete. */
+    async focus() {
+        return (await this.host()).focus();
+    }
+    /** Blurs the select and returns a void promise that indicates when the action is complete. */
+    async blur() {
+        return (await this.host()).blur();
+    }
+    /** Whether the select is focused. */
+    async isFocused() {
+        return (await this.host()).isFocused();
+    }
+    /** Gets the options inside the select panel. */
+    async getOptions(filter = {}) {
+        return this.locatorForAll(MatNativeOptionHarness.with(filter))();
+    }
+    /**
+     * Selects the options that match the passed-in filter. If the select is in multi-selection
+     * mode all options will be clicked, otherwise the harness will pick the first matching option.
+     */
+    async selectOptions(filter = {}) {
+        const [isMultiple, options] = await parallel(() => {
+            return [this.isMultiple(), this.getOptions(filter)];
+        });
+        if (options.length === 0) {
+            throw Error('Select does not have options matching the specified filter');
+        }
+        const [host, optionIndexes] = await parallel(() => [
+            this.host(),
+            parallel(() => options.slice(0, isMultiple ? undefined : 1).map(option => option.getIndex()))
+        ]);
+        await host.selectOptions(...optionIndexes);
+    }
+}
+MatNativeSelectHarness.hostSelector = 'select[matNativeControl]';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"native-select-harness.js","sourceRoot":"","sources":["../../../../../../../src/material/input/testing/native-select-harness.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {HarnessPredicate, parallel} from '@angular/cdk/testing';\nimport {MatFormFieldControlHarness} from '@angular/material/form-field/testing/control';\nimport {MatNativeOptionHarness} from './native-option-harness';\nimport {\n  NativeOptionHarnessFilters,\n  NativeSelectHarnessFilters,\n} from './native-select-harness-filters';\n\n\n/** Harness for interacting with a native `select` in tests. */\nexport class MatNativeSelectHarness extends MatFormFieldControlHarness {\n  static hostSelector = 'select[matNativeControl]';\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a `MatNativeSelectHarness` that meets\n   * certain criteria.\n   * @param options Options for filtering which select instances are considered a match.\n   * @return a `HarnessPredicate` configured with the given options.\n   */\n  static with(options: NativeSelectHarnessFilters = {}): HarnessPredicate<MatNativeSelectHarness> {\n    return new HarnessPredicate(MatNativeSelectHarness, options);\n  }\n\n  /** Gets a boolean promise indicating if the select is disabled. */\n  async isDisabled(): Promise<boolean> {\n    return (await this.host()).getProperty<boolean>('disabled');\n  }\n\n  /** Gets a boolean promise indicating if the select is required. */\n  async isRequired(): Promise<boolean> {\n    return (await this.host()).getProperty<boolean>('required');\n  }\n\n  /** Gets a boolean promise indicating if the select is in multi-selection mode. */\n  async isMultiple(): Promise<boolean> {\n    return (await this.host()).getProperty<boolean>('multiple');\n  }\n\n  /** Gets the name of the select. */\n  async getName(): Promise<string> {\n    // The \"name\" property of the native select is never undefined.\n    return (await (await this.host()).getProperty<string>('name'));\n  }\n\n  /** Gets the id of the select. */\n  async getId(): Promise<string> {\n    // We're guaranteed to have an id, because the `matNativeControl` always assigns one.\n    return (await (await this.host()).getProperty<string>('id'));\n  }\n\n  /** Focuses the select and returns a void promise that indicates when the action is complete. */\n  async focus(): Promise<void> {\n    return (await this.host()).focus();\n  }\n\n  /** Blurs the select and returns a void promise that indicates when the action is complete. */\n  async blur(): Promise<void> {\n    return (await this.host()).blur();\n  }\n\n  /** Whether the select is focused. */\n  async isFocused(): Promise<boolean> {\n    return (await this.host()).isFocused();\n  }\n\n  /** Gets the options inside the select panel. */\n  async getOptions(filter: NativeOptionHarnessFilters = {}):\n    Promise<MatNativeOptionHarness[]> {\n    return this.locatorForAll(MatNativeOptionHarness.with(filter))();\n  }\n\n  /**\n   * Selects the options that match the passed-in filter. If the select is in multi-selection\n   * mode all options will be clicked, otherwise the harness will pick the first matching option.\n   */\n  async selectOptions(filter: NativeOptionHarnessFilters = {}): Promise<void> {\n    const [isMultiple, options] = await parallel(() => {\n      return [this.isMultiple(), this.getOptions(filter)];\n    });\n\n    if (options.length === 0) {\n      throw Error('Select does not have options matching the specified filter');\n    }\n\n    const [host, optionIndexes] = await parallel(() => [\n      this.host(),\n      parallel(() => options.slice(0, isMultiple ? undefined : 1).map(option => option.getIndex()))\n    ]);\n\n    await host.selectOptions(...optionIndexes);\n  }\n}\n"]}

package/esm2020/list/list-module.mjs

@@ -0,0 +1,71 @@
+/**
+ * @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 { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MatCommonModule, MatLineModule, MatPseudoCheckboxModule, MatRippleModule, } from '@angular/material/core';
+import { MatList, MatNavList, MatListAvatarCssMatStyler, MatListIconCssMatStyler, MatListItem, MatListSubheaderCssMatStyler, } from './list';
+import { MatListOption, MatSelectionList } from './selection-list';
+import { MatDividerModule } from '@angular/material/divider';
+import * as i0 from "@angular/core";
+export class MatListModule {
+}
+MatListModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MatListModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatListModule, declarations: [MatList,
+        MatNavList,
+        MatListItem,
+        MatListAvatarCssMatStyler,
+        MatListIconCssMatStyler,
+        MatListSubheaderCssMatStyler,
+        MatSelectionList,
+        MatListOption], imports: [MatLineModule, MatRippleModule, MatCommonModule, MatPseudoCheckboxModule, CommonModule], exports: [MatList,
+        MatNavList,
+        MatListItem,
+        MatListAvatarCssMatStyler,
+        MatLineModule,
+        MatCommonModule,
+        MatListIconCssMatStyler,
+        MatListSubheaderCssMatStyler,
+        MatPseudoCheckboxModule,
+        MatSelectionList,
+        MatListOption,
+        MatDividerModule] });
+MatListModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatListModule, imports: [[MatLineModule, MatRippleModule, MatCommonModule, MatPseudoCheckboxModule, CommonModule], MatLineModule,
+        MatCommonModule,
+        MatPseudoCheckboxModule,
+        MatDividerModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatListModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [MatLineModule, MatRippleModule, MatCommonModule, MatPseudoCheckboxModule, CommonModule],
+                    exports: [
+                        MatList,
+                        MatNavList,
+                        MatListItem,
+                        MatListAvatarCssMatStyler,
+                        MatLineModule,
+                        MatCommonModule,
+                        MatListIconCssMatStyler,
+                        MatListSubheaderCssMatStyler,
+                        MatPseudoCheckboxModule,
+                        MatSelectionList,
+                        MatListOption,
+                        MatDividerModule
+                    ],
+                    declarations: [
+                        MatList,
+                        MatNavList,
+                        MatListItem,
+                        MatListAvatarCssMatStyler,
+                        MatListIconCssMatStyler,
+                        MatListSubheaderCssMatStyler,
+                        MatSelectionList,
+                        MatListOption
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC1tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbWF0ZXJpYWwvbGlzdC9saXN0LW1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFDN0MsT0FBTyxFQUFDLFFBQVEsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN2QyxPQUFPLEVBQ0wsZUFBZSxFQUNmLGFBQWEsRUFDYix1QkFBdUIsRUFDdkIsZUFBZSxHQUNoQixNQUFNLHdCQUF3QixDQUFDO0FBQ2hDLE9BQU8sRUFDTCxPQUFPLEVBQ1AsVUFBVSxFQUNWLHlCQUF5QixFQUN6Qix1QkFBdUIsRUFDdkIsV0FBVyxFQUNYLDRCQUE0QixHQUM3QixNQUFNLFFBQVEsQ0FBQztBQUNoQixPQUFPLEVBQUMsYUFBYSxFQUFFLGdCQUFnQixFQUFDLE1BQU0sa0JBQWtCLENBQUM7QUFDakUsT0FBTyxFQUFDLGdCQUFnQixFQUFDLE1BQU0sMkJBQTJCLENBQUM7O0FBOEIzRCxNQUFNLE9BQU8sYUFBYTs7a0hBQWIsYUFBYTttSEFBYixhQUFhLGlCQVZ0QixPQUFPO1FBQ1AsVUFBVTtRQUNWLFdBQVc7UUFDWCx5QkFBeUI7UUFDekIsdUJBQXVCO1FBQ3ZCLDRCQUE0QjtRQUM1QixnQkFBZ0I7UUFDaEIsYUFBYSxhQXZCTCxhQUFhLEVBQUUsZUFBZSxFQUFFLGVBQWUsRUFBRSx1QkFBdUIsRUFBRSxZQUFZLGFBRTlGLE9BQU87UUFDUCxVQUFVO1FBQ1YsV0FBVztRQUNYLHlCQUF5QjtRQUN6QixhQUFhO1FBQ2IsZUFBZTtRQUNmLHVCQUF1QjtRQUN2Qiw0QkFBNEI7UUFDNUIsdUJBQXVCO1FBQ3ZCLGdCQUFnQjtRQUNoQixhQUFhO1FBQ2IsZ0JBQWdCO21IQWFQLGFBQWEsWUExQmYsQ0FBQyxhQUFhLEVBQUUsZUFBZSxFQUFFLGVBQWUsRUFBRSx1QkFBdUIsRUFBRSxZQUFZLENBQUMsRUFNL0YsYUFBYTtRQUNiLGVBQWU7UUFHZix1QkFBdUI7UUFHdkIsZ0JBQWdCO21HQWFQLGFBQWE7a0JBM0J6QixRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLGFBQWEsRUFBRSxlQUFlLEVBQUUsZUFBZSxFQUFFLHVCQUF1QixFQUFFLFlBQVksQ0FBQztvQkFDakcsT0FBTyxFQUFFO3dCQUNQLE9BQU87d0JBQ1AsVUFBVTt3QkFDVixXQUFXO3dCQUNYLHlCQUF5Qjt3QkFDekIsYUFBYTt3QkFDYixlQUFlO3dCQUNmLHVCQUF1Qjt3QkFDdkIsNEJBQTRCO3dCQUM1Qix1QkFBdUI7d0JBQ3ZCLGdCQUFnQjt3QkFDaEIsYUFBYTt3QkFDYixnQkFBZ0I7cUJBQ2pCO29CQUNELFlBQVksRUFBRTt3QkFDWixPQUFPO3dCQUNQLFVBQVU7d0JBQ1YsV0FBVzt3QkFDWCx5QkFBeUI7d0JBQ3pCLHVCQUF1Qjt3QkFDdkIsNEJBQTRCO3dCQUM1QixnQkFBZ0I7d0JBQ2hCLGFBQWE7cUJBQ2Q7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtDb21tb25Nb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7XG4gIE1hdENvbW1vbk1vZHVsZSxcbiAgTWF0TGluZU1vZHVsZSxcbiAgTWF0UHNldWRvQ2hlY2tib3hNb2R1bGUsXG4gIE1hdFJpcHBsZU1vZHVsZSxcbn0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvY29yZSc7XG5pbXBvcnQge1xuICBNYXRMaXN0LFxuICBNYXROYXZMaXN0LFxuICBNYXRMaXN0QXZhdGFyQ3NzTWF0U3R5bGVyLFxuICBNYXRMaXN0SWNvbkNzc01hdFN0eWxlcixcbiAgTWF0TGlzdEl0ZW0sXG4gIE1hdExpc3RTdWJoZWFkZXJDc3NNYXRTdHlsZXIsXG59IGZyb20gJy4vbGlzdCc7XG5pbXBvcnQge01hdExpc3RPcHRpb24sIE1hdFNlbGVjdGlvbkxpc3R9IGZyb20gJy4vc2VsZWN0aW9uLWxpc3QnO1xuaW1wb3J0IHtNYXREaXZpZGVyTW9kdWxlfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9kaXZpZGVyJztcblxuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbTWF0TGluZU1vZHVsZSwgTWF0UmlwcGxlTW9kdWxlLCBNYXRDb21tb25Nb2R1bGUsIE1hdFBzZXVkb0NoZWNrYm94TW9kdWxlLCBDb21tb25Nb2R1bGVdLFxuICBleHBvcnRzOiBbXG4gICAgTWF0TGlzdCxcbiAgICBNYXROYXZMaXN0LFxuICAgIE1hdExpc3RJdGVtLFxuICAgIE1hdExpc3RBdmF0YXJDc3NNYXRTdHlsZXIsXG4gICAgTWF0TGluZU1vZHVsZSxcbiAgICBNYXRDb21tb25Nb2R1bGUsXG4gICAgTWF0TGlzdEljb25Dc3NNYXRTdHlsZXIsXG4gICAgTWF0TGlzdFN1YmhlYWRlckNzc01hdFN0eWxlcixcbiAgICBNYXRQc2V1ZG9DaGVja2JveE1vZHVsZSxcbiAgICBNYXRTZWxlY3Rpb25MaXN0LFxuICAgIE1hdExpc3RPcHRpb24sXG4gICAgTWF0RGl2aWRlck1vZHVsZVxuICBdLFxuICBkZWNsYXJhdGlvbnM6IFtcbiAgICBNYXRMaXN0LFxuICAgIE1hdE5hdkxpc3QsXG4gICAgTWF0TGlzdEl0ZW0sXG4gICAgTWF0TGlzdEF2YXRhckNzc01hdFN0eWxlcixcbiAgICBNYXRMaXN0SWNvbkNzc01hdFN0eWxlcixcbiAgICBNYXRMaXN0U3ViaGVhZGVyQ3NzTWF0U3R5bGVyLFxuICAgIE1hdFNlbGVjdGlvbkxpc3QsXG4gICAgTWF0TGlzdE9wdGlvblxuICBdLFxufSlcbmV4cG9ydCBjbGFzcyBNYXRMaXN0TW9kdWxlIHt9XG4iXX0=