Changing front

front/app/node_modules/@angular/cdk/esm2020/testing/change-detection.mjs

@@ -0,0 +1,102 @@
+/**
+ * @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 { BehaviorSubject } from 'rxjs';
+/** Subject used to dispatch and listen for changes to the auto change detection status . */
+const autoChangeDetectionSubject = new BehaviorSubject({
+    isDisabled: false,
+});
+/** The current subscription to `autoChangeDetectionSubject`. */
+let autoChangeDetectionSubscription;
+/**
+ * The default handler for auto change detection status changes. This handler will be used if the
+ * specific environment does not install its own.
+ * @param status The new auto change detection status.
+ */
+function defaultAutoChangeDetectionHandler(status) {
+    status.onDetectChangesNow?.();
+}
+/**
+ * Allows a test `HarnessEnvironment` to install its own handler for auto change detection status
+ * changes.
+ * @param handler The handler for the auto change detection status.
+ */
+export function handleAutoChangeDetectionStatus(handler) {
+    stopHandlingAutoChangeDetectionStatus();
+    autoChangeDetectionSubscription = autoChangeDetectionSubject.subscribe(handler);
+}
+/** Allows a `HarnessEnvironment` to stop handling auto change detection status changes. */
+export function stopHandlingAutoChangeDetectionStatus() {
+    autoChangeDetectionSubscription?.unsubscribe();
+    autoChangeDetectionSubscription = null;
+}
+/**
+ * Batches together triggering of change detection over the duration of the given function.
+ * @param fn The function to call with batched change detection.
+ * @param triggerBeforeAndAfter Optionally trigger change detection once before and after the batch
+ *   operation. If false, change detection will not be triggered.
+ * @return The result of the given function.
+ */
+async function batchChangeDetection(fn, triggerBeforeAndAfter) {
+    // If change detection batching is already in progress, just run the function.
+    if (autoChangeDetectionSubject.getValue().isDisabled) {
+        return await fn();
+    }
+    // If nothing is handling change detection batching, install the default handler.
+    if (!autoChangeDetectionSubscription) {
+        handleAutoChangeDetectionStatus(defaultAutoChangeDetectionHandler);
+    }
+    if (triggerBeforeAndAfter) {
+        await new Promise(resolve => autoChangeDetectionSubject.next({
+            isDisabled: true,
+            onDetectChangesNow: resolve,
+        }));
+        // The function passed in may throw (e.g. if the user wants to make an expectation of an error
+        // being thrown. If this happens, we need to make sure we still re-enable change detection, so
+        // we wrap it in a `finally` block.
+        try {
+            return await fn();
+        }
+        finally {
+            await new Promise(resolve => autoChangeDetectionSubject.next({
+                isDisabled: false,
+                onDetectChangesNow: resolve,
+            }));
+        }
+    }
+    else {
+        autoChangeDetectionSubject.next({ isDisabled: true });
+        // The function passed in may throw (e.g. if the user wants to make an expectation of an error
+        // being thrown. If this happens, we need to make sure we still re-enable change detection, so
+        // we wrap it in a `finally` block.
+        try {
+            return await fn();
+        }
+        finally {
+            autoChangeDetectionSubject.next({ isDisabled: false });
+        }
+    }
+}
+/**
+ * Disables the harness system's auto change detection for the duration of the given function.
+ * @param fn The function to disable auto change detection for.
+ * @return The result of the given function.
+ */
+export async function manualChangeDetection(fn) {
+    return batchChangeDetection(fn, false);
+}
+/**
+ * Resolves the given list of async values in parallel (i.e. via Promise.all) while batching change
+ * detection over the entire operation such that change detection occurs exactly once before
+ * resolving the values and once after.
+ * @param values A getter for the async values to resolve in parallel with batched change detection.
+ * @return The resolved values.
+ */
+export async function parallel(values) {
+    return batchChangeDetection(() => Promise.all(values()), true);
+}
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/testing/component-harness.mjs

@@ -0,0 +1,328 @@
+/**
+ * @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 { parallel } from './change-detection';
+/**
+ * Base class for component harnesses that all component harness authors should extend. This base
+ * component harness provides the basic ability to locate element and sub-component harness. It
+ * should be inherited when defining user's own harness.
+ */
+export class ComponentHarness {
+    constructor(locatorFactory) {
+        this.locatorFactory = locatorFactory;
+    }
+    /** Gets a `Promise` for the `TestElement` representing the host element of the component. */
+    async host() {
+        return this.locatorFactory.rootElement;
+    }
+    /**
+     * Gets a `LocatorFactory` for the document root element. This factory can be used to create
+     * locators for elements that a component creates outside of its own root element. (e.g. by
+     * appending to document.body).
+     */
+    documentRootLocatorFactory() {
+        return this.locatorFactory.documentRootLocatorFactory();
+    }
+    /**
+     * Creates an asynchronous locator function that can be used to find a `ComponentHarness` instance
+     * or element under the host element of this `ComponentHarness`.
+     * @param queries A list of queries specifying which harnesses and elements to search for:
+     *   - A `string` searches for elements matching the CSS selector specified by the string.
+     *   - A `ComponentHarness` constructor searches for `ComponentHarness` instances matching the
+     *     given class.
+     *   - A `HarnessPredicate` searches for `ComponentHarness` instances matching the given
+     *     predicate.
+     * @return An asynchronous locator function that searches for and returns a `Promise` for the
+     *   first element or harness matching the given search criteria. Matches are ordered first by
+     *   order in the DOM, and second by order in the queries list. If no matches are found, the
+     *   `Promise` rejects. The type that the `Promise` resolves to is a union of all result types for
+     *   each query.
+     *
+     * e.g. Given the following DOM: `<div id="d1" /><div id="d2" />`, and assuming
+     * `DivHarness.hostSelector === 'div'`:
+     * - `await ch.locatorFor(DivHarness, 'div')()` gets a `DivHarness` instance for `#d1`
+     * - `await ch.locatorFor('div', DivHarness)()` gets a `TestElement` instance for `#d1`
+     * - `await ch.locatorFor('span')()` throws because the `Promise` rejects.
+     */
+    locatorFor(...queries) {
+        return this.locatorFactory.locatorFor(...queries);
+    }
+    /**
+     * Creates an asynchronous locator function that can be used to find a `ComponentHarness` instance
+     * or element under the host element of this `ComponentHarness`.
+     * @param queries A list of queries specifying which harnesses and elements to search for:
+     *   - A `string` searches for elements matching the CSS selector specified by the string.
+     *   - A `ComponentHarness` constructor searches for `ComponentHarness` instances matching the
+     *     given class.
+     *   - A `HarnessPredicate` searches for `ComponentHarness` instances matching the given
+     *     predicate.
+     * @return An asynchronous locator function that searches for and returns a `Promise` for the
+     *   first element or harness matching the given search criteria. Matches are ordered first by
+     *   order in the DOM, and second by order in the queries list. If no matches are found, the
+     *   `Promise` is resolved with `null`. The type that the `Promise` resolves to is a union of all
+     *   result types for each query or null.
+     *
+     * e.g. Given the following DOM: `<div id="d1" /><div id="d2" />`, and assuming
+     * `DivHarness.hostSelector === 'div'`:
+     * - `await ch.locatorForOptional(DivHarness, 'div')()` gets a `DivHarness` instance for `#d1`
+     * - `await ch.locatorForOptional('div', DivHarness)()` gets a `TestElement` instance for `#d1`
+     * - `await ch.locatorForOptional('span')()` gets `null`.
+     */
+    locatorForOptional(...queries) {
+        return this.locatorFactory.locatorForOptional(...queries);
+    }
+    /**
+     * Creates an asynchronous locator function that can be used to find `ComponentHarness` instances
+     * or elements under the host element of this `ComponentHarness`.
+     * @param queries A list of queries specifying which harnesses and elements to search for:
+     *   - A `string` searches for elements matching the CSS selector specified by the string.
+     *   - A `ComponentHarness` constructor searches for `ComponentHarness` instances matching the
+     *     given class.
+     *   - A `HarnessPredicate` searches for `ComponentHarness` instances matching the given
+     *     predicate.
+     * @return An asynchronous locator function that searches for and returns a `Promise` for all
+     *   elements and harnesses matching the given search criteria. Matches are ordered first by
+     *   order in the DOM, and second by order in the queries list. If an element matches more than
+     *   one `ComponentHarness` class, the locator gets an instance of each for the same element. If
+     *   an element matches multiple `string` selectors, only one `TestElement` instance is returned
+     *   for that element. The type that the `Promise` resolves to is an array where each element is
+     *   the union of all result types for each query.
+     *
+     * e.g. Given the following DOM: `<div id="d1" /><div id="d2" />`, and assuming
+     * `DivHarness.hostSelector === 'div'` and `IdIsD1Harness.hostSelector === '#d1'`:
+     * - `await ch.locatorForAll(DivHarness, 'div')()` gets `[
+     *     DivHarness, // for #d1
+     *     TestElement, // for #d1
+     *     DivHarness, // for #d2
+     *     TestElement // for #d2
+     *   ]`
+     * - `await ch.locatorForAll('div', '#d1')()` gets `[
+     *     TestElement, // for #d1
+     *     TestElement // for #d2
+     *   ]`
+     * - `await ch.locatorForAll(DivHarness, IdIsD1Harness)()` gets `[
+     *     DivHarness, // for #d1
+     *     IdIsD1Harness, // for #d1
+     *     DivHarness // for #d2
+     *   ]`
+     * - `await ch.locatorForAll('span')()` gets `[]`.
+     */
+    locatorForAll(...queries) {
+        return this.locatorFactory.locatorForAll(...queries);
+    }
+    /**
+     * Flushes change detection and async tasks in the Angular zone.
+     * In most cases it should not be necessary to call this manually. However, there may be some edge
+     * cases where it is needed to fully flush animation events.
+     */
+    async forceStabilize() {
+        return this.locatorFactory.forceStabilize();
+    }
+    /**
+     * Waits for all scheduled or running async tasks to complete. This allows harness
+     * authors to wait for async tasks outside of the Angular zone.
+     */
+    async waitForTasksOutsideAngular() {
+        return this.locatorFactory.waitForTasksOutsideAngular();
+    }
+}
+/**
+ * Base class for component harnesses that authors should extend if they anticipate that consumers
+ * of the harness may want to access other harnesses within the `<ng-content>` of the component.
+ */
+export class ContentContainerComponentHarness extends ComponentHarness {
+    async getChildLoader(selector) {
+        return (await this.getRootHarnessLoader()).getChildLoader(selector);
+    }
+    async getAllChildLoaders(selector) {
+        return (await this.getRootHarnessLoader()).getAllChildLoaders(selector);
+    }
+    async getHarness(query) {
+        return (await this.getRootHarnessLoader()).getHarness(query);
+    }
+    async getHarnessOrNull(query) {
+        return (await this.getRootHarnessLoader()).getHarnessOrNull(query);
+    }
+    async getAllHarnesses(query) {
+        return (await this.getRootHarnessLoader()).getAllHarnesses(query);
+    }
+    async hasHarness(query) {
+        return (await this.getRootHarnessLoader()).hasHarness(query);
+    }
+    /**
+     * Gets the root harness loader from which to start
+     * searching for content contained by this harness.
+     */
+    async getRootHarnessLoader() {
+        return this.locatorFactory.rootHarnessLoader();
+    }
+}
+/**
+ * A class used to associate a ComponentHarness class with predicates functions that can be used to
+ * filter instances of the class.
+ */
+export class HarnessPredicate {
+    constructor(harnessType, options) {
+        this.harnessType = harnessType;
+        this._predicates = [];
+        this._descriptions = [];
+        this._addBaseOptions(options);
+    }
+    /**
+     * Checks if the specified nullable string value matches the given pattern.
+     * @param value The nullable string value to check, or a Promise resolving to the
+     *   nullable string value.
+     * @param pattern The pattern the value is expected to match. If `pattern` is a string,
+     *   `value` is expected to match exactly. If `pattern` is a regex, a partial match is
+     *   allowed. If `pattern` is `null`, the value is expected to be `null`.
+     * @return Whether the value matches the pattern.
+     */
+    static async stringMatches(value, pattern) {
+        value = await value;
+        if (pattern === null) {
+            return value === null;
+        }
+        else if (value === null) {
+            return false;
+        }
+        return typeof pattern === 'string' ? value === pattern : pattern.test(value);
+    }
+    /**
+     * Adds a predicate function to be run against candidate harnesses.
+     * @param description A description of this predicate that may be used in error messages.
+     * @param predicate An async predicate function.
+     * @return this (for method chaining).
+     */
+    add(description, predicate) {
+        this._descriptions.push(description);
+        this._predicates.push(predicate);
+        return this;
+    }
+    /**
+     * Adds a predicate function that depends on an option value to be run against candidate
+     * harnesses. If the option value is undefined, the predicate will be ignored.
+     * @param name The name of the option (may be used in error messages).
+     * @param option The option value.
+     * @param predicate The predicate function to run if the option value is not undefined.
+     * @return this (for method chaining).
+     */
+    addOption(name, option, predicate) {
+        if (option !== undefined) {
+            this.add(`${name} = ${_valueAsString(option)}`, item => predicate(item, option));
+        }
+        return this;
+    }
+    /**
+     * Filters a list of harnesses on this predicate.
+     * @param harnesses The list of harnesses to filter.
+     * @return A list of harnesses that satisfy this predicate.
+     */
+    async filter(harnesses) {
+        if (harnesses.length === 0) {
+            return [];
+        }
+        const results = await parallel(() => harnesses.map(h => this.evaluate(h)));
+        return harnesses.filter((_, i) => results[i]);
+    }
+    /**
+     * Evaluates whether the given harness satisfies this predicate.
+     * @param harness The harness to check
+     * @return A promise that resolves to true if the harness satisfies this predicate,
+     *   and resolves to false otherwise.
+     */
+    async evaluate(harness) {
+        const results = await parallel(() => this._predicates.map(p => p(harness)));
+        return results.reduce((combined, current) => combined && current, true);
+    }
+    /** Gets a description of this predicate for use in error messages. */
+    getDescription() {
+        return this._descriptions.join(', ');
+    }
+    /** Gets the selector used to find candidate elements. */
+    getSelector() {
+        // We don't have to go through the extra trouble if there are no ancestors.
+        if (!this._ancestor) {
+            return (this.harnessType.hostSelector || '').trim();
+        }
+        const [ancestors, ancestorPlaceholders] = _splitAndEscapeSelector(this._ancestor);
+        const [selectors, selectorPlaceholders] = _splitAndEscapeSelector(this.harnessType.hostSelector || '');
+        const result = [];
+        // We have to add the ancestor to each part of the host compound selector, otherwise we can get
+        // incorrect results. E.g. `.ancestor .a, .ancestor .b` vs `.ancestor .a, .b`.
+        ancestors.forEach(escapedAncestor => {
+            const ancestor = _restoreSelector(escapedAncestor, ancestorPlaceholders);
+            return selectors.forEach(escapedSelector => result.push(`${ancestor} ${_restoreSelector(escapedSelector, selectorPlaceholders)}`));
+        });
+        return result.join(', ');
+    }
+    /** Adds base options common to all harness types. */
+    _addBaseOptions(options) {
+        this._ancestor = options.ancestor || '';
+        if (this._ancestor) {
+            this._descriptions.push(`has ancestor matching selector "${this._ancestor}"`);
+        }
+        const selector = options.selector;
+        if (selector !== undefined) {
+            this.add(`host matches selector "${selector}"`, async (item) => {
+                return (await item.host()).matchesSelector(selector);
+            });
+        }
+    }
+}
+/** Represent a value as a string for the purpose of logging. */
+function _valueAsString(value) {
+    if (value === undefined) {
+        return 'undefined';
+    }
+    try {
+        // `JSON.stringify` doesn't handle RegExp properly, so we need a custom replacer.
+        // Use a character that is unlikely to appear in real strings to denote the start and end of
+        // the regex. This allows us to strip out the extra quotes around the value added by
+        // `JSON.stringify`. Also do custom escaping on `"` characters to prevent `JSON.stringify`
+        // from escaping them as if they were part of a string.
+        const stringifiedValue = JSON.stringify(value, (_, v) => v instanceof RegExp
+            ? `◬MAT_RE_ESCAPE◬${v.toString().replace(/"/g, '◬MAT_RE_ESCAPE◬')}◬MAT_RE_ESCAPE◬`
+            : v);
+        // Strip out the extra quotes around regexes and put back the manually escaped `"` characters.
+        return stringifiedValue
+            .replace(/"◬MAT_RE_ESCAPE◬|◬MAT_RE_ESCAPE◬"/g, '')
+            .replace(/◬MAT_RE_ESCAPE◬/g, '"');
+    }
+    catch {
+        // `JSON.stringify` will throw if the object is cyclical,
+        // in this case the best we can do is report the value as `{...}`.
+        return '{...}';
+    }
+}
+/**
+ * Splits up a compound selector into its parts and escapes any quoted content. The quoted content
+ * has to be escaped, because it can contain commas which will throw throw us off when trying to
+ * split it.
+ * @param selector Selector to be split.
+ * @returns The escaped string where any quoted content is replaced with a placeholder. E.g.
+ * `[foo="bar"]` turns into `[foo=__cdkPlaceholder-0__]`. Use `_restoreSelector` to restore
+ * the placeholders.
+ */
+function _splitAndEscapeSelector(selector) {
+    const placeholders = [];
+    // Note that the regex doesn't account for nested quotes so something like `"ab'cd'e"` will be
+    // considered as two blocks. It's a bit of an edge case, but if we find that it's a problem,
+    // we can make it a bit smarter using a loop. Use this for now since it's more readable and
+    // compact. More complete implementation:
+    // https://github.com/angular/angular/blob/bd34bc9e89f18a/packages/compiler/src/shadow_css.ts#L655
+    const result = selector.replace(/(["'][^["']*["'])/g, (_, keep) => {
+        const replaceBy = `__cdkPlaceholder-${placeholders.length}__`;
+        placeholders.push(keep);
+        return replaceBy;
+    });
+    return [result.split(',').map(part => part.trim()), placeholders];
+}
+/** Restores a selector whose content was escaped in `_splitAndEscapeSelector`. */
+function _restoreSelector(selector, placeholders) {
+    return selector.replace(/__cdkPlaceholder-(\d+)__/g, (_, index) => placeholders[+index]);
+}
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/testing/element-dimensions.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudC1kaW1lbnNpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2Nkay90ZXN0aW5nL2VsZW1lbnQtZGltZW5zaW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLyoqXG4gKiBEaW1lbnNpb25zIGZvciBlbGVtZW50IHNpemUgYW5kIGl0cyBwb3NpdGlvbiByZWxhdGl2ZSB0byB0aGUgdmlld3BvcnQuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRWxlbWVudERpbWVuc2lvbnMge1xuICB0b3A6IG51bWJlcjtcbiAgbGVmdDogbnVtYmVyO1xuICB3aWR0aDogbnVtYmVyO1xuICBoZWlnaHQ6IG51bWJlcjtcbn1cbiJdfQ==

front/app/node_modules/@angular/cdk/esm2020/testing/harness-environment.mjs

@@ -0,0 +1,220 @@
+/**
+ * @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 { parallel } from './change-detection';
+import { ComponentHarness, HarnessPredicate, } from './component-harness';
+/**
+ * Base harness environment class that can be extended to allow `ComponentHarness`es to be used in
+ * different test environments (e.g. testbed, protractor, etc.). This class implements the
+ * functionality of both a `HarnessLoader` and `LocatorFactory`. This class is generic on the raw
+ * element type, `E`, used by the particular test environment.
+ */
+export class HarnessEnvironment {
+    constructor(rawRootElement) {
+        this.rawRootElement = rawRootElement;
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    get rootElement() {
+        this._rootElement = this._rootElement || this.createTestElement(this.rawRootElement);
+        return this._rootElement;
+    }
+    set rootElement(element) {
+        this._rootElement = element;
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    documentRootLocatorFactory() {
+        return this.createEnvironment(this.getDocumentRoot());
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    locatorFor(...queries) {
+        return () => _assertResultFound(this._getAllHarnessesAndTestElements(queries), _getDescriptionForLocatorForQueries(queries));
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    locatorForOptional(...queries) {
+        return async () => (await this._getAllHarnessesAndTestElements(queries))[0] || null;
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    locatorForAll(...queries) {
+        return () => this._getAllHarnessesAndTestElements(queries);
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    async rootHarnessLoader() {
+        return this;
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    async harnessLoaderFor(selector) {
+        return this.createEnvironment(await _assertResultFound(this.getAllRawElements(selector), [
+            _getDescriptionForHarnessLoaderQuery(selector),
+        ]));
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    async harnessLoaderForOptional(selector) {
+        const elements = await this.getAllRawElements(selector);
+        return elements[0] ? this.createEnvironment(elements[0]) : null;
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    async harnessLoaderForAll(selector) {
+        const elements = await this.getAllRawElements(selector);
+        return elements.map(element => this.createEnvironment(element));
+    }
+    // Implemented as part of the `HarnessLoader` interface.
+    getHarness(query) {
+        return this.locatorFor(query)();
+    }
+    // Implemented as part of the `HarnessLoader` interface.
+    getHarnessOrNull(query) {
+        return this.locatorForOptional(query)();
+    }
+    // Implemented as part of the `HarnessLoader` interface.
+    getAllHarnesses(query) {
+        return this.locatorForAll(query)();
+    }
+    // Implemented as part of the `HarnessLoader` interface.
+    async hasHarness(query) {
+        return (await this.locatorForOptional(query)()) !== null;
+    }
+    // Implemented as part of the `HarnessLoader` interface.
+    async getChildLoader(selector) {
+        return this.createEnvironment(await _assertResultFound(this.getAllRawElements(selector), [
+            _getDescriptionForHarnessLoaderQuery(selector),
+        ]));
+    }
+    // Implemented as part of the `HarnessLoader` interface.
+    async getAllChildLoaders(selector) {
+        return (await this.getAllRawElements(selector)).map(e => this.createEnvironment(e));
+    }
+    /** Creates a `ComponentHarness` for the given harness type with the given raw host element. */
+    createComponentHarness(harnessType, element) {
+        return new harnessType(this.createEnvironment(element));
+    }
+    /**
+     * Matches the given raw elements with the given list of element and harness queries to produce a
+     * list of matched harnesses and test elements.
+     */
+    async _getAllHarnessesAndTestElements(queries) {
+        if (!queries.length) {
+            throw Error('CDK Component harness query must contain at least one element.');
+        }
+        const { allQueries, harnessQueries, elementQueries, harnessTypes } = _parseQueries(queries);
+        // Combine all of the queries into one large comma-delimited selector and use it to get all raw
+        // elements matching any of the individual queries.
+        const rawElements = await this.getAllRawElements([...elementQueries, ...harnessQueries.map(predicate => predicate.getSelector())].join(','));
+        // If every query is searching for the same harness subclass, we know every result corresponds
+        // to an instance of that subclass. Likewise, if every query is for a `TestElement`, we know
+        // every result corresponds to a `TestElement`. Otherwise we need to verify which result was
+        // found by which selector so it can be matched to the appropriate instance.
+        const skipSelectorCheck = (elementQueries.length === 0 && harnessTypes.size === 1) || harnessQueries.length === 0;
+        const perElementMatches = await parallel(() => rawElements.map(async (rawElement) => {
+            const testElement = this.createTestElement(rawElement);
+            const allResultsForElement = await parallel(
+            // For each query, get `null` if it doesn't match, or a `TestElement` or
+            // `ComponentHarness` as appropriate if it does match. This gives us everything that
+            // matches the current raw element, but it may contain duplicate entries (e.g.
+            // multiple `TestElement` or multiple `ComponentHarness` of the same type).
+            () => allQueries.map(query => this._getQueryResultForElement(query, rawElement, testElement, skipSelectorCheck)));
+            return _removeDuplicateQueryResults(allResultsForElement);
+        }));
+        return [].concat(...perElementMatches);
+    }
+    /**
+     * Check whether the given query matches the given element, if it does return the matched
+     * `TestElement` or `ComponentHarness`, if it does not, return null. In cases where the caller
+     * knows for sure that the query matches the element's selector, `skipSelectorCheck` can be used
+     * to skip verification and optimize performance.
+     */
+    async _getQueryResultForElement(query, rawElement, testElement, skipSelectorCheck = false) {
+        if (typeof query === 'string') {
+            return skipSelectorCheck || (await testElement.matchesSelector(query)) ? testElement : null;
+        }
+        if (skipSelectorCheck || (await testElement.matchesSelector(query.getSelector()))) {
+            const harness = this.createComponentHarness(query.harnessType, rawElement);
+            return (await query.evaluate(harness)) ? harness : null;
+        }
+        return null;
+    }
+}
+/**
+ * Parses a list of queries in the format accepted by the `locatorFor*` methods into an easier to
+ * work with format.
+ */
+function _parseQueries(queries) {
+    const allQueries = [];
+    const harnessQueries = [];
+    const elementQueries = [];
+    const harnessTypes = new Set();
+    for (const query of queries) {
+        if (typeof query === 'string') {
+            allQueries.push(query);
+            elementQueries.push(query);
+        }
+        else {
+            const predicate = query instanceof HarnessPredicate ? query : new HarnessPredicate(query, {});
+            allQueries.push(predicate);
+            harnessQueries.push(predicate);
+            harnessTypes.add(predicate.harnessType);
+        }
+    }
+    return { allQueries, harnessQueries, elementQueries, harnessTypes };
+}
+/**
+ * Removes duplicate query results for a particular element. (e.g. multiple `TestElement`
+ * instances or multiple instances of the same `ComponentHarness` class.
+ */
+async function _removeDuplicateQueryResults(results) {
+    let testElementMatched = false;
+    let matchedHarnessTypes = new Set();
+    const dedupedMatches = [];
+    for (const result of results) {
+        if (!result) {
+            continue;
+        }
+        if (result instanceof ComponentHarness) {
+            if (!matchedHarnessTypes.has(result.constructor)) {
+                matchedHarnessTypes.add(result.constructor);
+                dedupedMatches.push(result);
+            }
+        }
+        else if (!testElementMatched) {
+            testElementMatched = true;
+            dedupedMatches.push(result);
+        }
+    }
+    return dedupedMatches;
+}
+/** Verifies that there is at least one result in an array. */
+async function _assertResultFound(results, queryDescriptions) {
+    const result = (await results)[0];
+    if (result == undefined) {
+        throw Error(`Failed to find element matching one of the following queries:\n` +
+            queryDescriptions.map(desc => `(${desc})`).join(',\n'));
+    }
+    return result;
+}
+/** Gets a list of description strings from a list of queries. */
+function _getDescriptionForLocatorForQueries(queries) {
+    return queries.map(query => typeof query === 'string'
+        ? _getDescriptionForTestElementQuery(query)
+        : _getDescriptionForComponentHarnessQuery(query));
+}
+/** Gets a description string for a `ComponentHarness` query. */
+function _getDescriptionForComponentHarnessQuery(query) {
+    const harnessPredicate = query instanceof HarnessPredicate ? query : new HarnessPredicate(query, {});
+    const { name, hostSelector } = harnessPredicate.harnessType;
+    const description = `${name} with host element matching selector: "${hostSelector}"`;
+    const constraints = harnessPredicate.getDescription();
+    return (description +
+        (constraints ? ` satisfying the constraints: ${harnessPredicate.getDescription()}` : ''));
+}
+/** Gets a description string for a `TestElement` query. */
+function _getDescriptionForTestElementQuery(selector) {
+    return `TestElement for element matching selector: "${selector}"`;
+}
+/** Gets a description string for a `HarnessLoader` query. */
+function _getDescriptionForHarnessLoaderQuery(selector) {
+    return `HarnessLoader for element matching selector: "${selector}"`;
+}
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/testing/index.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL3Rlc3RpbmcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

front/app/node_modules/@angular/cdk/esm2020/testing/public-api.mjs

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './component-harness';
+export * from './harness-environment';
+export * from './test-element';
+export * from './test-element-errors';
+export * from './element-dimensions';
+export * from './text-filtering';
+export * from './change-detection';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jZGsvdGVzdGluZy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnQtaGFybmVzcyc7XG5leHBvcnQgKiBmcm9tICcuL2hhcm5lc3MtZW52aXJvbm1lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi90ZXN0LWVsZW1lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi90ZXN0LWVsZW1lbnQtZXJyb3JzJztcbmV4cG9ydCAqIGZyb20gJy4vZWxlbWVudC1kaW1lbnNpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vdGV4dC1maWx0ZXJpbmcnO1xuZXhwb3J0ICogZnJvbSAnLi9jaGFuZ2UtZGV0ZWN0aW9uJztcbiJdfQ==

front/app/node_modules/@angular/cdk/esm2020/testing/selenium-webdriver/index.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL3Rlc3Rpbmcvc2VsZW5pdW0td2ViZHJpdmVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

front/app/node_modules/@angular/cdk/esm2020/testing/selenium-webdriver/public-api.mjs

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './selenium-web-driver-element';
+export * from './selenium-web-driver-harness-environment';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jZGsvdGVzdGluZy9zZWxlbml1bS13ZWJkcml2ZXIvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsMkNBQTJDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9zZWxlbml1bS13ZWItZHJpdmVyLWVsZW1lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9zZWxlbml1bS13ZWItZHJpdmVyLWhhcm5lc3MtZW52aXJvbm1lbnQnO1xuIl19

front/app/node_modules/@angular/cdk/esm2020/testing/selenium-webdriver/selenium-web-driver-element.mjs

@@ -0,0 +1,204 @@
+/**
+ * @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 { _getTextWithExcludedElements, getNoKeysSpecifiedError, } from '@angular/cdk/testing';
+import * as webdriver from 'selenium-webdriver';
+import { getSeleniumWebDriverModifierKeys, seleniumWebDriverKeyMap } from './selenium-webdriver-keys';
+/** A `TestElement` implementation for WebDriver. */
+export class SeleniumWebDriverElement {
+    constructor(element, _stabilize) {
+        this.element = element;
+        this._stabilize = _stabilize;
+    }
+    /** Blur the element. */
+    async blur() {
+        await this._executeScript((element) => element.blur(), this.element());
+        await this._stabilize();
+    }
+    /** Clear the element's input (for input and textarea elements only). */
+    async clear() {
+        await this.element().clear();
+        await this._stabilize();
+    }
+    async click(...args) {
+        await this._dispatchClickEventSequence(args, webdriver.Button.LEFT);
+        await this._stabilize();
+    }
+    async rightClick(...args) {
+        await this._dispatchClickEventSequence(args, webdriver.Button.RIGHT);
+        await this._stabilize();
+    }
+    /** Focus the element. */
+    async focus() {
+        await this._executeScript((element) => element.focus(), this.element());
+        await this._stabilize();
+    }
+    /** Get the computed value of the given CSS property for the element. */
+    async getCssValue(property) {
+        await this._stabilize();
+        return this.element().getCssValue(property);
+    }
+    /** Hovers the mouse over the element. */
+    async hover() {
+        await this._actions().mouseMove(this.element()).perform();
+        await this._stabilize();
+    }
+    /** Moves the mouse away from the element. */
+    async mouseAway() {
+        await this._actions().mouseMove(this.element(), { x: -1, y: -1 }).perform();
+        await this._stabilize();
+    }
+    async sendKeys(...modifiersAndKeys) {
+        const first = modifiersAndKeys[0];
+        let modifiers;
+        let rest;
+        if (first !== undefined && typeof first !== 'string' && typeof first !== 'number') {
+            modifiers = first;
+            rest = modifiersAndKeys.slice(1);
+        }
+        else {
+            modifiers = {};
+            rest = modifiersAndKeys;
+        }
+        const modifierKeys = getSeleniumWebDriverModifierKeys(modifiers);
+        const keys = rest
+            .map(k => (typeof k === 'string' ? k.split('') : [seleniumWebDriverKeyMap[k]]))
+            .reduce((arr, k) => arr.concat(k), [])
+            // webdriver.Key.chord doesn't work well with geckodriver (mozilla/geckodriver#1502),
+            // so avoid it if no modifier keys are required.
+            .map(k => (modifierKeys.length > 0 ? webdriver.Key.chord(...modifierKeys, k) : k));
+        // Throw an error if no keys have been specified. Calling this function with no
+        // keys should not result in a focus event being dispatched unexpectedly.
+        if (keys.length === 0) {
+            throw getNoKeysSpecifiedError();
+        }
+        await this.element().sendKeys(...keys);
+        await this._stabilize();
+    }
+    /**
+     * Gets the text from the element.
+     * @param options Options that affect what text is included.
+     */
+    async text(options) {
+        await this._stabilize();
+        if (options?.exclude) {
+            return this._executeScript(_getTextWithExcludedElements, this.element(), options.exclude);
+        }
+        // We don't go through the WebDriver `getText`, because it excludes text from hidden elements.
+        return this._executeScript((element) => (element.textContent || '').trim(), this.element());
+    }
+    /** Gets the value for the given attribute from the element. */
+    async getAttribute(name) {
+        await this._stabilize();
+        return this._executeScript((element, attribute) => element.getAttribute(attribute), this.element(), name);
+    }
+    /** Checks whether the element has the given class. */
+    async hasClass(name) {
+        await this._stabilize();
+        const classes = (await this.getAttribute('class')) || '';
+        return new Set(classes.split(/\s+/).filter(c => c)).has(name);
+    }
+    /** Gets the dimensions of the element. */
+    async getDimensions() {
+        await this._stabilize();
+        const { width, height } = await this.element().getSize();
+        const { x: left, y: top } = await this.element().getLocation();
+        return { width, height, left, top };
+    }
+    /** Gets the value of a property of an element. */
+    async getProperty(name) {
+        await this._stabilize();
+        return this._executeScript((element, property) => element[property], this.element(), name);
+    }
+    /** Sets the value of a property of an input. */
+    async setInputValue(newValue) {
+        await this._executeScript((element, value) => (element.value = value), this.element(), newValue);
+        await this._stabilize();
+    }
+    /** Selects the options at the specified indexes inside of a native `select` element. */
+    async selectOptions(...optionIndexes) {
+        await this._stabilize();
+        const options = await this.element().findElements(webdriver.By.css('option'));
+        const indexes = new Set(optionIndexes); // Convert to a set to remove duplicates.
+        if (options.length && indexes.size) {
+            // Reset the value so all the selected states are cleared. We can
+            // reuse the input-specific method since the logic is the same.
+            await this.setInputValue('');
+            for (let i = 0; i < options.length; i++) {
+                if (indexes.has(i)) {
+                    // We have to hold the control key while clicking on options so that multiple can be
+                    // selected in multi-selection mode. The key doesn't do anything for single selection.
+                    await this._actions().keyDown(webdriver.Key.CONTROL).perform();
+                    await options[i].click();
+                    await this._actions().keyUp(webdriver.Key.CONTROL).perform();
+                }
+            }
+            await this._stabilize();
+        }
+    }
+    /** Checks whether this element matches the given selector. */
+    async matchesSelector(selector) {
+        await this._stabilize();
+        return this._executeScript((element, s) => (Element.prototype.matches || Element.prototype.msMatchesSelector).call(element, s), this.element(), selector);
+    }
+    /** Checks whether the element is focused. */
+    async isFocused() {
+        await this._stabilize();
+        return webdriver.WebElement.equals(this.element(), this.element().getDriver().switchTo().activeElement());
+    }
+    /**
+     * Dispatches an event with a particular name.
+     * @param name Name of the event to be dispatched.
+     */
+    async dispatchEvent(name, data) {
+        await this._executeScript(dispatchEvent, name, this.element(), data);
+        await this._stabilize();
+    }
+    /** Gets the webdriver action sequence. */
+    _actions() {
+        return this.element().getDriver().actions();
+    }
+    /** Executes a function in the browser. */
+    async _executeScript(script, ...var_args) {
+        return this.element()
+            .getDriver()
+            .executeScript(script, ...var_args);
+    }
+    /** Dispatches all the events that are part of a click event sequence. */
+    async _dispatchClickEventSequence(args, button) {
+        let modifiers = {};
+        if (args.length && typeof args[args.length - 1] === 'object') {
+            modifiers = args.pop();
+        }
+        const modifierKeys = getSeleniumWebDriverModifierKeys(modifiers);
+        // Omitting the offset argument to mouseMove results in clicking the center.
+        // This is the default behavior we want, so we use an empty array of offsetArgs if
+        // no args remain after popping the modifiers from the args passed to this function.
+        const offsetArgs = (args.length === 2 ? [{ x: args[0], y: args[1] }] : []);
+        let actions = this._actions().mouseMove(this.element(), ...offsetArgs);
+        for (const modifierKey of modifierKeys) {
+            actions = actions.keyDown(modifierKey);
+        }
+        actions = actions.click(button);
+        for (const modifierKey of modifierKeys) {
+            actions = actions.keyUp(modifierKey);
+        }
+        await actions.perform();
+    }
+}
+/**
+ * Dispatches an event with a particular name and data to an element. Note that this needs to be a
+ * pure function, because it gets stringified by WebDriver and is executed inside the browser.
+ */
+function dispatchEvent(name, element, data) {
+    const event = document.createEvent('Event');
+    event.initEvent(name);
+    // tslint:disable-next-line:ban Have to use `Object.assign` to preserve the original object.
+    Object.assign(event, data || {});
+    element.dispatchEvent(event);
+}
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/testing/selenium-webdriver/selenium-web-driver-harness-environment.mjs

@@ -0,0 +1,88 @@
+/**
+ * @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 { HarnessEnvironment } from '@angular/cdk/testing';
+import * as webdriver from 'selenium-webdriver';
+import { SeleniumWebDriverElement } from './selenium-web-driver-element';
+/** The default environment options. */
+const defaultEnvironmentOptions = {
+    queryFn: async (selector, root) => root().findElements(webdriver.By.css(selector)),
+};
+/**
+ * This function is meant to be executed in the browser. It taps into the hooks exposed by Angular
+ * and invokes the specified `callback` when the application is stable (no more pending tasks).
+ */
+function whenStable(callback) {
+    Promise.all(window.frameworkStabilizers.map(stabilizer => new Promise(stabilizer))).then(callback);
+}
+/**
+ * This function is meant to be executed in the browser. It checks whether the Angular framework has
+ * bootstrapped yet.
+ */
+function isBootstrapped() {
+    return !!window.frameworkStabilizers;
+}
+/** Waits for angular to be ready after the page load. */
+export async function waitForAngularReady(wd) {
+    await wd.wait(() => wd.executeScript(isBootstrapped));
+    await wd.executeAsyncScript(whenStable);
+}
+/** A `HarnessEnvironment` implementation for WebDriver. */
+export class SeleniumWebDriverHarnessEnvironment extends HarnessEnvironment {
+    constructor(rawRootElement, options) {
+        super(rawRootElement);
+        this._options = { ...defaultEnvironmentOptions, ...options };
+        this._stabilizeCallback = () => this.forceStabilize();
+    }
+    /** Gets the ElementFinder corresponding to the given TestElement. */
+    static getNativeElement(el) {
+        if (el instanceof SeleniumWebDriverElement) {
+            return el.element();
+        }
+        throw Error('This TestElement was not created by the WebDriverHarnessEnvironment');
+    }
+    /** Creates a `HarnessLoader` rooted at the document root. */
+    static loader(driver, options) {
+        return new SeleniumWebDriverHarnessEnvironment(() => driver.findElement(webdriver.By.css('body')), options);
+    }
+    /**
+     * Flushes change detection and async tasks captured in the Angular zone.
+     * In most cases it should not be necessary to call this manually. However, there may be some edge
+     * cases where it is needed to fully flush animation events.
+     */
+    async forceStabilize() {
+        await this.rawRootElement().getDriver().executeAsyncScript(whenStable);
+    }
+    /** @docs-private */
+    async waitForTasksOutsideAngular() {
+        // TODO: figure out how we can do this for the webdriver environment.
+        //  https://github.com/angular/components/issues/17412
+    }
+    /** Gets the root element for the document. */
+    getDocumentRoot() {
+        return () => this.rawRootElement().getDriver().findElement(webdriver.By.css('body'));
+    }
+    /** Creates a `TestElement` from a raw element. */
+    createTestElement(element) {
+        return new SeleniumWebDriverElement(element, this._stabilizeCallback);
+    }
+    /** Creates a `HarnessLoader` rooted at the given raw element. */
+    createEnvironment(element) {
+        return new SeleniumWebDriverHarnessEnvironment(element, this._options);
+    }
+    // Note: This seems to be working, though we may need to re-evaluate if we encounter issues with
+    // stale element references. `() => Promise<webdriver.WebElement[]>` seems like a more correct
+    // return type, though supporting it would require changes to the public harness API.
+    /**
+     * Gets a list of all elements matching the given selector under this environment's root element.
+     */
+    async getAllRawElements(selector) {
+        const els = await this._options.queryFn(selector, this.rawRootElement);
+        return els.map((x) => () => x);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/testing/selenium-webdriver/selenium-webdriver-keys.mjs

@@ -0,0 +1,63 @@
+/**
+ * @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 { TestKey } from '@angular/cdk/testing';
+import * as webdriver from 'selenium-webdriver';
+/**
+ * Maps the `TestKey` constants to WebDriver's `webdriver.Key` constants.
+ * See https://github.com/SeleniumHQ/selenium/blob/trunk/javascript/webdriver/key.js#L29
+ */
+export const seleniumWebDriverKeyMap = {
+    [TestKey.BACKSPACE]: webdriver.Key.BACK_SPACE,
+    [TestKey.TAB]: webdriver.Key.TAB,
+    [TestKey.ENTER]: webdriver.Key.ENTER,
+    [TestKey.SHIFT]: webdriver.Key.SHIFT,
+    [TestKey.CONTROL]: webdriver.Key.CONTROL,
+    [TestKey.ALT]: webdriver.Key.ALT,
+    [TestKey.ESCAPE]: webdriver.Key.ESCAPE,
+    [TestKey.PAGE_UP]: webdriver.Key.PAGE_UP,
+    [TestKey.PAGE_DOWN]: webdriver.Key.PAGE_DOWN,
+    [TestKey.END]: webdriver.Key.END,
+    [TestKey.HOME]: webdriver.Key.HOME,
+    [TestKey.LEFT_ARROW]: webdriver.Key.ARROW_LEFT,
+    [TestKey.UP_ARROW]: webdriver.Key.ARROW_UP,
+    [TestKey.RIGHT_ARROW]: webdriver.Key.ARROW_RIGHT,
+    [TestKey.DOWN_ARROW]: webdriver.Key.ARROW_DOWN,
+    [TestKey.INSERT]: webdriver.Key.INSERT,
+    [TestKey.DELETE]: webdriver.Key.DELETE,
+    [TestKey.F1]: webdriver.Key.F1,
+    [TestKey.F2]: webdriver.Key.F2,
+    [TestKey.F3]: webdriver.Key.F3,
+    [TestKey.F4]: webdriver.Key.F4,
+    [TestKey.F5]: webdriver.Key.F5,
+    [TestKey.F6]: webdriver.Key.F6,
+    [TestKey.F7]: webdriver.Key.F7,
+    [TestKey.F8]: webdriver.Key.F8,
+    [TestKey.F9]: webdriver.Key.F9,
+    [TestKey.F10]: webdriver.Key.F10,
+    [TestKey.F11]: webdriver.Key.F11,
+    [TestKey.F12]: webdriver.Key.F12,
+    [TestKey.META]: webdriver.Key.META,
+};
+/** Gets a list of WebDriver `Key`s for the given `ModifierKeys`. */
+export function getSeleniumWebDriverModifierKeys(modifiers) {
+    const result = [];
+    if (modifiers.control) {
+        result.push(webdriver.Key.CONTROL);
+    }
+    if (modifiers.alt) {
+        result.push(webdriver.Key.ALT);
+    }
+    if (modifiers.shift) {
+        result.push(webdriver.Key.SHIFT);
+    }
+    if (modifiers.meta) {
+        result.push(webdriver.Key.META);
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/testing/test-element-errors.mjs

@@ -0,0 +1,15 @@
+/**
+ * @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
+ */
+/**
+ * Returns an error which reports that no keys have been specified.
+ * @docs-private
+ */
+export function getNoKeysSpecifiedError() {
+    return Error('No keys have been specified.');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC1lbGVtZW50LWVycm9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jZGsvdGVzdGluZy90ZXN0LWVsZW1lbnQtZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOzs7R0FHRztBQUNILE1BQU0sVUFBVSx1QkFBdUI7SUFDckMsT0FBTyxLQUFLLENBQUMsOEJBQThCLENBQUMsQ0FBQztBQUMvQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbi8qKlxuICogUmV0dXJucyBhbiBlcnJvciB3aGljaCByZXBvcnRzIHRoYXQgbm8ga2V5cyBoYXZlIGJlZW4gc3BlY2lmaWVkLlxuICogQGRvY3MtcHJpdmF0ZVxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0Tm9LZXlzU3BlY2lmaWVkRXJyb3IoKSB7XG4gIHJldHVybiBFcnJvcignTm8ga2V5cyBoYXZlIGJlZW4gc3BlY2lmaWVkLicpO1xufVxuIl19

front/app/node_modules/@angular/cdk/esm2020/testing/test-element.mjs

@@ -0,0 +1,48 @@
+/**
+ * @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
+ */
+/** An enum of non-text keys that can be used with the `sendKeys` method. */
+// NOTE: This is a separate enum from `@angular/cdk/keycodes` because we don't necessarily want to
+// support every possible keyCode. We also can't rely on Protractor's `Key` because we don't want a
+// dependency on any particular testing framework here. Instead we'll just maintain this supported
+// list of keys and let individual concrete `HarnessEnvironment` classes map them to whatever key
+// representation is used in its respective testing framework.
+// tslint:disable-next-line:prefer-const-enum Seems like this causes some issues with System.js
+export var TestKey;
+(function (TestKey) {
+    TestKey[TestKey["BACKSPACE"] = 0] = "BACKSPACE";
+    TestKey[TestKey["TAB"] = 1] = "TAB";
+    TestKey[TestKey["ENTER"] = 2] = "ENTER";
+    TestKey[TestKey["SHIFT"] = 3] = "SHIFT";
+    TestKey[TestKey["CONTROL"] = 4] = "CONTROL";
+    TestKey[TestKey["ALT"] = 5] = "ALT";
+    TestKey[TestKey["ESCAPE"] = 6] = "ESCAPE";
+    TestKey[TestKey["PAGE_UP"] = 7] = "PAGE_UP";
+    TestKey[TestKey["PAGE_DOWN"] = 8] = "PAGE_DOWN";
+    TestKey[TestKey["END"] = 9] = "END";
+    TestKey[TestKey["HOME"] = 10] = "HOME";
+    TestKey[TestKey["LEFT_ARROW"] = 11] = "LEFT_ARROW";
+    TestKey[TestKey["UP_ARROW"] = 12] = "UP_ARROW";
+    TestKey[TestKey["RIGHT_ARROW"] = 13] = "RIGHT_ARROW";
+    TestKey[TestKey["DOWN_ARROW"] = 14] = "DOWN_ARROW";
+    TestKey[TestKey["INSERT"] = 15] = "INSERT";
+    TestKey[TestKey["DELETE"] = 16] = "DELETE";
+    TestKey[TestKey["F1"] = 17] = "F1";
+    TestKey[TestKey["F2"] = 18] = "F2";
+    TestKey[TestKey["F3"] = 19] = "F3";
+    TestKey[TestKey["F4"] = 20] = "F4";
+    TestKey[TestKey["F5"] = 21] = "F5";
+    TestKey[TestKey["F6"] = 22] = "F6";
+    TestKey[TestKey["F7"] = 23] = "F7";
+    TestKey[TestKey["F8"] = 24] = "F8";
+    TestKey[TestKey["F9"] = 25] = "F9";
+    TestKey[TestKey["F10"] = 26] = "F10";
+    TestKey[TestKey["F11"] = 27] = "F11";
+    TestKey[TestKey["F12"] = 28] = "F12";
+    TestKey[TestKey["META"] = 29] = "META";
+})(TestKey || (TestKey = {}));
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/testing/testbed/fake-events/dispatch-events.mjs

@@ -0,0 +1,53 @@
+/**
+ * @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 { createFakeEvent, createKeyboardEvent, createMouseEvent, createPointerEvent, createTouchEvent, } from './event-objects';
+/**
+ * Utility to dispatch any event on a Node.
+ * @docs-private
+ */
+export function dispatchEvent(node, event) {
+    node.dispatchEvent(event);
+    return event;
+}
+/**
+ * Shorthand to dispatch a fake event on a specified node.
+ * @docs-private
+ */
+export function dispatchFakeEvent(node, type, bubbles) {
+    return dispatchEvent(node, createFakeEvent(type, bubbles));
+}
+/**
+ * Shorthand to dispatch a keyboard event with a specified key code and
+ * optional modifiers.
+ * @docs-private
+ */
+export function dispatchKeyboardEvent(node, type, keyCode, key, modifiers) {
+    return dispatchEvent(node, createKeyboardEvent(type, keyCode, key, modifiers));
+}
+/**
+ * Shorthand to dispatch a mouse event on the specified coordinates.
+ * @docs-private
+ */
+export function dispatchMouseEvent(node, type, clientX = 0, clientY = 0, offsetX, offsetY, button, modifiers) {
+    return dispatchEvent(node, createMouseEvent(type, clientX, clientY, offsetX, offsetY, button, modifiers));
+}
+/**
+ * Shorthand to dispatch a pointer event on the specified coordinates.
+ * @docs-private
+ */
+export function dispatchPointerEvent(node, type, clientX = 0, clientY = 0, offsetX, offsetY, options) {
+    return dispatchEvent(node, createPointerEvent(type, clientX, clientY, offsetX, offsetY, options));
+}
+/**
+ * Shorthand to dispatch a touch event on the specified coordinates.
+ * @docs-private
+ */
+export function dispatchTouchEvent(node, type, pageX = 0, pageY = 0, clientX = 0, clientY = 0) {
+    return dispatchEvent(node, createTouchEvent(type, pageX, pageY, clientX, clientY));
+}
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/testing/testbed/fake-events/element-focus.mjs

@@ -0,0 +1,39 @@
+/**
+ * @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 { dispatchFakeEvent } from './dispatch-events';
+function triggerFocusChange(element, event) {
+    let eventFired = false;
+    const handler = () => (eventFired = true);
+    element.addEventListener(event, handler);
+    element[event]();
+    element.removeEventListener(event, handler);
+    if (!eventFired) {
+        dispatchFakeEvent(element, event);
+    }
+}
+/**
+ * Patches an elements focus and blur methods to emit events consistently and predictably.
+ * This is necessary, because some browsers can call the focus handlers asynchronously,
+ * while others won't fire them at all if the browser window is not focused.
+ * @docs-private
+ */
+// TODO: Check if this element focus patching is still needed for local testing,
+// where browser is not necessarily focused.
+export function patchElementFocus(element) {
+    element.focus = () => dispatchFakeEvent(element, 'focus');
+    element.blur = () => dispatchFakeEvent(element, 'blur');
+}
+/** @docs-private */
+export function triggerFocus(element) {
+    triggerFocusChange(element, 'focus');
+}
+/** @docs-private */
+export function triggerBlur(element) {
+    triggerFocusChange(element, 'blur');
+}
+//# sourceMappingURL=data:application/json;base64,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

front/app/node_modules/@angular/cdk/esm2020/testing/testbed/fake-events/event-objects.mjs

@@ -0,0 +1,127 @@
+/**
+ * @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
+ */
+/** Used to generate unique IDs for events. */
+let uniqueIds = 0;
+/**
+ * Creates a browser MouseEvent with the specified options.
+ * @docs-private
+ */
+export function createMouseEvent(type, clientX = 0, clientY = 0, offsetX = 1, offsetY = 1, button = 0, modifiers = {}) {
+    // Note: We cannot determine the position of the mouse event based on the screen
+    // because the dimensions and position of the browser window are not available
+    // To provide reasonable `screenX` and `screenY` coordinates, we simply use the
+    // client coordinates as if the browser is opened in fullscreen.
+    const screenX = clientX;
+    const screenY = clientY;
+    const event = new MouseEvent(type, {
+        bubbles: true,
+        cancelable: true,
+        composed: true,
+        view: window,
+        detail: 0,
+        relatedTarget: null,
+        screenX,
+        screenY,
+        clientX,
+        clientY,
+        ctrlKey: modifiers.control,
+        altKey: modifiers.alt,
+        shiftKey: modifiers.shift,
+        metaKey: modifiers.meta,
+        button: button,
+        buttons: 1,
+    });
+    // The `MouseEvent` constructor doesn't allow us to pass these properties into the constructor.
+    // Override them to `1`, because they're used for fake screen reader event detection.
+    if (offsetX != null) {
+        defineReadonlyEventProperty(event, 'offsetX', offsetX);
+    }
+    if (offsetY != null) {
+        defineReadonlyEventProperty(event, 'offsetY', offsetY);
+    }
+    return event;
+}
+/**
+ * Creates a browser `PointerEvent` with the specified options. Pointer events
+ * by default will appear as if they are the primary pointer of their type.
+ * https://www.w3.org/TR/pointerevents2/#dom-pointerevent-isprimary.
+ *
+ * For example, if pointer events for a multi-touch interaction are created, the non-primary
+ * pointer touches would need to be represented by non-primary pointer events.
+ *
+ * @docs-private
+ */
+export function createPointerEvent(type, clientX = 0, clientY = 0, offsetX, offsetY, options = { isPrimary: true }) {
+    const event = new PointerEvent(type, {
+        bubbles: true,
+        cancelable: true,
+        composed: true,
+        view: window,
+        clientX,
+        clientY,
+        ...options,
+    });
+    if (offsetX != null) {
+        defineReadonlyEventProperty(event, 'offsetX', offsetX);
+    }
+    if (offsetY != null) {
+        defineReadonlyEventProperty(event, 'offsetY', offsetY);
+    }
+    return event;
+}
+/**
+ * Creates a browser TouchEvent with the specified pointer coordinates.
+ * @docs-private
+ */
+export function createTouchEvent(type, pageX = 0, pageY = 0, clientX = 0, clientY = 0) {
+    // We cannot use the `TouchEvent` or `Touch` because Firefox and Safari lack support.
+    // TODO: Switch to the constructor API when it is available for Firefox and Safari.
+    const event = document.createEvent('UIEvent');
+    const touchDetails = { pageX, pageY, clientX, clientY, identifier: uniqueIds++ };
+    // TS3.6 removes the initUIEvent method and suggests porting to "new UIEvent()".
+    event.initUIEvent(type, true, true, window, 0);
+    // Most of the browsers don't have a "initTouchEvent" method that can be used to define
+    // the touch details.
+    defineReadonlyEventProperty(event, 'touches', [touchDetails]);
+    defineReadonlyEventProperty(event, 'targetTouches', [touchDetails]);
+    defineReadonlyEventProperty(event, 'changedTouches', [touchDetails]);
+    return event;
+}
+/**
+ * Creates a keyboard event with the specified key and modifiers.
+ * @docs-private
+ */
+export function createKeyboardEvent(type, keyCode = 0, key = '', modifiers = {}) {
+    return new KeyboardEvent(type, {
+        bubbles: true,
+        cancelable: true,
+        composed: true,
+        view: window,
+        keyCode: keyCode,
+        key: key,
+        shiftKey: modifiers.shift,
+        metaKey: modifiers.meta,
+        altKey: modifiers.alt,
+        ctrlKey: modifiers.control,
+    });
+}
+/**
+ * Creates a fake event object with any desired event type.
+ * @docs-private
+ */
+export function createFakeEvent(type, bubbles = false, cancelable = true, composed = true) {
+    return new Event(type, { bubbles, cancelable, composed });
+}
+/**
+ * Defines a readonly property on the given event object. Readonly properties on an event object
+ * are always set as configurable as that matches default readonly properties for DOM event objects.
+ */
+function defineReadonlyEventProperty(event, propertyName, value) {
+    Object.defineProperty(event, propertyName, { get: () => value, configurable: true });
+}
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/testing/testbed/fake-events/index.mjs

@@ -0,0 +1,14 @@
+/**
+ * @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
+ */
+// These are private APIs that are used both by the public APIs inside of this package, as well
+// as in unit tests of other entry-points, hence why we need to re-export them through here.
+export * from './dispatch-events';
+export * from './event-objects';
+export * from './element-focus';
+export * from './type-in-element';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL3Rlc3RpbmcvdGVzdGJlZC9mYWtlLWV2ZW50cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCwrRkFBK0Y7QUFDL0YsNEZBQTRGO0FBQzVGLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLy8gVGhlc2UgYXJlIHByaXZhdGUgQVBJcyB0aGF0IGFyZSB1c2VkIGJvdGggYnkgdGhlIHB1YmxpYyBBUElzIGluc2lkZSBvZiB0aGlzIHBhY2thZ2UsIGFzIHdlbGxcbi8vIGFzIGluIHVuaXQgdGVzdHMgb2Ygb3RoZXIgZW50cnktcG9pbnRzLCBoZW5jZSB3aHkgd2UgbmVlZCB0byByZS1leHBvcnQgdGhlbSB0aHJvdWdoIGhlcmUuXG5leHBvcnQgKiBmcm9tICcuL2Rpc3BhdGNoLWV2ZW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2V2ZW50LW9iamVjdHMnO1xuZXhwb3J0ICogZnJvbSAnLi9lbGVtZW50LWZvY3VzJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZS1pbi1lbGVtZW50JztcbiJdfQ==

front/app/node_modules/@angular/cdk/esm2020/testing/testbed/fake-events/type-in-element.mjs

@@ -0,0 +1,97 @@
+/**
+ * @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 { getNoKeysSpecifiedError } from '@angular/cdk/testing';
+import { PERIOD } from '@angular/cdk/keycodes';
+import { dispatchFakeEvent, dispatchKeyboardEvent } from './dispatch-events';
+import { triggerFocus } from './element-focus';
+/** Input types for which the value can be entered incrementally. */
+const incrementalInputTypes = new Set([
+    'text',
+    'email',
+    'hidden',
+    'password',
+    'search',
+    'tel',
+    'url',
+]);
+/**
+ * Checks whether the given Element is a text input element.
+ * @docs-private
+ */
+export function isTextInput(element) {
+    const nodeName = element.nodeName.toLowerCase();
+    return nodeName === 'input' || nodeName === 'textarea';
+}
+export function typeInElement(element, ...modifiersAndKeys) {
+    const first = modifiersAndKeys[0];
+    let modifiers;
+    let rest;
+    if (first !== undefined &&
+        typeof first !== 'string' &&
+        first.keyCode === undefined &&
+        first.key === undefined) {
+        modifiers = first;
+        rest = modifiersAndKeys.slice(1);
+    }
+    else {
+        modifiers = {};
+        rest = modifiersAndKeys;
+    }
+    const isInput = isTextInput(element);
+    const inputType = element.getAttribute('type') || 'text';
+    const keys = rest
+        .map(k => typeof k === 'string'
+        ? k.split('').map(c => ({ keyCode: c.toUpperCase().charCodeAt(0), key: c }))
+        : [k])
+        .reduce((arr, k) => arr.concat(k), []);
+    // Throw an error if no keys have been specified. Calling this function with no
+    // keys should not result in a focus event being dispatched unexpectedly.
+    if (keys.length === 0) {
+        throw getNoKeysSpecifiedError();
+    }
+    // We simulate the user typing in a value by incrementally assigning the value below. The problem
+    // is that for some input types, the browser won't allow for an invalid value to be set via the
+    // `value` property which will always be the case when going character-by-character. If we detect
+    // such an input, we have to set the value all at once or listeners to the `input` event (e.g.
+    // the `ReactiveFormsModule` uses such an approach) won't receive the correct value.
+    const enterValueIncrementally = inputType === 'number'
+        ? // The value can be set character by character in number inputs if it doesn't have any decimals.
+            keys.every(key => key.key !== '.' && key.key !== '-' && key.keyCode !== PERIOD)
+        : incrementalInputTypes.has(inputType);
+    triggerFocus(element);
+    // When we aren't entering the value incrementally, assign it all at once ahead
+    // of time so that any listeners to the key events below will have access to it.
+    if (!enterValueIncrementally) {
+        element.value = keys.reduce((value, key) => value + (key.key || ''), '');
+    }
+    for (const key of keys) {
+        dispatchKeyboardEvent(element, 'keydown', key.keyCode, key.key, modifiers);
+        dispatchKeyboardEvent(element, 'keypress', key.keyCode, key.key, modifiers);
+        if (isInput && key.key && key.key.length === 1) {
+            if (enterValueIncrementally) {
+                element.value += key.key;
+                dispatchFakeEvent(element, 'input');
+            }
+        }
+        dispatchKeyboardEvent(element, 'keyup', key.keyCode, key.key, modifiers);
+    }
+    // Since we weren't dispatching `input` events while sending the keys, we have to do it now.
+    if (!enterValueIncrementally) {
+        dispatchFakeEvent(element, 'input');
+    }
+}
+/**
+ * Clears the text in an input or textarea element.
+ * @docs-private
+ */
+export function clearElement(element) {
+    triggerFocus(element);
+    element.value = '';
+    dispatchFakeEvent(element, 'input');
+}
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/testing/testbed/index.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL3Rlc3RpbmcvdGVzdGJlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

front/app/node_modules/@angular/cdk/esm2020/testing/testbed/public-api.mjs

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './testbed-harness-environment';
+export * from './unit-test-element';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jZGsvdGVzdGluZy90ZXN0YmVkL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHFCQUFxQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vdGVzdGJlZC1oYXJuZXNzLWVudmlyb25tZW50JztcbmV4cG9ydCAqIGZyb20gJy4vdW5pdC10ZXN0LWVsZW1lbnQnO1xuIl19

front/app/node_modules/@angular/cdk/esm2020/testing/testbed/task-state-zone-interceptor.mjs

@@ -0,0 +1,82 @@
+/**
+ * @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 { BehaviorSubject } from 'rxjs';
+/** Unique symbol that is used to patch a property to a proxy zone. */
+const stateObservableSymbol = Symbol('ProxyZone_PATCHED#stateObservable');
+/**
+ * Interceptor that can be set up in a `ProxyZone` instance. The interceptor
+ * will keep track of the task state and emit whenever the state changes.
+ *
+ * This serves as a workaround for https://github.com/angular/angular/issues/32896.
+ */
+export class TaskStateZoneInterceptor {
+    constructor(_lastState) {
+        this._lastState = _lastState;
+        /** Subject that can be used to emit a new state change. */
+        this._stateSubject = new BehaviorSubject(this._lastState ? this._getTaskStateFromInternalZoneState(this._lastState) : { stable: true });
+        /** Public observable that emits whenever the task state changes. */
+        this.state = this._stateSubject;
+    }
+    /** This will be called whenever the task state changes in the intercepted zone. */
+    onHasTask(delegate, current, target, hasTaskState) {
+        if (current === target) {
+            this._stateSubject.next(this._getTaskStateFromInternalZoneState(hasTaskState));
+        }
+    }
+    /** Gets the task state from the internal ZoneJS task state. */
+    _getTaskStateFromInternalZoneState(state) {
+        return { stable: !state.macroTask && !state.microTask };
+    }
+    /**
+     * Sets up the custom task state Zone interceptor in the  `ProxyZone`. Throws if
+     * no `ProxyZone` could be found.
+     * @returns an observable that emits whenever the task state changes.
+     */
+    static setup() {
+        if (Zone === undefined) {
+            throw Error('Could not find ZoneJS. For test harnesses running in TestBed, ' +
+                'ZoneJS needs to be installed.');
+        }
+        // tslint:disable-next-line:variable-name
+        const ProxyZoneSpec = Zone['ProxyZoneSpec'];
+        // If there is no "ProxyZoneSpec" installed, we throw an error and recommend
+        // setting up the proxy zone by pulling in the testing bundle.
+        if (!ProxyZoneSpec) {
+            throw Error('ProxyZoneSpec is needed for the test harnesses but could not be found. ' +
+                'Please make sure that your environment includes zone.js/dist/zone-testing.js');
+        }
+        // Ensure that there is a proxy zone instance set up, and get
+        // a reference to the instance if present.
+        const zoneSpec = ProxyZoneSpec.assertPresent();
+        // If there already is a delegate registered in the proxy zone, and it
+        // is type of the custom task state interceptor, we just use that state
+        // observable. This allows us to only intercept Zone once per test
+        // (similar to how `fakeAsync` or `async` work).
+        if (zoneSpec[stateObservableSymbol]) {
+            return zoneSpec[stateObservableSymbol];
+        }
+        // Since we intercept on environment creation and the fixture has been
+        // created before, we might have missed tasks scheduled before. Fortunately
+        // the proxy zone keeps track of the previous task state, so we can just pass
+        // this as initial state to the task zone interceptor.
+        const interceptor = new TaskStateZoneInterceptor(zoneSpec.lastTaskState);
+        const zoneSpecOnHasTask = zoneSpec.onHasTask.bind(zoneSpec);
+        // We setup the task state interceptor in the `ProxyZone`. Note that we cannot register
+        // the interceptor as a new proxy zone delegate because it would mean that other zone
+        // delegates (e.g. `FakeAsyncTestZone` or `AsyncTestZone`) can accidentally overwrite/disable
+        // our interceptor. Since we just intend to monitor the task state of the proxy zone, it is
+        // sufficient to just patch the proxy zone. This also avoids that we interfere with the task
+        // queue scheduling logic.
+        zoneSpec.onHasTask = function (...args) {
+            zoneSpecOnHasTask(...args);
+            interceptor.onHasTask(...args);
+        };
+        return (zoneSpec[stateObservableSymbol] = interceptor.state);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/testing/testbed/testbed-harness-environment.mjs

@@ -0,0 +1,163 @@
+/**
+ * @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 { handleAutoChangeDetectionStatus, HarnessEnvironment, stopHandlingAutoChangeDetectionStatus, } from '@angular/cdk/testing';
+import { flush } from '@angular/core/testing';
+import { takeWhile } from 'rxjs/operators';
+import { TaskStateZoneInterceptor } from './task-state-zone-interceptor';
+import { UnitTestElement } from './unit-test-element';
+/** The default environment options. */
+const defaultEnvironmentOptions = {
+    queryFn: (selector, root) => root.querySelectorAll(selector),
+};
+/** Whether auto change detection is currently disabled. */
+let disableAutoChangeDetection = false;
+/**
+ * The set of non-destroyed fixtures currently being used by `TestbedHarnessEnvironment` instances.
+ */
+const activeFixtures = new Set();
+/**
+ * Installs a handler for change detection batching status changes for a specific fixture.
+ * @param fixture The fixture to handle change detection batching for.
+ */
+function installAutoChangeDetectionStatusHandler(fixture) {
+    if (!activeFixtures.size) {
+        handleAutoChangeDetectionStatus(({ isDisabled, onDetectChangesNow }) => {
+            disableAutoChangeDetection = isDisabled;
+            if (onDetectChangesNow) {
+                Promise.all(Array.from(activeFixtures).map(detectChanges)).then(onDetectChangesNow);
+            }
+        });
+    }
+    activeFixtures.add(fixture);
+}
+/**
+ * Uninstalls a handler for change detection batching status changes for a specific fixture.
+ * @param fixture The fixture to stop handling change detection batching for.
+ */
+function uninstallAutoChangeDetectionStatusHandler(fixture) {
+    activeFixtures.delete(fixture);
+    if (!activeFixtures.size) {
+        stopHandlingAutoChangeDetectionStatus();
+    }
+}
+/** Whether we are currently in the fake async zone. */
+function isInFakeAsyncZone() {
+    return Zone.current.get('FakeAsyncTestZoneSpec') != null;
+}
+/**
+ * Triggers change detection for a specific fixture.
+ * @param fixture The fixture to trigger change detection for.
+ */
+async function detectChanges(fixture) {
+    fixture.detectChanges();
+    if (isInFakeAsyncZone()) {
+        flush();
+    }
+    else {
+        await fixture.whenStable();
+    }
+}
+/** A `HarnessEnvironment` implementation for Angular's Testbed. */
+export class TestbedHarnessEnvironment extends HarnessEnvironment {
+    constructor(rawRootElement, _fixture, options) {
+        super(rawRootElement);
+        this._fixture = _fixture;
+        /** Whether the environment has been destroyed. */
+        this._destroyed = false;
+        this._options = { ...defaultEnvironmentOptions, ...options };
+        this._taskState = TaskStateZoneInterceptor.setup();
+        this._stabilizeCallback = () => this.forceStabilize();
+        installAutoChangeDetectionStatusHandler(_fixture);
+        _fixture.componentRef.onDestroy(() => {
+            uninstallAutoChangeDetectionStatusHandler(_fixture);
+            this._destroyed = true;
+        });
+    }
+    /** Creates a `HarnessLoader` rooted at the given fixture's root element. */
+    static loader(fixture, options) {
+        return new TestbedHarnessEnvironment(fixture.nativeElement, fixture, options);
+    }
+    /**
+     * Creates a `HarnessLoader` at the document root. This can be used if harnesses are
+     * located outside of a fixture (e.g. overlays appended to the document body).
+     */
+    static documentRootLoader(fixture, options) {
+        return new TestbedHarnessEnvironment(document.body, fixture, options);
+    }
+    /** Gets the native DOM element corresponding to the given TestElement. */
+    static getNativeElement(el) {
+        if (el instanceof UnitTestElement) {
+            return el.element;
+        }
+        throw Error('This TestElement was not created by the TestbedHarnessEnvironment');
+    }
+    /**
+     * Creates an instance of the given harness type, using the fixture's root element as the
+     * harness's host element. This method should be used when creating a harness for the root element
+     * of a fixture, as components do not have the correct selector when they are created as the root
+     * of the fixture.
+     */
+    static async harnessForFixture(fixture, harnessType, options) {
+        const environment = new TestbedHarnessEnvironment(fixture.nativeElement, fixture, options);
+        await environment.forceStabilize();
+        return environment.createComponentHarness(harnessType, fixture.nativeElement);
+    }
+    /**
+     * Flushes change detection and async tasks captured in the Angular zone.
+     * In most cases it should not be necessary to call this manually. However, there may be some edge
+     * cases where it is needed to fully flush animation events.
+     */
+    async forceStabilize() {
+        if (!disableAutoChangeDetection) {
+            if (this._destroyed) {
+                throw Error('Harness is attempting to use a fixture that has already been destroyed.');
+            }
+            await detectChanges(this._fixture);
+        }
+    }
+    /**
+     * Waits for all scheduled or running async tasks to complete. This allows harness
+     * authors to wait for async tasks outside of the Angular zone.
+     */
+    async waitForTasksOutsideAngular() {
+        // If we run in the fake async zone, we run "flush" to run any scheduled tasks. This
+        // ensures that the harnesses behave inside of the FakeAsyncTestZone similar to the
+        // "AsyncTestZone" and the root zone (i.e. neither fakeAsync or async). Note that we
+        // cannot just rely on the task state observable to become stable because the state will
+        // never change. This is because the task queue will be only drained if the fake async
+        // zone is being flushed.
+        if (isInFakeAsyncZone()) {
+            flush();
+        }
+        // Wait until the task queue has been drained and the zone is stable. Note that
+        // we cannot rely on "fixture.whenStable" since it does not catch tasks scheduled
+        // outside of the Angular zone. For test harnesses, we want to ensure that the
+        // app is fully stabilized and therefore need to use our own zone interceptor.
+        await this._taskState.pipe(takeWhile(state => !state.stable)).toPromise();
+    }
+    /** Gets the root element for the document. */
+    getDocumentRoot() {
+        return document.body;
+    }
+    /** Creates a `TestElement` from a raw element. */
+    createTestElement(element) {
+        return new UnitTestElement(element, this._stabilizeCallback);
+    }
+    /** Creates a `HarnessLoader` rooted at the given raw element. */
+    createEnvironment(element) {
+        return new TestbedHarnessEnvironment(element, this._fixture, this._options);
+    }
+    /**
+     * Gets a list of all elements matching the given selector under this environment's root element.
+     */
+    async getAllRawElements(selector) {
+        await this.forceStabilize();
+        return Array.from(this._options.queryFn(selector, this.rawRootElement));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/testing/testbed/unit-test-element.mjs

@@ -0,0 +1,245 @@
+/**
+ * @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 * as keyCodes from '@angular/cdk/keycodes';
+import { _getTextWithExcludedElements, TestKey, } from '@angular/cdk/testing';
+import { clearElement, createFakeEvent, dispatchFakeEvent, dispatchMouseEvent, dispatchPointerEvent, isTextInput, triggerBlur, triggerFocus, typeInElement, dispatchEvent, } from './fake-events';
+/** Maps `TestKey` constants to the `keyCode` and `key` values used by native browser events. */
+const keyMap = {
+    [TestKey.BACKSPACE]: { keyCode: keyCodes.BACKSPACE, key: 'Backspace' },
+    [TestKey.TAB]: { keyCode: keyCodes.TAB, key: 'Tab' },
+    [TestKey.ENTER]: { keyCode: keyCodes.ENTER, key: 'Enter' },
+    [TestKey.SHIFT]: { keyCode: keyCodes.SHIFT, key: 'Shift' },
+    [TestKey.CONTROL]: { keyCode: keyCodes.CONTROL, key: 'Control' },
+    [TestKey.ALT]: { keyCode: keyCodes.ALT, key: 'Alt' },
+    [TestKey.ESCAPE]: { keyCode: keyCodes.ESCAPE, key: 'Escape' },
+    [TestKey.PAGE_UP]: { keyCode: keyCodes.PAGE_UP, key: 'PageUp' },
+    [TestKey.PAGE_DOWN]: { keyCode: keyCodes.PAGE_DOWN, key: 'PageDown' },
+    [TestKey.END]: { keyCode: keyCodes.END, key: 'End' },
+    [TestKey.HOME]: { keyCode: keyCodes.HOME, key: 'Home' },
+    [TestKey.LEFT_ARROW]: { keyCode: keyCodes.LEFT_ARROW, key: 'ArrowLeft' },
+    [TestKey.UP_ARROW]: { keyCode: keyCodes.UP_ARROW, key: 'ArrowUp' },
+    [TestKey.RIGHT_ARROW]: { keyCode: keyCodes.RIGHT_ARROW, key: 'ArrowRight' },
+    [TestKey.DOWN_ARROW]: { keyCode: keyCodes.DOWN_ARROW, key: 'ArrowDown' },
+    [TestKey.INSERT]: { keyCode: keyCodes.INSERT, key: 'Insert' },
+    [TestKey.DELETE]: { keyCode: keyCodes.DELETE, key: 'Delete' },
+    [TestKey.F1]: { keyCode: keyCodes.F1, key: 'F1' },
+    [TestKey.F2]: { keyCode: keyCodes.F2, key: 'F2' },
+    [TestKey.F3]: { keyCode: keyCodes.F3, key: 'F3' },
+    [TestKey.F4]: { keyCode: keyCodes.F4, key: 'F4' },
+    [TestKey.F5]: { keyCode: keyCodes.F5, key: 'F5' },
+    [TestKey.F6]: { keyCode: keyCodes.F6, key: 'F6' },
+    [TestKey.F7]: { keyCode: keyCodes.F7, key: 'F7' },
+    [TestKey.F8]: { keyCode: keyCodes.F8, key: 'F8' },
+    [TestKey.F9]: { keyCode: keyCodes.F9, key: 'F9' },
+    [TestKey.F10]: { keyCode: keyCodes.F10, key: 'F10' },
+    [TestKey.F11]: { keyCode: keyCodes.F11, key: 'F11' },
+    [TestKey.F12]: { keyCode: keyCodes.F12, key: 'F12' },
+    [TestKey.META]: { keyCode: keyCodes.META, key: 'Meta' },
+};
+/** A `TestElement` implementation for unit tests. */
+export class UnitTestElement {
+    constructor(element, _stabilize) {
+        this.element = element;
+        this._stabilize = _stabilize;
+    }
+    /** Blur the element. */
+    async blur() {
+        triggerBlur(this.element);
+        await this._stabilize();
+    }
+    /** Clear the element's input (for input and textarea elements only). */
+    async clear() {
+        if (!isTextInput(this.element)) {
+            throw Error('Attempting to clear an invalid element');
+        }
+        clearElement(this.element);
+        await this._stabilize();
+    }
+    async click(...args) {
+        const isDisabled = this.element.disabled === true;
+        // If the element is `disabled` and has a `disabled` property, we emit the mouse event
+        // sequence but not dispatch the `click` event. This is necessary to keep the behavior
+        // consistent with an actual user interaction. The click event is not necessarily
+        // automatically prevented by the browser. There is mismatch between Firefox and Chromium:
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=329509.
+        // https://bugs.chromium.org/p/chromium/issues/detail?id=1115661.
+        await this._dispatchMouseEventSequence(isDisabled ? null : 'click', args, 0);
+        await this._stabilize();
+    }
+    async rightClick(...args) {
+        await this._dispatchMouseEventSequence('contextmenu', args, 2);
+        await this._stabilize();
+    }
+    /** Focus the element. */
+    async focus() {
+        triggerFocus(this.element);
+        await this._stabilize();
+    }
+    /** Get the computed value of the given CSS property for the element. */
+    async getCssValue(property) {
+        await this._stabilize();
+        // TODO(mmalerba): Consider adding value normalization if we run into common cases where its
+        //  needed.
+        return getComputedStyle(this.element).getPropertyValue(property);
+    }
+    /** Hovers the mouse over the element. */
+    async hover() {
+        this._dispatchPointerEventIfSupported('pointerenter');
+        dispatchMouseEvent(this.element, 'mouseover');
+        dispatchMouseEvent(this.element, 'mouseenter');
+        await this._stabilize();
+    }
+    /** Moves the mouse away from the element. */
+    async mouseAway() {
+        this._dispatchPointerEventIfSupported('pointerleave');
+        dispatchMouseEvent(this.element, 'mouseout');
+        dispatchMouseEvent(this.element, 'mouseleave');
+        await this._stabilize();
+    }
+    async sendKeys(...modifiersAndKeys) {
+        const args = modifiersAndKeys.map(k => (typeof k === 'number' ? keyMap[k] : k));
+        typeInElement(this.element, ...args);
+        await this._stabilize();
+    }
+    /**
+     * Gets the text from the element.
+     * @param options Options that affect what text is included.
+     */
+    async text(options) {
+        await this._stabilize();
+        if (options?.exclude) {
+            return _getTextWithExcludedElements(this.element, options.exclude);
+        }
+        return (this.element.textContent || '').trim();
+    }
+    /** Gets the value for the given attribute from the element. */
+    async getAttribute(name) {
+        await this._stabilize();
+        return this.element.getAttribute(name);
+    }
+    /** Checks whether the element has the given class. */
+    async hasClass(name) {
+        await this._stabilize();
+        return this.element.classList.contains(name);
+    }
+    /** Gets the dimensions of the element. */
+    async getDimensions() {
+        await this._stabilize();
+        return this.element.getBoundingClientRect();
+    }
+    /** Gets the value of a property of an element. */
+    async getProperty(name) {
+        await this._stabilize();
+        return this.element[name];
+    }
+    /** Sets the value of a property of an input. */
+    async setInputValue(value) {
+        this.element.value = value;
+        await this._stabilize();
+    }
+    /** Selects the options at the specified indexes inside of a native `select` element. */
+    async selectOptions(...optionIndexes) {
+        let hasChanged = false;
+        const options = this.element.querySelectorAll('option');
+        const indexes = new Set(optionIndexes); // Convert to a set to remove duplicates.
+        for (let i = 0; i < options.length; i++) {
+            const option = options[i];
+            const wasSelected = option.selected;
+            // We have to go through `option.selected`, because `HTMLSelectElement.value` doesn't
+            // allow for multiple options to be selected, even in `multiple` mode.
+            option.selected = indexes.has(i);
+            if (option.selected !== wasSelected) {
+                hasChanged = true;
+                dispatchFakeEvent(this.element, 'change');
+            }
+        }
+        if (hasChanged) {
+            await this._stabilize();
+        }
+    }
+    /** Checks whether this element matches the given selector. */
+    async matchesSelector(selector) {
+        await this._stabilize();
+        const elementPrototype = Element.prototype;
+        return (elementPrototype['matches'] || elementPrototype['msMatchesSelector']).call(this.element, selector);
+    }
+    /** Checks whether the element is focused. */
+    async isFocused() {
+        await this._stabilize();
+        return document.activeElement === this.element;
+    }
+    /**
+     * Dispatches an event with a particular name.
+     * @param name Name of the event to be dispatched.
+     */
+    async dispatchEvent(name, data) {
+        const event = createFakeEvent(name);
+        if (data) {
+            // tslint:disable-next-line:ban Have to use `Object.assign` to preserve the original object.
+            Object.assign(event, data);
+        }
+        dispatchEvent(this.element, event);
+        await this._stabilize();
+    }
+    /**
+     * Dispatches a pointer event on the current element if the browser supports it.
+     * @param name Name of the pointer event to be dispatched.
+     * @param clientX Coordinate of the user's pointer along the X axis.
+     * @param clientY Coordinate of the user's pointer along the Y axis.
+     * @param button Mouse button that should be pressed when dispatching the event.
+     */
+    _dispatchPointerEventIfSupported(name, clientX, clientY, offsetX, offsetY, button) {
+        // The latest versions of all browsers we support have the new `PointerEvent` API.
+        // Though since we capture the two most recent versions of these browsers, we also
+        // need to support Safari 12 at time of writing. Safari 12 does not have support for this,
+        // so we need to conditionally create and dispatch these events based on feature detection.
+        if (typeof PointerEvent !== 'undefined' && PointerEvent) {
+            dispatchPointerEvent(this.element, name, clientX, clientY, offsetX, offsetY, {
+                isPrimary: true,
+                button,
+            });
+        }
+    }
+    /**
+     * Dispatches all the events that are part of a mouse event sequence
+     * and then emits a given primary event at the end, if speciifed.
+     */
+    async _dispatchMouseEventSequence(primaryEventName, args, button) {
+        let clientX = undefined;
+        let clientY = undefined;
+        let offsetX = undefined;
+        let offsetY = undefined;
+        let modifiers = {};
+        if (args.length && typeof args[args.length - 1] === 'object') {
+            modifiers = args.pop();
+        }
+        if (args.length) {
+            const { left, top, width, height } = await this.getDimensions();
+            offsetX = args[0] === 'center' ? width / 2 : args[0];
+            offsetY = args[0] === 'center' ? height / 2 : args[1];
+            // Round the computed click position as decimal pixels are not
+            // supported by mouse events and could lead to unexpected results.
+            clientX = Math.round(left + offsetX);
+            clientY = Math.round(top + offsetY);
+        }
+        this._dispatchPointerEventIfSupported('pointerdown', clientX, clientY, offsetX, offsetY, button);
+        dispatchMouseEvent(this.element, 'mousedown', clientX, clientY, offsetX, offsetY, button, modifiers);
+        this._dispatchPointerEventIfSupported('pointerup', clientX, clientY, offsetX, offsetY, button);
+        dispatchMouseEvent(this.element, 'mouseup', clientX, clientY, offsetX, offsetY, button, modifiers);
+        // If a primary event name is specified, emit it after the mouse event sequence.
+        if (primaryEventName !== null) {
+            dispatchMouseEvent(this.element, primaryEventName, clientX, clientY, offsetX, offsetY, button, modifiers);
+        }
+        // This call to _stabilize should not be needed since the callers will already do that them-
+        // selves. Nevertheless it breaks some tests in g3 without it. It needs to be investigated
+        // why removing breaks those tests.
+        // See: https://github.com/angular/components/pull/20758/files#r520886256.
+        await this._stabilize();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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
Line truncated

front/app/node_modules/@angular/cdk/esm2020/testing/text-filtering.mjs

@@ -0,0 +1,21 @@
+/**
+ * @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
+ */
+/**
+ * Gets text of element excluding certain selectors within the element.
+ * @param element Element to get text from,
+ * @param excludeSelector Selector identifying which elements to exclude,
+ */
+export function _getTextWithExcludedElements(element, excludeSelector) {
+    const clone = element.cloneNode(true);
+    const exclusions = clone.querySelectorAll(excludeSelector);
+    for (let i = 0; i < exclusions.length; i++) {
+        exclusions[i].remove();
+    }
+    return (clone.textContent || '').trim();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGV4dC1maWx0ZXJpbmcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrL3Rlc3RpbmcvdGV4dC1maWx0ZXJpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUg7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSw0QkFBNEIsQ0FBQyxPQUFnQixFQUFFLGVBQXVCO0lBQ3BGLE1BQU0sS0FBSyxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFZLENBQUM7SUFDakQsTUFBTSxVQUFVLEdBQUcsS0FBSyxDQUFDLGdCQUFnQixDQUFDLGVBQWUsQ0FBQyxDQUFDO0lBQzNELEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxVQUFVLENBQUMsTUFBTSxFQUFFLENBQUMsRUFBRSxFQUFFO1FBQzFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQztLQUN4QjtJQUNELE9BQU8sQ0FBQyxLQUFLLENBQUMsV0FBVyxJQUFJLEVBQUUsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDO0FBQzFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLyoqXG4gKiBHZXRzIHRleHQgb2YgZWxlbWVudCBleGNsdWRpbmcgY2VydGFpbiBzZWxlY3RvcnMgd2l0aGluIHRoZSBlbGVtZW50LlxuICogQHBhcmFtIGVsZW1lbnQgRWxlbWVudCB0byBnZXQgdGV4dCBmcm9tLFxuICogQHBhcmFtIGV4Y2x1ZGVTZWxlY3RvciBTZWxlY3RvciBpZGVudGlmeWluZyB3aGljaCBlbGVtZW50cyB0byBleGNsdWRlLFxuICovXG5leHBvcnQgZnVuY3Rpb24gX2dldFRleHRXaXRoRXhjbHVkZWRFbGVtZW50cyhlbGVtZW50OiBFbGVtZW50LCBleGNsdWRlU2VsZWN0b3I6IHN0cmluZykge1xuICBjb25zdCBjbG9uZSA9IGVsZW1lbnQuY2xvbmVOb2RlKHRydWUpIGFzIEVsZW1lbnQ7XG4gIGNvbnN0IGV4Y2x1c2lvbnMgPSBjbG9uZS5xdWVyeVNlbGVjdG9yQWxsKGV4Y2x1ZGVTZWxlY3Rvcik7XG4gIGZvciAobGV0IGkgPSAwOyBpIDwgZXhjbHVzaW9ucy5sZW5ndGg7IGkrKykge1xuICAgIGV4Y2x1c2lvbnNbaV0ucmVtb3ZlKCk7XG4gIH1cbiAgcmV0dXJuIChjbG9uZS50ZXh0Q29udGVudCB8fCAnJykudHJpbSgpO1xufVxuIl19