@angular/common 17.0.1 → 17.0.3

package/esm2022/testing/src/navigation/fake_navigation.mjs

@@ -0,0 +1,668 @@
+/**
+ * @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
+ */
+// Prevents deletion of `Event` from `globalThis` during module loading.
+const Event = globalThis.Event;
+/**
+ * Fake implementation of user agent history and navigation behavior. This is a
+ * high-fidelity implementation of browser behavior that attempts to emulate
+ * things like traversal delay.
+ */
+export class FakeNavigation {
+    /** Equivalent to `navigation.currentEntry`. */
+    get currentEntry() {
+        return this.entriesArr[this.currentEntryIndex];
+    }
+    get canGoBack() {
+        return this.currentEntryIndex > 0;
+    }
+    get canGoForward() {
+        return this.currentEntryIndex < this.entriesArr.length - 1;
+    }
+    constructor(window, baseURI) {
+        this.window = window;
+        this.baseURI = baseURI;
+        /**
+         * The fake implementation of an entries array. Only same-document entries
+         * allowed.
+         */
+        this.entriesArr = [];
+        /**
+         * The current active entry index into `entriesArr`.
+         */
+        this.currentEntryIndex = 0;
+        /**
+         * The current navigate event.
+         */
+        this.navigateEvent = undefined;
+        /**
+         * A Map of pending traversals, so that traversals to the same entry can be
+         * re-used.
+         */
+        this.traversalQueue = new Map();
+        /**
+         * A Promise that resolves when the previous traversals have finished. Used to
+         * simulate the cross-process communication necessary for traversals.
+         */
+        this.nextTraversal = Promise.resolve();
+        /**
+         * A prospective current active entry index, which includes unresolved
+         * traversals. Used by `go` to determine where navigations are intended to go.
+         */
+        this.prospectiveEntryIndex = 0;
+        /**
+         * A test-only option to make traversals synchronous, rather than emulate
+         * cross-process communication.
+         */
+        this.synchronousTraversals = false;
+        /** Whether to allow a call to setInitialEntryForTesting. */
+        this.canSetInitialEntry = true;
+        /** `EventTarget` to dispatch events. */
+        this.eventTarget = this.window.document.createElement('div');
+        /** The next unique id for created entries. Replace recreates this id. */
+        this.nextId = 0;
+        /** The next unique key for created entries. Replace inherits this id. */
+        this.nextKey = 0;
+        /** Whether this fake is disposed. */
+        this.disposed = false;
+        // First entry.
+        this.setInitialEntryForTesting('.');
+    }
+    /**
+     * Sets the initial entry.
+     */
+    setInitialEntryForTesting(url, options = { historyState: null }) {
+        if (!this.canSetInitialEntry) {
+            throw new Error('setInitialEntryForTesting can only be called before any ' +
+                'navigation has occurred');
+        }
+        const currentInitialEntry = this.entriesArr[0];
+        this.entriesArr[0] = new FakeNavigationHistoryEntry(options.absoluteUrl ? url : new URL(url, this.baseURI).toString(), {
+            index: 0,
+            key: currentInitialEntry?.key ?? String(this.nextKey++),
+            id: currentInitialEntry?.id ?? String(this.nextId++),
+            sameDocument: true,
+            historyState: options?.historyState,
+            state: options.state,
+        });
+    }
+    /** Returns whether the initial entry is still eligible to be set. */
+    canSetInitialEntryForTesting() {
+        return this.canSetInitialEntry;
+    }
+    /**
+     * Sets whether to emulate traversals as synchronous rather than
+     * asynchronous.
+     */
+    setSynchronousTraversalsForTesting(synchronousTraversals) {
+        this.synchronousTraversals = synchronousTraversals;
+    }
+    /** Equivalent to `navigation.entries()`. */
+    entries() {
+        return this.entriesArr.slice();
+    }
+    /** Equivalent to `navigation.navigate()`. */
+    navigate(url, options) {
+        const fromUrl = new URL(this.currentEntry.url, this.baseURI);
+        const toUrl = new URL(url, this.baseURI);
+        let navigationType;
+        if (!options?.history || options.history === 'auto') {
+            // Auto defaults to push, but if the URLs are the same, is a replace.
+            if (fromUrl.toString() === toUrl.toString()) {
+                navigationType = 'replace';
+            }
+            else {
+                navigationType = 'push';
+            }
+        }
+        else {
+            navigationType = options.history;
+        }
+        const hashChange = isHashChange(fromUrl, toUrl);
+        const destination = new FakeNavigationDestination({
+            url: toUrl.toString(),
+            state: options?.state,
+            sameDocument: hashChange,
+            historyState: null,
+        });
+        const result = new InternalNavigationResult();
+        this.userAgentNavigate(destination, result, {
+            navigationType,
+            cancelable: true,
+            canIntercept: true,
+            // Always false for navigate().
+            userInitiated: false,
+            hashChange,
+            info: options?.info,
+        });
+        return {
+            committed: result.committed,
+            finished: result.finished,
+        };
+    }
+    /** Equivalent to `history.pushState()`. */
+    pushState(data, title, url) {
+        this.pushOrReplaceState('push', data, title, url);
+    }
+    /** Equivalent to `history.replaceState()`. */
+    replaceState(data, title, url) {
+        this.pushOrReplaceState('replace', data, title, url);
+    }
+    pushOrReplaceState(navigationType, data, _title, url) {
+        const fromUrl = new URL(this.currentEntry.url, this.baseURI);
+        const toUrl = url ? new URL(url, this.baseURI) : fromUrl;
+        const hashChange = isHashChange(fromUrl, toUrl);
+        const destination = new FakeNavigationDestination({
+            url: toUrl.toString(),
+            sameDocument: true,
+            historyState: data,
+        });
+        const result = new InternalNavigationResult();
+        this.userAgentNavigate(destination, result, {
+            navigationType,
+            cancelable: true,
+            canIntercept: true,
+            // Always false for pushState() or replaceState().
+            userInitiated: false,
+            hashChange,
+            skipPopState: true,
+        });
+    }
+    /** Equivalent to `navigation.traverseTo()`. */
+    traverseTo(key, options) {
+        const fromUrl = new URL(this.currentEntry.url, this.baseURI);
+        const entry = this.findEntry(key);
+        if (!entry) {
+            const domException = new DOMException('Invalid key', 'InvalidStateError');
+            const committed = Promise.reject(domException);
+            const finished = Promise.reject(domException);
+            committed.catch(() => { });
+            finished.catch(() => { });
+            return {
+                committed,
+                finished,
+            };
+        }
+        if (entry === this.currentEntry) {
+            return {
+                committed: Promise.resolve(this.currentEntry),
+                finished: Promise.resolve(this.currentEntry),
+            };
+        }
+        if (this.traversalQueue.has(entry.key)) {
+            const existingResult = this.traversalQueue.get(entry.key);
+            return {
+                committed: existingResult.committed,
+                finished: existingResult.finished,
+            };
+        }
+        const hashChange = isHashChange(fromUrl, new URL(entry.url, this.baseURI));
+        const destination = new FakeNavigationDestination({
+            url: entry.url,
+            state: entry.getState(),
+            historyState: entry.getHistoryState(),
+            key: entry.key,
+            id: entry.id,
+            index: entry.index,
+            sameDocument: entry.sameDocument,
+        });
+        this.prospectiveEntryIndex = entry.index;
+        const result = new InternalNavigationResult();
+        this.traversalQueue.set(entry.key, result);
+        this.runTraversal(() => {
+            this.traversalQueue.delete(entry.key);
+            this.userAgentNavigate(destination, result, {
+                navigationType: 'traverse',
+                cancelable: true,
+                canIntercept: true,
+                // Always false for traverseTo().
+                userInitiated: false,
+                hashChange,
+                info: options?.info,
+            });
+        });
+        return {
+            committed: result.committed,
+            finished: result.finished,
+        };
+    }
+    /** Equivalent to `navigation.back()`. */
+    back(options) {
+        if (this.currentEntryIndex === 0) {
+            const domException = new DOMException('Cannot go back', 'InvalidStateError');
+            const committed = Promise.reject(domException);
+            const finished = Promise.reject(domException);
+            committed.catch(() => { });
+            finished.catch(() => { });
+            return {
+                committed,
+                finished,
+            };
+        }
+        const entry = this.entriesArr[this.currentEntryIndex - 1];
+        return this.traverseTo(entry.key, options);
+    }
+    /** Equivalent to `navigation.forward()`. */
+    forward(options) {
+        if (this.currentEntryIndex === this.entriesArr.length - 1) {
+            const domException = new DOMException('Cannot go forward', 'InvalidStateError');
+            const committed = Promise.reject(domException);
+            const finished = Promise.reject(domException);
+            committed.catch(() => { });
+            finished.catch(() => { });
+            return {
+                committed,
+                finished,
+            };
+        }
+        const entry = this.entriesArr[this.currentEntryIndex + 1];
+        return this.traverseTo(entry.key, options);
+    }
+    /**
+     * Equivalent to `history.go()`.
+     * Note that this method does not actually work precisely to how Chrome
+     * does, instead choosing a simpler model with less unexpected behavior.
+     * Chrome has a few edge case optimizations, for instance with repeated
+     * `back(); forward()` chains it collapses certain traversals.
+     */
+    go(direction) {
+        const targetIndex = this.prospectiveEntryIndex + direction;
+        if (targetIndex >= this.entriesArr.length || targetIndex < 0) {
+            return;
+        }
+        this.prospectiveEntryIndex = targetIndex;
+        this.runTraversal(() => {
+            // Check again that destination is in the entries array.
+            if (targetIndex >= this.entriesArr.length || targetIndex < 0) {
+                return;
+            }
+            const fromUrl = new URL(this.currentEntry.url, this.baseURI);
+            const entry = this.entriesArr[targetIndex];
+            const hashChange = isHashChange(fromUrl, new URL(entry.url, this.baseURI));
+            const destination = new FakeNavigationDestination({
+                url: entry.url,
+                state: entry.getState(),
+                historyState: entry.getHistoryState(),
+                key: entry.key,
+                id: entry.id,
+                index: entry.index,
+                sameDocument: entry.sameDocument,
+            });
+            const result = new InternalNavigationResult();
+            this.userAgentNavigate(destination, result, {
+                navigationType: 'traverse',
+                cancelable: true,
+                canIntercept: true,
+                // Always false for go().
+                userInitiated: false,
+                hashChange,
+            });
+        });
+    }
+    /** Runs a traversal synchronously or asynchronously */
+    runTraversal(traversal) {
+        if (this.synchronousTraversals) {
+            traversal();
+            return;
+        }
+        // Each traversal occupies a single timeout resolution.
+        // This means that Promises added to commit and finish should resolve
+        // before the next traversal.
+        this.nextTraversal = this.nextTraversal.then(() => {
+            return new Promise((resolve) => {
+                setTimeout(() => {
+                    resolve();
+                    traversal();
+                });
+            });
+        });
+    }
+    /** Equivalent to `navigation.addEventListener()`. */
+    addEventListener(type, callback, options) {
+        this.eventTarget.addEventListener(type, callback, options);
+    }
+    /** Equivalent to `navigation.removeEventListener()`. */
+    removeEventListener(type, callback, options) {
+        this.eventTarget.removeEventListener(type, callback, options);
+    }
+    /** Equivalent to `navigation.dispatchEvent()` */
+    dispatchEvent(event) {
+        return this.eventTarget.dispatchEvent(event);
+    }
+    /** Cleans up resources. */
+    dispose() {
+        // Recreate eventTarget to release current listeners.
+        // `document.createElement` because NodeJS `EventTarget` is incompatible with Domino's `Event`.
+        this.eventTarget = this.window.document.createElement('div');
+        this.disposed = true;
+    }
+    /** Returns whether this fake is disposed. */
+    isDisposed() {
+        return this.disposed;
+    }
+    /** Implementation for all navigations and traversals. */
+    userAgentNavigate(destination, result, options) {
+        // The first navigation should disallow any future calls to set the initial
+        // entry.
+        this.canSetInitialEntry = false;
+        if (this.navigateEvent) {
+            this.navigateEvent.cancel(new DOMException('Navigation was aborted', 'AbortError'));
+            this.navigateEvent = undefined;
+        }
+        const navigateEvent = createFakeNavigateEvent({
+            navigationType: options.navigationType,
+            cancelable: options.cancelable,
+            canIntercept: options.canIntercept,
+            userInitiated: options.userInitiated,
+            hashChange: options.hashChange,
+            signal: result.signal,
+            destination,
+            info: options.info,
+            sameDocument: destination.sameDocument,
+            skipPopState: options.skipPopState,
+            result,
+            userAgentCommit: () => {
+                this.userAgentCommit();
+            },
+        });
+        this.navigateEvent = navigateEvent;
+        this.eventTarget.dispatchEvent(navigateEvent);
+        navigateEvent.dispatchedNavigateEvent();
+        if (navigateEvent.commitOption === 'immediate') {
+            navigateEvent.commit(/* internal= */ true);
+        }
+    }
+    /** Implementation to commit a navigation. */
+    userAgentCommit() {
+        if (!this.navigateEvent) {
+            return;
+        }
+        const from = this.currentEntry;
+        if (!this.navigateEvent.sameDocument) {
+            const error = new Error('Cannot navigate to a non-same-document URL.');
+            this.navigateEvent.cancel(error);
+            throw error;
+        }
+        if (this.navigateEvent.navigationType === 'push' ||
+            this.navigateEvent.navigationType === 'replace') {
+            this.userAgentPushOrReplace(this.navigateEvent.destination, {
+                navigationType: this.navigateEvent.navigationType,
+            });
+        }
+        else if (this.navigateEvent.navigationType === 'traverse') {
+            this.userAgentTraverse(this.navigateEvent.destination);
+        }
+        this.navigateEvent.userAgentNavigated(this.currentEntry);
+        const currentEntryChangeEvent = createFakeNavigationCurrentEntryChangeEvent({ from, navigationType: this.navigateEvent.navigationType });
+        this.eventTarget.dispatchEvent(currentEntryChangeEvent);
+        if (!this.navigateEvent.skipPopState) {
+            const popStateEvent = createPopStateEvent({
+                state: this.navigateEvent.destination.getHistoryState(),
+            });
+            this.window.dispatchEvent(popStateEvent);
+        }
+    }
+    /** Implementation for a push or replace navigation. */
+    userAgentPushOrReplace(destination, { navigationType }) {
+        if (navigationType === 'push') {
+            this.currentEntryIndex++;
+            this.prospectiveEntryIndex = this.currentEntryIndex;
+        }
+        const index = this.currentEntryIndex;
+        const key = navigationType === 'push' ? String(this.nextKey++) : this.currentEntry.key;
+        const entry = new FakeNavigationHistoryEntry(destination.url, {
+            id: String(this.nextId++),
+            key,
+            index,
+            sameDocument: true,
+            state: destination.getState(),
+            historyState: destination.getHistoryState(),
+        });
+        if (navigationType === 'push') {
+            this.entriesArr.splice(index, Infinity, entry);
+        }
+        else {
+            this.entriesArr[index] = entry;
+        }
+    }
+    /** Implementation for a traverse navigation. */
+    userAgentTraverse(destination) {
+        this.currentEntryIndex = destination.index;
+    }
+    /** Utility method for finding entries with the given `key`. */
+    findEntry(key) {
+        for (const entry of this.entriesArr) {
+            if (entry.key === key)
+                return entry;
+        }
+        return undefined;
+    }
+    set onnavigate(_handler) {
+        throw new Error('unimplemented');
+    }
+    get onnavigate() {
+        throw new Error('unimplemented');
+    }
+    set oncurrententrychange(_handler) {
+        throw new Error('unimplemented');
+    }
+    get oncurrententrychange() {
+        throw new Error('unimplemented');
+    }
+    set onnavigatesuccess(_handler) {
+        throw new Error('unimplemented');
+    }
+    get onnavigatesuccess() {
+        throw new Error('unimplemented');
+    }
+    set onnavigateerror(_handler) {
+        throw new Error('unimplemented');
+    }
+    get onnavigateerror() {
+        throw new Error('unimplemented');
+    }
+    get transition() {
+        throw new Error('unimplemented');
+    }
+    updateCurrentEntry(_options) {
+        throw new Error('unimplemented');
+    }
+    reload(_options) {
+        throw new Error('unimplemented');
+    }
+}
+/**
+ * Fake equivalent of `NavigationHistoryEntry`.
+ */
+export class FakeNavigationHistoryEntry {
+    constructor(url, { id, key, index, sameDocument, state, historyState, }) {
+        this.url = url;
+        // tslint:disable-next-line:no-any
+        this.ondispose = null;
+        this.id = id;
+        this.key = key;
+        this.index = index;
+        this.sameDocument = sameDocument;
+        this.state = state;
+        this.historyState = historyState;
+    }
+    getState() {
+        // Budget copy.
+        return this.state ? JSON.parse(JSON.stringify(this.state)) : this.state;
+    }
+    getHistoryState() {
+        // Budget copy.
+        return this.historyState ? JSON.parse(JSON.stringify(this.historyState)) : this.historyState;
+    }
+    addEventListener(type, callback, options) {
+        throw new Error('unimplemented');
+    }
+    removeEventListener(type, callback, options) {
+        throw new Error('unimplemented');
+    }
+    dispatchEvent(event) {
+        throw new Error('unimplemented');
+    }
+}
+/**
+ * Create a fake equivalent of `NavigateEvent`. This is not a class because ES5
+ * transpiled JavaScript cannot extend native Event.
+ */
+function createFakeNavigateEvent({ cancelable, canIntercept, userInitiated, hashChange, navigationType, signal, destination, info, sameDocument, skipPopState, result, userAgentCommit, }) {
+    const event = new Event('navigate', { bubbles: false, cancelable });
+    event.canIntercept = canIntercept;
+    event.userInitiated = userInitiated;
+    event.hashChange = hashChange;
+    event.navigationType = navigationType;
+    event.signal = signal;
+    event.destination = destination;
+    event.info = info;
+    event.downloadRequest = null;
+    event.formData = null;
+    event.sameDocument = sameDocument;
+    event.skipPopState = skipPopState;
+    event.commitOption = 'immediate';
+    let handlerFinished = undefined;
+    let interceptCalled = false;
+    let dispatchedNavigateEvent = false;
+    let commitCalled = false;
+    event.intercept = function (options) {
+        interceptCalled = true;
+        event.sameDocument = true;
+        const handler = options?.handler;
+        if (handler) {
+            handlerFinished = handler();
+        }
+        if (options?.commit) {
+            event.commitOption = options.commit;
+        }
+        if (options?.focusReset !== undefined || options?.scroll !== undefined) {
+            throw new Error('unimplemented');
+        }
+    };
+    event.scroll = function () {
+        throw new Error('unimplemented');
+    };
+    event.commit = function (internal = false) {
+        if (!internal && !interceptCalled) {
+            throw new DOMException(`Failed to execute 'commit' on 'NavigateEvent': intercept() must be ` +
+                `called before commit().`, 'InvalidStateError');
+        }
+        if (!dispatchedNavigateEvent) {
+            throw new DOMException(`Failed to execute 'commit' on 'NavigateEvent': commit() may not be ` +
+                `called during event dispatch.`, 'InvalidStateError');
+        }
+        if (commitCalled) {
+            throw new DOMException(`Failed to execute 'commit' on 'NavigateEvent': commit() already ` +
+                `called.`, 'InvalidStateError');
+        }
+        commitCalled = true;
+        userAgentCommit();
+    };
+    // Internal only.
+    event.cancel = function (reason) {
+        result.committedReject(reason);
+        result.finishedReject(reason);
+    };
+    // Internal only.
+    event.dispatchedNavigateEvent = function () {
+        dispatchedNavigateEvent = true;
+        if (event.commitOption === 'after-transition') {
+            // If handler finishes before commit, call commit.
+            handlerFinished?.then(() => {
+                if (!commitCalled) {
+                    event.commit(/* internal */ true);
+                }
+            }, () => { });
+        }
+        Promise.all([result.committed, handlerFinished])
+            .then(([entry]) => {
+            result.finishedResolve(entry);
+        }, (reason) => {
+            result.finishedReject(reason);
+        });
+    };
+    // Internal only.
+    event.userAgentNavigated = function (entry) {
+        result.committedResolve(entry);
+    };
+    return event;
+}
+/**
+ * Create a fake equivalent of `NavigationCurrentEntryChange`. This does not use
+ * a class because ES5 transpiled JavaScript cannot extend native Event.
+ */
+function createFakeNavigationCurrentEntryChangeEvent({ from, navigationType, }) {
+    const event = new Event('currententrychange', {
+        bubbles: false,
+        cancelable: false,
+    });
+    event.from = from;
+    event.navigationType = navigationType;
+    return event;
+}
+/**
+ * Create a fake equivalent of `PopStateEvent`. This does not use a class
+ * because ES5 transpiled JavaScript cannot extend native Event.
+ */
+function createPopStateEvent({ state }) {
+    const event = new Event('popstate', {
+        bubbles: false,
+        cancelable: false,
+    });
+    event.state = state;
+    return event;
+}
+/**
+ * Fake equivalent of `NavigationDestination`.
+ */
+export class FakeNavigationDestination {
+    constructor({ url, sameDocument, historyState, state, key = null, id = null, index = -1, }) {
+        this.url = url;
+        this.sameDocument = sameDocument;
+        this.state = state;
+        this.historyState = historyState;
+        this.key = key;
+        this.id = id;
+        this.index = index;
+    }
+    getState() {
+        return this.state;
+    }
+    getHistoryState() {
+        return this.historyState;
+    }
+}
+/** Utility function to determine whether two UrlLike have the same hash. */
+function isHashChange(from, to) {
+    return (to.hash !== from.hash && to.hostname === from.hostname && to.pathname === from.pathname &&
+        to.search === from.search);
+}
+/** Internal utility class for representing the result of a navigation.  */
+class InternalNavigationResult {
+    get signal() {
+        return this.abortController.signal;
+    }
+    constructor() {
+        this.abortController = new AbortController();
+        this.committed = new Promise((resolve, reject) => {
+            this.committedResolve = resolve;
+            this.committedReject = reject;
+        });
+        this.finished = new Promise(async (resolve, reject) => {
+            this.finishedResolve = resolve;
+            this.finishedReject = (reason) => {
+                reject(reason);
+                this.abortController.abort(reason);
+            };
+        });
+        // All rejections are handled.
+        this.committed.catch(() => { });
+        this.finished.catch(() => { });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fake_navigation.js","sourceRoot":"","sources":["../../../../../../../../packages/common/testing/src/navigation/fake_navigation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\n// Prevents deletion of `Event` from `globalThis` during module loading.\nconst Event = globalThis.Event;\n\n/**\n * Fake implementation of user agent history and navigation behavior. This is a\n * high-fidelity implementation of browser behavior that attempts to emulate\n * things like traversal delay.\n */\nexport class FakeNavigation implements Navigation {\n  /**\n   * The fake implementation of an entries array. Only same-document entries\n   * allowed.\n   */\n  private readonly entriesArr: FakeNavigationHistoryEntry[] = [];\n\n  /**\n   * The current active entry index into `entriesArr`.\n   */\n  private currentEntryIndex = 0;\n\n  /**\n   * The current navigate event.\n   */\n  private navigateEvent: InternalFakeNavigateEvent|undefined = undefined;\n\n  /**\n   * A Map of pending traversals, so that traversals to the same entry can be\n   * re-used.\n   */\n  private readonly traversalQueue = new Map<string, InternalNavigationResult>();\n\n  /**\n   * A Promise that resolves when the previous traversals have finished. Used to\n   * simulate the cross-process communication necessary for traversals.\n   */\n  private nextTraversal = Promise.resolve();\n\n  /**\n   * A prospective current active entry index, which includes unresolved\n   * traversals. Used by `go` to determine where navigations are intended to go.\n   */\n  private prospectiveEntryIndex = 0;\n\n  /**\n   * A test-only option to make traversals synchronous, rather than emulate\n   * cross-process communication.\n   */\n  private synchronousTraversals = false;\n\n  /** Whether to allow a call to setInitialEntryForTesting. */\n  private canSetInitialEntry = true;\n\n  /** `EventTarget` to dispatch events. */\n  private eventTarget: EventTarget = this.window.document.createElement('div');\n\n  /** The next unique id for created entries. Replace recreates this id. */\n  private nextId = 0;\n\n  /** The next unique key for created entries. Replace inherits this id. */\n  private nextKey = 0;\n\n  /** Whether this fake is disposed. */\n  private disposed = false;\n\n  /** Equivalent to `navigation.currentEntry`. */\n  get currentEntry(): FakeNavigationHistoryEntry {\n    return this.entriesArr[this.currentEntryIndex];\n  }\n\n  get canGoBack(): boolean {\n    return this.currentEntryIndex > 0;\n  }\n\n  get canGoForward(): boolean {\n    return this.currentEntryIndex < this.entriesArr.length - 1;\n  }\n\n  constructor(private readonly window: Window, private readonly baseURI: string) {\n    // First entry.\n    this.setInitialEntryForTesting('.');\n  }\n\n  /**\n   * Sets the initial entry.\n   */\n  setInitialEntryForTesting(\n      url: string,\n      options: {\n        historyState: unknown;\n        // Allows setting the URL without resolving it against the base.\n        absoluteUrl?: boolean;\n        state?: unknown;\n      } = {historyState: null},\n  ) {\n    if (!this.canSetInitialEntry) {\n      throw new Error(\n          'setInitialEntryForTesting can only be called before any ' +\n              'navigation has occurred',\n      );\n    }\n    const currentInitialEntry = this.entriesArr[0];\n    this.entriesArr[0] = new FakeNavigationHistoryEntry(\n        options.absoluteUrl ? url : new URL(url, this.baseURI).toString(),\n        {\n          index: 0,\n          key: currentInitialEntry?.key ?? String(this.nextKey++),\n          id: currentInitialEntry?.id ?? String(this.nextId++),\n          sameDocument: true,\n          historyState: options?.historyState,\n          state: options.state,\n        },\n    );\n  }\n\n  /** Returns whether the initial entry is still eligible to be set. */\n  canSetInitialEntryForTesting(): boolean {\n    return this.canSetInitialEntry;\n  }\n\n  /**\n   * Sets whether to emulate traversals as synchronous rather than\n   * asynchronous.\n   */\n  setSynchronousTraversalsForTesting(synchronousTraversals: boolean) {\n    this.synchronousTraversals = synchronousTraversals;\n  }\n\n  /** Equivalent to `navigation.entries()`. */\n  entries(): FakeNavigationHistoryEntry[] {\n    return this.entriesArr.slice();\n  }\n\n  /** Equivalent to `navigation.navigate()`. */\n  navigate(\n      url: string,\n      options?: NavigationNavigateOptions,\n      ): FakeNavigationResult {\n    const fromUrl = new URL(this.currentEntry.url!, this.baseURI);\n    const toUrl = new URL(url, this.baseURI);\n\n    let navigationType: NavigationTypeString;\n    if (!options?.history || options.history === 'auto') {\n      // Auto defaults to push, but if the URLs are the same, is a replace.\n      if (fromUrl.toString() === toUrl.toString()) {\n        navigationType = 'replace';\n      } else {\n        navigationType = 'push';\n      }\n    } else {\n      navigationType = options.history;\n    }\n\n    const hashChange = isHashChange(fromUrl, toUrl);\n\n    const destination = new FakeNavigationDestination({\n      url: toUrl.toString(),\n      state: options?.state,\n      sameDocument: hashChange,\n      historyState: null,\n    });\n    const result = new InternalNavigationResult();\n\n    this.userAgentNavigate(destination, result, {\n      navigationType,\n      cancelable: true,\n      canIntercept: true,\n      // Always false for navigate().\n      userInitiated: false,\n      hashChange,\n      info: options?.info,\n    });\n\n    return {\n      committed: result.committed,\n      finished: result.finished,\n    };\n  }\n\n  /** Equivalent to `history.pushState()`. */\n  pushState(data: unknown, title: string, url?: string): void {\n    this.pushOrReplaceState('push', data, title, url);\n  }\n\n  /** Equivalent to `history.replaceState()`. */\n  replaceState(data: unknown, title: string, url?: string): void {\n    this.pushOrReplaceState('replace', data, title, url);\n  }\n\n  private pushOrReplaceState(\n      navigationType: NavigationTypeString,\n      data: unknown,\n      _title: string,\n      url?: string,\n      ): void {\n    const fromUrl = new URL(this.currentEntry.url!, this.baseURI);\n    const toUrl = url ? new URL(url, this.baseURI) : fromUrl;\n\n    const hashChange = isHashChange(fromUrl, toUrl);\n\n    const destination = new FakeNavigationDestination({\n      url: toUrl.toString(),\n      sameDocument: true,\n      historyState: data,\n    });\n    const result = new InternalNavigationResult();\n\n    this.userAgentNavigate(destination, result, {\n      navigationType,\n      cancelable: true,\n      canIntercept: true,\n      // Always false for pushState() or replaceState().\n      userInitiated: false,\n      hashChange,\n      skipPopState: true,\n    });\n  }\n\n  /** Equivalent to `navigation.traverseTo()`. */\n  traverseTo(key: string, options?: NavigationOptions): FakeNavigationResult {\n    const fromUrl = new URL(this.currentEntry.url!, this.baseURI);\n    const entry = this.findEntry(key);\n    if (!entry) {\n      const domException = new DOMException(\n          'Invalid key',\n          'InvalidStateError',\n      );\n      const committed = Promise.reject(domException);\n      const finished = Promise.reject(domException);\n      committed.catch(() => {});\n      finished.catch(() => {});\n      return {\n        committed,\n        finished,\n      };\n    }\n    if (entry === this.currentEntry) {\n      return {\n        committed: Promise.resolve(this.currentEntry),\n        finished: Promise.resolve(this.currentEntry),\n      };\n    }\n    if (this.traversalQueue.has(entry.key)) {\n      const existingResult = this.traversalQueue.get(entry.key)!;\n      return {\n        committed: existingResult.committed,\n        finished: existingResult.finished,\n      };\n    }\n\n    const hashChange = isHashChange(fromUrl, new URL(entry.url!, this.baseURI));\n    const destination = new FakeNavigationDestination({\n      url: entry.url!,\n      state: entry.getState(),\n      historyState: entry.getHistoryState(),\n      key: entry.key,\n      id: entry.id,\n      index: entry.index,\n      sameDocument: entry.sameDocument,\n    });\n    this.prospectiveEntryIndex = entry.index;\n    const result = new InternalNavigationResult();\n    this.traversalQueue.set(entry.key, result);\n    this.runTraversal(() => {\n      this.traversalQueue.delete(entry.key);\n      this.userAgentNavigate(destination, result, {\n        navigationType: 'traverse',\n        cancelable: true,\n        canIntercept: true,\n        // Always false for traverseTo().\n        userInitiated: false,\n        hashChange,\n        info: options?.info,\n      });\n    });\n    return {\n      committed: result.committed,\n      finished: result.finished,\n    };\n  }\n\n  /** Equivalent to `navigation.back()`. */\n  back(options?: NavigationOptions): FakeNavigationResult {\n    if (this.currentEntryIndex === 0) {\n      const domException = new DOMException(\n          'Cannot go back',\n          'InvalidStateError',\n      );\n      const committed = Promise.reject(domException);\n      const finished = Promise.reject(domException);\n      committed.catch(() => {});\n      finished.catch(() => {});\n      return {\n        committed,\n        finished,\n      };\n    }\n    const entry = this.entriesArr[this.currentEntryIndex - 1];\n    return this.traverseTo(entry.key, options);\n  }\n\n  /** Equivalent to `navigation.forward()`. */\n  forward(options?: NavigationOptions): FakeNavigationResult {\n    if (this.currentEntryIndex === this.entriesArr.length - 1) {\n      const domException = new DOMException(\n          'Cannot go forward',\n          'InvalidStateError',\n      );\n      const committed = Promise.reject(domException);\n      const finished = Promise.reject(domException);\n      committed.catch(() => {});\n      finished.catch(() => {});\n      return {\n        committed,\n        finished,\n      };\n    }\n    const entry = this.entriesArr[this.currentEntryIndex + 1];\n    return this.traverseTo(entry.key, options);\n  }\n\n  /**\n   * Equivalent to `history.go()`.\n   * Note that this method does not actually work precisely to how Chrome\n   * does, instead choosing a simpler model with less unexpected behavior.\n   * Chrome has a few edge case optimizations, for instance with repeated\n   * `back(); forward()` chains it collapses certain traversals.\n   */\n  go(direction: number): void {\n    const targetIndex = this.prospectiveEntryIndex + direction;\n    if (targetIndex >= this.entriesArr.length || targetIndex < 0) {\n      return;\n    }\n    this.prospectiveEntryIndex = targetIndex;\n    this.runTraversal(() => {\n      // Check again that destination is in the entries array.\n      if (targetIndex >= this.entriesArr.length || targetIndex < 0) {\n        return;\n      }\n      const fromUrl = new URL(this.currentEntry.url!, this.baseURI);\n      const entry = this.entriesArr[targetIndex];\n      const hashChange = isHashChange(fromUrl, new URL(entry.url!, this.baseURI));\n      const destination = new FakeNavigationDestination({\n        url: entry.url!,\n        state: entry.getState(),\n        historyState: entry.getHistoryState(),\n        key: entry.key,\n        id: entry.id,\n        index: entry.index,\n        sameDocument: entry.sameDocument,\n      });\n      const result = new InternalNavigationResult();\n      this.userAgentNavigate(destination, result, {\n        navigationType: 'traverse',\n        cancelable: true,\n        canIntercept: true,\n        // Always false for go().\n        userInitiated: false,\n        hashChange,\n      });\n    });\n  }\n\n  /** Runs a traversal synchronously or asynchronously */\n  private runTraversal(traversal: () => void) {\n    if (this.synchronousTraversals) {\n      traversal();\n      return;\n    }\n\n    // Each traversal occupies a single timeout resolution.\n    // This means that Promises added to commit and finish should resolve\n    // before the next traversal.\n    this.nextTraversal = this.nextTraversal.then(() => {\n      return new Promise<void>((resolve) => {\n        setTimeout(() => {\n          resolve();\n          traversal();\n        });\n      });\n    });\n  }\n\n  /** Equivalent to `navigation.addEventListener()`. */\n  addEventListener(\n      type: string,\n      callback: EventListenerOrEventListenerObject,\n      options?: AddEventListenerOptions|boolean,\n  ) {\n    this.eventTarget.addEventListener(type, callback, options);\n  }\n\n  /** Equivalent to `navigation.removeEventListener()`. */\n  removeEventListener(\n      type: string,\n      callback: EventListenerOrEventListenerObject,\n      options?: EventListenerOptions|boolean,\n  ) {\n    this.eventTarget.removeEventListener(type, callback, options);\n  }\n\n  /** Equivalent to `navigation.dispatchEvent()` */\n  dispatchEvent(event: Event): boolean {\n    return this.eventTarget.dispatchEvent(event);\n  }\n\n  /** Cleans up resources. */\n  dispose() {\n    // Recreate eventTarget to release current listeners.\n    // `document.createElement` because NodeJS `EventTarget` is incompatible with Domino's `Event`.\n    this.eventTarget = this.window.document.createElement('div');\n    this.disposed = true;\n  }\n\n  /** Returns whether this fake is disposed. */\n  isDisposed() {\n    return this.disposed;\n  }\n\n  /** Implementation for all navigations and traversals. */\n  private userAgentNavigate(\n      destination: FakeNavigationDestination,\n      result: InternalNavigationResult,\n      options: InternalNavigateOptions,\n  ) {\n    // The first navigation should disallow any future calls to set the initial\n    // entry.\n    this.canSetInitialEntry = false;\n    if (this.navigateEvent) {\n      this.navigateEvent.cancel(\n          new DOMException('Navigation was aborted', 'AbortError'),\n      );\n      this.navigateEvent = undefined;\n    }\n\n    const navigateEvent = createFakeNavigateEvent({\n      navigationType: options.navigationType,\n      cancelable: options.cancelable,\n      canIntercept: options.canIntercept,\n      userInitiated: options.userInitiated,\n      hashChange: options.hashChange,\n      signal: result.signal,\n      destination,\n      info: options.info,\n      sameDocument: destination.sameDocument,\n      skipPopState: options.skipPopState,\n      result,\n      userAgentCommit: () => {\n        this.userAgentCommit();\n      },\n    });\n\n    this.navigateEvent = navigateEvent;\n    this.eventTarget.dispatchEvent(navigateEvent);\n    navigateEvent.dispatchedNavigateEvent();\n    if (navigateEvent.commitOption === 'immediate') {\n      navigateEvent.commit(/* internal= */ true);\n    }\n  }\n\n  /** Implementation to commit a navigation. */\n  private userAgentCommit() {\n    if (!this.navigateEvent) {\n      return;\n    }\n    const from = this.currentEntry;\n    if (!this.navigateEvent.sameDocument) {\n      const error = new Error('Cannot navigate to a non-same-document URL.');\n      this.navigateEvent.cancel(error);\n      throw error;\n    }\n    if (this.navigateEvent.navigationType === 'push' ||\n        this.navigateEvent.navigationType === 'replace') {\n      this.userAgentPushOrReplace(this.navigateEvent.destination, {\n        navigationType: this.navigateEvent.navigationType,\n      });\n    } else if (this.navigateEvent.navigationType === 'traverse') {\n      this.userAgentTraverse(this.navigateEvent.destination);\n    }\n    this.navigateEvent.userAgentNavigated(this.currentEntry);\n    const currentEntryChangeEvent = createFakeNavigationCurrentEntryChangeEvent(\n        {from, navigationType: this.navigateEvent.navigationType},\n    );\n    this.eventTarget.dispatchEvent(currentEntryChangeEvent);\n    if (!this.navigateEvent.skipPopState) {\n      const popStateEvent = createPopStateEvent({\n        state: this.navigateEvent.destination.getHistoryState(),\n      });\n      this.window.dispatchEvent(popStateEvent);\n    }\n  }\n\n  /** Implementation for a push or replace navigation. */\n  private userAgentPushOrReplace(\n      destination: FakeNavigationDestination,\n      {navigationType}: {navigationType: NavigationTypeString},\n  ) {\n    if (navigationType === 'push') {\n      this.currentEntryIndex++;\n      this.prospectiveEntryIndex = this.currentEntryIndex;\n    }\n    const index = this.currentEntryIndex;\n    const key = navigationType === 'push' ? String(this.nextKey++) : this.currentEntry.key;\n    const entry = new FakeNavigationHistoryEntry(destination.url, {\n      id: String(this.nextId++),\n      key,\n      index,\n      sameDocument: true,\n      state: destination.getState(),\n      historyState: destination.getHistoryState(),\n    });\n    if (navigationType === 'push') {\n      this.entriesArr.splice(index, Infinity, entry);\n    } else {\n      this.entriesArr[index] = entry;\n    }\n  }\n\n  /** Implementation for a traverse navigation. */\n  private userAgentTraverse(destination: FakeNavigationDestination) {\n    this.currentEntryIndex = destination.index;\n  }\n\n  /** Utility method for finding entries with the given `key`. */\n  private findEntry(key: string) {\n    for (const entry of this.entriesArr) {\n      if (entry.key === key) return entry;\n    }\n    return undefined;\n  }\n\n  set onnavigate(_handler: ((this: Navigation, ev: NavigateEvent) => any)|null) {\n    throw new Error('unimplemented');\n  }\n\n  get onnavigate(): ((this: Navigation, ev: NavigateEvent) => any)|null {\n    throw new Error('unimplemented');\n  }\n\n  set oncurrententrychange(_handler:\n                               ((this: Navigation, ev: NavigationCurrentEntryChangeEvent) => any)|\n                           null) {\n    throw new Error('unimplemented');\n  }\n\n  get oncurrententrychange():\n      ((this: Navigation, ev: NavigationCurrentEntryChangeEvent) => any)|null {\n    throw new Error('unimplemented');\n  }\n\n  set onnavigatesuccess(_handler: ((this: Navigation, ev: Event) => any)|null) {\n    throw new Error('unimplemented');\n  }\n\n  get onnavigatesuccess(): ((this: Navigation, ev: Event) => any)|null {\n    throw new Error('unimplemented');\n  }\n\n  set onnavigateerror(_handler: ((this: Navigation, ev: ErrorEvent) => any)|null) {\n    throw new Error('unimplemented');\n  }\n\n  get onnavigateerror(): ((this: Navigation, ev: ErrorEvent) => any)|null {\n    throw new Error('unimplemented');\n  }\n\n  get transition(): NavigationTransition|null {\n    throw new Error('unimplemented');\n  }\n\n  updateCurrentEntry(_options: NavigationUpdateCurrentEntryOptions): void {\n    throw new Error('unimplemented');\n  }\n\n  reload(_options?: NavigationReloadOptions): NavigationResult {\n    throw new Error('unimplemented');\n  }\n}\n\n/**\n * Fake equivalent of the `NavigationResult` interface with\n * `FakeNavigationHistoryEntry`.\n */\ninterface FakeNavigationResult extends NavigationResult {\n  readonly committed: Promise<FakeNavigationHistoryEntry>;\n  readonly finished: Promise<FakeNavigationHistoryEntry>;\n}\n\n/**\n * Fake equivalent of `NavigationHistoryEntry`.\n */\nexport class FakeNavigationHistoryEntry implements NavigationHistoryEntry {\n  readonly sameDocument;\n\n  readonly id: string;\n  readonly key: string;\n  readonly index: number;\n  private readonly state: unknown;\n  private readonly historyState: unknown;\n\n  // tslint:disable-next-line:no-any\n  ondispose: ((this: NavigationHistoryEntry, ev: Event) => any)|null = null;\n\n  constructor(\n      readonly url: string|null,\n      {\n        id,\n        key,\n        index,\n        sameDocument,\n        state,\n        historyState,\n      }: {\n        id: string; key: string; index: number; sameDocument: boolean; historyState: unknown;\n        state?: unknown;\n      },\n  ) {\n    this.id = id;\n    this.key = key;\n    this.index = index;\n    this.sameDocument = sameDocument;\n    this.state = state;\n    this.historyState = historyState;\n  }\n\n  getState(): unknown {\n    // Budget copy.\n    return this.state ? JSON.parse(JSON.stringify(this.state)) : this.state;\n  }\n\n  getHistoryState(): unknown {\n    // Budget copy.\n    return this.historyState ? JSON.parse(JSON.stringify(this.historyState)) : this.historyState;\n  }\n\n  addEventListener(\n      type: string,\n      callback: EventListenerOrEventListenerObject,\n      options?: AddEventListenerOptions|boolean,\n  ) {\n    throw new Error('unimplemented');\n  }\n\n  removeEventListener(\n      type: string,\n      callback: EventListenerOrEventListenerObject,\n      options?: EventListenerOptions|boolean,\n  ) {\n    throw new Error('unimplemented');\n  }\n\n  dispatchEvent(event: Event): boolean {\n    throw new Error('unimplemented');\n  }\n}\n\n/** `NavigationInterceptOptions` with experimental commit option. */\nexport interface ExperimentalNavigationInterceptOptions extends NavigationInterceptOptions {\n  commit?: 'immediate'|'after-transition';\n}\n\n/** `NavigateEvent` with experimental commit function. */\nexport interface ExperimentalNavigateEvent extends NavigateEvent {\n  intercept(options?: ExperimentalNavigationInterceptOptions): void;\n\n  commit(): void;\n}\n\n/**\n * Fake equivalent of `NavigateEvent`.\n */\nexport interface FakeNavigateEvent extends ExperimentalNavigateEvent {\n  readonly destination: FakeNavigationDestination;\n}\n\ninterface InternalFakeNavigateEvent extends FakeNavigateEvent {\n  readonly sameDocument: boolean;\n  readonly skipPopState?: boolean;\n  readonly commitOption: 'after-transition'|'immediate';\n  readonly result: InternalNavigationResult;\n\n  commit(internal?: boolean): void;\n  cancel(reason: Error): void;\n  dispatchedNavigateEvent(): void;\n  userAgentNavigated(entry: FakeNavigationHistoryEntry): void;\n}\n\n/**\n * Create a fake equivalent of `NavigateEvent`. This is not a class because ES5\n * transpiled JavaScript cannot extend native Event.\n */\nfunction createFakeNavigateEvent({\n  cancelable,\n  canIntercept,\n  userInitiated,\n  hashChange,\n  navigationType,\n  signal,\n  destination,\n  info,\n  sameDocument,\n  skipPopState,\n  result,\n  userAgentCommit,\n}: {\n  cancelable: boolean; canIntercept: boolean; userInitiated: boolean; hashChange: boolean;\n  navigationType: NavigationTypeString;\n  signal: AbortSignal;\n  destination: FakeNavigationDestination;\n  info: unknown;\n  sameDocument: boolean;\n  skipPopState?: boolean; result: InternalNavigationResult; userAgentCommit: () => void;\n}) {\n  const event = new Event('navigate', {bubbles: false, cancelable}) as {\n    -readonly[P in keyof InternalFakeNavigateEvent]: InternalFakeNavigateEvent[P];\n  };\n  event.canIntercept = canIntercept;\n  event.userInitiated = userInitiated;\n  event.hashChange = hashChange;\n  event.navigationType = navigationType;\n  event.signal = signal;\n  event.destination = destination;\n  event.info = info;\n  event.downloadRequest = null;\n  event.formData = null;\n\n  event.sameDocument = sameDocument;\n  event.skipPopState = skipPopState;\n  event.commitOption = 'immediate';\n\n  let handlerFinished: Promise<void>|undefined = undefined;\n  let interceptCalled = false;\n  let dispatchedNavigateEvent = false;\n  let commitCalled = false;\n\n  event.intercept = function(\n      this: InternalFakeNavigateEvent,\n      options?: ExperimentalNavigationInterceptOptions,\n      ): void {\n    interceptCalled = true;\n    event.sameDocument = true;\n    const handler = options?.handler;\n    if (handler) {\n      handlerFinished = handler();\n    }\n    if (options?.commit) {\n      event.commitOption = options.commit;\n    }\n    if (options?.focusReset !== undefined || options?.scroll !== undefined) {\n      throw new Error('unimplemented');\n    }\n  };\n\n  event.scroll = function(this: InternalFakeNavigateEvent): void {\n    throw new Error('unimplemented');\n  };\n\n  event.commit = function(this: InternalFakeNavigateEvent, internal = false) {\n    if (!internal && !interceptCalled) {\n      throw new DOMException(\n          `Failed to execute 'commit' on 'NavigateEvent': intercept() must be ` +\n              `called before commit().`,\n          'InvalidStateError',\n      );\n    }\n    if (!dispatchedNavigateEvent) {\n      throw new DOMException(\n          `Failed to execute 'commit' on 'NavigateEvent': commit() may not be ` +\n              `called during event dispatch.`,\n          'InvalidStateError',\n      );\n    }\n    if (commitCalled) {\n      throw new DOMException(\n          `Failed to execute 'commit' on 'NavigateEvent': commit() already ` +\n              `called.`,\n          'InvalidStateError',\n      );\n    }\n    commitCalled = true;\n\n    userAgentCommit();\n  };\n\n  // Internal only.\n  event.cancel = function(this: InternalFakeNavigateEvent, reason: Error) {\n    result.committedReject(reason);\n    result.finishedReject(reason);\n  };\n\n  // Internal only.\n  event.dispatchedNavigateEvent = function(this: InternalFakeNavigateEvent) {\n    dispatchedNavigateEvent = true;\n    if (event.commitOption === 'after-transition') {\n      // If handler finishes before commit, call commit.\n      handlerFinished?.then(\n          () => {\n            if (!commitCalled) {\n              event.commit(/* internal */ true);\n            }\n          },\n          () => {},\n      );\n    }\n    Promise.all([result.committed, handlerFinished])\n        .then(\n            ([entry]) => {\n              result.finishedResolve(entry);\n            },\n            (reason) => {\n              result.finishedReject(reason);\n            },\n        );\n  };\n\n  // Internal only.\n  event.userAgentNavigated = function(\n      this: InternalFakeNavigateEvent,\n      entry: FakeNavigationHistoryEntry,\n  ) {\n    result.committedResolve(entry);\n  };\n\n  return event as InternalFakeNavigateEvent;\n}\n\n/** Fake equivalent of `NavigationCurrentEntryChangeEvent`. */\nexport interface FakeNavigationCurrentEntryChangeEvent extends NavigationCurrentEntryChangeEvent {\n  readonly from: FakeNavigationHistoryEntry;\n}\n\n/**\n * Create a fake equivalent of `NavigationCurrentEntryChange`. This does not use\n * a class because ES5 transpiled JavaScript cannot extend native Event.\n */\nfunction createFakeNavigationCurrentEntryChangeEvent({\n  from,\n  navigationType,\n}: {from: FakeNavigationHistoryEntry; navigationType: NavigationTypeString;}) {\n  const event = new Event('currententrychange', {\n                  bubbles: false,\n                  cancelable: false,\n                }) as {\n    -readonly[P in keyof NavigationCurrentEntryChangeEvent]: NavigationCurrentEntryChangeEvent[P];\n  };\n  event.from = from;\n  event.navigationType = navigationType;\n  return event as FakeNavigationCurrentEntryChangeEvent;\n}\n\n/**\n * Create a fake equivalent of `PopStateEvent`. This does not use a class\n * because ES5 transpiled JavaScript cannot extend native Event.\n */\nfunction createPopStateEvent({state}: {state: unknown}) {\n  const event = new Event('popstate', {\n                  bubbles: false,\n                  cancelable: false,\n                }) as {-readonly[P in keyof PopStateEvent]: PopStateEvent[P]};\n  event.state = state;\n  return event as PopStateEvent;\n}\n\n/**\n * Fake equivalent of `NavigationDestination`.\n */\nexport class FakeNavigationDestination implements NavigationDestination {\n  readonly url: string;\n  readonly sameDocument: boolean;\n  readonly key: string|null;\n  readonly id: string|null;\n  readonly index: number;\n\n  private readonly state?: unknown;\n  private readonly historyState: unknown;\n\n  constructor({\n    url,\n    sameDocument,\n    historyState,\n    state,\n    key = null,\n    id = null,\n    index = -1,\n  }: {\n    url: string; sameDocument: boolean; historyState: unknown;\n    state?: unknown;\n    key?: string | null;\n    id?: string | null;\n    index?: number;\n  }) {\n    this.url = url;\n    this.sameDocument = sameDocument;\n    this.state = state;\n    this.historyState = historyState;\n    this.key = key;\n    this.id = id;\n    this.index = index;\n  }\n\n  getState(): unknown {\n    return this.state;\n  }\n\n  getHistoryState(): unknown {\n    return this.historyState;\n  }\n}\n\n/** Utility function to determine whether two UrlLike have the same hash. */\nfunction isHashChange(from: URL, to: URL): boolean {\n  return (\n      to.hash !== from.hash && to.hostname === from.hostname && to.pathname === from.pathname &&\n      to.search === from.search);\n}\n\n/** Internal utility class for representing the result of a navigation.  */\nclass InternalNavigationResult {\n  committedResolve!: (entry: FakeNavigationHistoryEntry) => void;\n  committedReject!: (reason: Error) => void;\n  finishedResolve!: (entry: FakeNavigationHistoryEntry) => void;\n  finishedReject!: (reason: Error) => void;\n  readonly committed: Promise<FakeNavigationHistoryEntry>;\n  readonly finished: Promise<FakeNavigationHistoryEntry>;\n  get signal(): AbortSignal {\n    return this.abortController.signal;\n  }\n  private readonly abortController = new AbortController();\n\n  constructor() {\n    this.committed = new Promise<FakeNavigationHistoryEntry>(\n        (resolve, reject) => {\n          this.committedResolve = resolve;\n          this.committedReject = reject;\n        },\n    );\n\n    this.finished = new Promise<FakeNavigationHistoryEntry>(\n        async (resolve, reject) => {\n          this.finishedResolve = resolve;\n          this.finishedReject = (reason: Error) => {\n            reject(reason);\n            this.abortController.abort(reason);\n          };\n        },\n    );\n    // All rejections are handled.\n    this.committed.catch(() => {});\n    this.finished.catch(() => {});\n  }\n}\n\n/** Internal options for performing a navigate. */\ninterface InternalNavigateOptions {\n  navigationType: NavigationTypeString;\n  cancelable: boolean;\n  canIntercept: boolean;\n  userInitiated: boolean;\n  hashChange: boolean;\n  info?: unknown;\n  skipPopState?: boolean;\n}\n"]}