Add progressive web app companion for cross-platform access

Vite + TypeScript PWA that mirrors the Android app's core features:
- Pre-processed shelter data (build-time UTM33N→WGS84 conversion)
- Leaflet map with shelter markers, user location, and offline tiles
- Canvas compass arrow (ported from DirectionArrowView.kt)
- IndexedDB shelter cache with 7-day staleness check
- Service worker with CacheFirst tiles and precached app shell
- i18n for en, nb, nn (ported from Android strings.xml)
- iOS/Android compass handling with low-pass filter
- Respects user map interaction (no auto-snap on pan/zoom)
- Build revision cache-breaker for reliable SW updates

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

pwa/node_modules/workbox-background-sync/BackgroundSyncPlugin.d.ts

@@ -0,0 +1,27 @@
+import { WorkboxPlugin } from 'workbox-core/types.js';
+import { QueueOptions } from './Queue.js';
+import './_version.js';
+/**
+ * A class implementing the `fetchDidFail` lifecycle callback. This makes it
+ * easier to add failed requests to a background sync Queue.
+ *
+ * @memberof workbox-background-sync
+ */
+declare class BackgroundSyncPlugin implements WorkboxPlugin {
+    private readonly _queue;
+    /**
+     * @param {string} name See the {@link workbox-background-sync.Queue}
+     *     documentation for parameter details.
+     * @param {Object} [options] See the
+     *     {@link workbox-background-sync.Queue} documentation for
+     *     parameter details.
+     */
+    constructor(name: string, options?: QueueOptions);
+    /**
+     * @param {Object} options
+     * @param {Request} options.request
+     * @private
+     */
+    fetchDidFail: WorkboxPlugin['fetchDidFail'];
+}
+export { BackgroundSyncPlugin };

pwa/node_modules/workbox-background-sync/BackgroundSyncPlugin.js

@@ -0,0 +1,36 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+import { Queue } from './Queue.js';
+import './_version.js';
+/**
+ * A class implementing the `fetchDidFail` lifecycle callback. This makes it
+ * easier to add failed requests to a background sync Queue.
+ *
+ * @memberof workbox-background-sync
+ */
+class BackgroundSyncPlugin {
+    /**
+     * @param {string} name See the {@link workbox-background-sync.Queue}
+     *     documentation for parameter details.
+     * @param {Object} [options] See the
+     *     {@link workbox-background-sync.Queue} documentation for
+     *     parameter details.
+     */
+    constructor(name, options) {
+        /**
+         * @param {Object} options
+         * @param {Request} options.request
+         * @private
+         */
+        this.fetchDidFail = async ({ request }) => {
+            await this._queue.pushRequest({ request });
+        };
+        this._queue = new Queue(name, options);
+    }
+}
+export { BackgroundSyncPlugin };

pwa/node_modules/workbox-background-sync/BackgroundSyncPlugin.mjs

@@ -0,0 +1 @@
+export * from './BackgroundSyncPlugin.js';

pwa/node_modules/workbox-background-sync/LICENSE

@@ -0,0 +1,19 @@
+Copyright 2018 Google LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

pwa/node_modules/workbox-background-sync/Queue.d.ts

@@ -0,0 +1,175 @@
+import './_version.js';
+interface OnSyncCallbackOptions {
+    queue: Queue;
+}
+interface OnSyncCallback {
+    (options: OnSyncCallbackOptions): void | Promise<void>;
+}
+export interface QueueOptions {
+    forceSyncFallback?: boolean;
+    maxRetentionTime?: number;
+    onSync?: OnSyncCallback;
+}
+interface QueueEntry {
+    request: Request;
+    timestamp?: number;
+    metadata?: object;
+}
+/**
+ * A class to manage storing failed requests in IndexedDB and retrying them
+ * later. All parts of the storing and replaying process are observable via
+ * callbacks.
+ *
+ * @memberof workbox-background-sync
+ */
+declare class Queue {
+    private readonly _name;
+    private readonly _onSync;
+    private readonly _maxRetentionTime;
+    private readonly _queueStore;
+    private readonly _forceSyncFallback;
+    private _syncInProgress;
+    private _requestsAddedDuringSync;
+    /**
+     * Creates an instance of Queue with the given options
+     *
+     * @param {string} name The unique name for this queue. This name must be
+     *     unique as it's used to register sync events and store requests
+     *     in IndexedDB specific to this instance. An error will be thrown if
+     *     a duplicate name is detected.
+     * @param {Object} [options]
+     * @param {Function} [options.onSync] A function that gets invoked whenever
+     *     the 'sync' event fires. The function is invoked with an object
+     *     containing the `queue` property (referencing this instance), and you
+     *     can use the callback to customize the replay behavior of the queue.
+     *     When not set the `replayRequests()` method is called.
+     *     Note: if the replay fails after a sync event, make sure you throw an
+     *     error, so the browser knows to retry the sync event later.
+     * @param {number} [options.maxRetentionTime=7 days] The amount of time (in
+     *     minutes) a request may be retried. After this amount of time has
+     *     passed, the request will be deleted from the queue.
+     * @param {boolean} [options.forceSyncFallback=false] If `true`, instead
+     *     of attempting to use background sync events, always attempt to replay
+     *     queued request at service worker startup. Most folks will not need
+     *     this, unless you explicitly target a runtime like Electron that
+     *     exposes the interfaces for background sync, but does not have a working
+     *     implementation.
+     */
+    constructor(name: string, { forceSyncFallback, onSync, maxRetentionTime }?: QueueOptions);
+    /**
+     * @return {string}
+     */
+    get name(): string;
+    /**
+     * Stores the passed request in IndexedDB (with its timestamp and any
+     * metadata) at the end of the queue.
+     *
+     * @param {QueueEntry} entry
+     * @param {Request} entry.request The request to store in the queue.
+     * @param {Object} [entry.metadata] Any metadata you want associated with the
+     *     stored request. When requests are replayed you'll have access to this
+     *     metadata object in case you need to modify the request beforehand.
+     * @param {number} [entry.timestamp] The timestamp (Epoch time in
+     *     milliseconds) when the request was first added to the queue. This is
+     *     used along with `maxRetentionTime` to remove outdated requests. In
+     *     general you don't need to set this value, as it's automatically set
+     *     for you (defaulting to `Date.now()`), but you can update it if you
+     *     don't want particular requests to expire.
+     */
+    pushRequest(entry: QueueEntry): Promise<void>;
+    /**
+     * Stores the passed request in IndexedDB (with its timestamp and any
+     * metadata) at the beginning of the queue.
+     *
+     * @param {QueueEntry} entry
+     * @param {Request} entry.request The request to store in the queue.
+     * @param {Object} [entry.metadata] Any metadata you want associated with the
+     *     stored request. When requests are replayed you'll have access to this
+     *     metadata object in case you need to modify the request beforehand.
+     * @param {number} [entry.timestamp] The timestamp (Epoch time in
+     *     milliseconds) when the request was first added to the queue. This is
+     *     used along with `maxRetentionTime` to remove outdated requests. In
+     *     general you don't need to set this value, as it's automatically set
+     *     for you (defaulting to `Date.now()`), but you can update it if you
+     *     don't want particular requests to expire.
+     */
+    unshiftRequest(entry: QueueEntry): Promise<void>;
+    /**
+     * Removes and returns the last request in the queue (along with its
+     * timestamp and any metadata). The returned object takes the form:
+     * `{request, timestamp, metadata}`.
+     *
+     * @return {Promise<QueueEntry | undefined>}
+     */
+    popRequest(): Promise<QueueEntry | undefined>;
+    /**
+     * Removes and returns the first request in the queue (along with its
+     * timestamp and any metadata). The returned object takes the form:
+     * `{request, timestamp, metadata}`.
+     *
+     * @return {Promise<QueueEntry | undefined>}
+     */
+    shiftRequest(): Promise<QueueEntry | undefined>;
+    /**
+     * Returns all the entries that have not expired (per `maxRetentionTime`).
+     * Any expired entries are removed from the queue.
+     *
+     * @return {Promise<Array<QueueEntry>>}
+     */
+    getAll(): Promise<Array<QueueEntry>>;
+    /**
+     * Returns the number of entries present in the queue.
+     * Note that expired entries (per `maxRetentionTime`) are also included in this count.
+     *
+     * @return {Promise<number>}
+     */
+    size(): Promise<number>;
+    /**
+     * Adds the entry to the QueueStore and registers for a sync event.
+     *
+     * @param {Object} entry
+     * @param {Request} entry.request
+     * @param {Object} [entry.metadata]
+     * @param {number} [entry.timestamp=Date.now()]
+     * @param {string} operation ('push' or 'unshift')
+     * @private
+     */
+    _addRequest({ request, metadata, timestamp }: QueueEntry, operation: 'push' | 'unshift'): Promise<void>;
+    /**
+     * Removes and returns the first or last (depending on `operation`) entry
+     * from the QueueStore that's not older than the `maxRetentionTime`.
+     *
+     * @param {string} operation ('pop' or 'shift')
+     * @return {Object|undefined}
+     * @private
+     */
+    _removeRequest(operation: 'pop' | 'shift'): Promise<QueueEntry | undefined>;
+    /**
+     * Loops through each request in the queue and attempts to re-fetch it.
+     * If any request fails to re-fetch, it's put back in the same position in
+     * the queue (which registers a retry for the next sync event).
+     */
+    replayRequests(): Promise<void>;
+    /**
+     * Registers a sync event with a tag unique to this instance.
+     */
+    registerSync(): Promise<void>;
+    /**
+     * In sync-supporting browsers, this adds a listener for the sync event.
+     * In non-sync-supporting browsers, or if _forceSyncFallback is true, this
+     * will retry the queue on service worker startup.
+     *
+     * @private
+     */
+    private _addSyncListener;
+    /**
+     * Returns the set of queue names. This is primarily used to reset the list
+     * of queue names in tests.
+     *
+     * @return {Set<string>}
+     *
+     * @private
+     */
+    static get _queueNames(): Set<string>;
+}
+export { Queue };

pwa/node_modules/workbox-background-sync/Queue.js

@@ -0,0 +1,401 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+import { WorkboxError } from 'workbox-core/_private/WorkboxError.js';
+import { logger } from 'workbox-core/_private/logger.js';
+import { assert } from 'workbox-core/_private/assert.js';
+import { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';
+import { QueueStore } from './lib/QueueStore.js';
+import { StorableRequest } from './lib/StorableRequest.js';
+import './_version.js';
+const TAG_PREFIX = 'workbox-background-sync';
+const MAX_RETENTION_TIME = 60 * 24 * 7; // 7 days in minutes
+const queueNames = new Set();
+/**
+ * Converts a QueueStore entry into the format exposed by Queue. This entails
+ * converting the request data into a real request and omitting the `id` and
+ * `queueName` properties.
+ *
+ * @param {UnidentifiedQueueStoreEntry} queueStoreEntry
+ * @return {Queue}
+ * @private
+ */
+const convertEntry = (queueStoreEntry) => {
+    const queueEntry = {
+        request: new StorableRequest(queueStoreEntry.requestData).toRequest(),
+        timestamp: queueStoreEntry.timestamp,
+    };
+    if (queueStoreEntry.metadata) {
+        queueEntry.metadata = queueStoreEntry.metadata;
+    }
+    return queueEntry;
+};
+/**
+ * A class to manage storing failed requests in IndexedDB and retrying them
+ * later. All parts of the storing and replaying process are observable via
+ * callbacks.
+ *
+ * @memberof workbox-background-sync
+ */
+class Queue {
+    /**
+     * Creates an instance of Queue with the given options
+     *
+     * @param {string} name The unique name for this queue. This name must be
+     *     unique as it's used to register sync events and store requests
+     *     in IndexedDB specific to this instance. An error will be thrown if
+     *     a duplicate name is detected.
+     * @param {Object} [options]
+     * @param {Function} [options.onSync] A function that gets invoked whenever
+     *     the 'sync' event fires. The function is invoked with an object
+     *     containing the `queue` property (referencing this instance), and you
+     *     can use the callback to customize the replay behavior of the queue.
+     *     When not set the `replayRequests()` method is called.
+     *     Note: if the replay fails after a sync event, make sure you throw an
+     *     error, so the browser knows to retry the sync event later.
+     * @param {number} [options.maxRetentionTime=7 days] The amount of time (in
+     *     minutes) a request may be retried. After this amount of time has
+     *     passed, the request will be deleted from the queue.
+     * @param {boolean} [options.forceSyncFallback=false] If `true`, instead
+     *     of attempting to use background sync events, always attempt to replay
+     *     queued request at service worker startup. Most folks will not need
+     *     this, unless you explicitly target a runtime like Electron that
+     *     exposes the interfaces for background sync, but does not have a working
+     *     implementation.
+     */
+    constructor(name, { forceSyncFallback, onSync, maxRetentionTime } = {}) {
+        this._syncInProgress = false;
+        this._requestsAddedDuringSync = false;
+        // Ensure the store name is not already being used
+        if (queueNames.has(name)) {
+            throw new WorkboxError('duplicate-queue-name', { name });
+        }
+        else {
+            queueNames.add(name);
+        }
+        this._name = name;
+        this._onSync = onSync || this.replayRequests;
+        this._maxRetentionTime = maxRetentionTime || MAX_RETENTION_TIME;
+        this._forceSyncFallback = Boolean(forceSyncFallback);
+        this._queueStore = new QueueStore(this._name);
+        this._addSyncListener();
+    }
+    /**
+     * @return {string}
+     */
+    get name() {
+        return this._name;
+    }
+    /**
+     * Stores the passed request in IndexedDB (with its timestamp and any
+     * metadata) at the end of the queue.
+     *
+     * @param {QueueEntry} entry
+     * @param {Request} entry.request The request to store in the queue.
+     * @param {Object} [entry.metadata] Any metadata you want associated with the
+     *     stored request. When requests are replayed you'll have access to this
+     *     metadata object in case you need to modify the request beforehand.
+     * @param {number} [entry.timestamp] The timestamp (Epoch time in
+     *     milliseconds) when the request was first added to the queue. This is
+     *     used along with `maxRetentionTime` to remove outdated requests. In
+     *     general you don't need to set this value, as it's automatically set
+     *     for you (defaulting to `Date.now()`), but you can update it if you
+     *     don't want particular requests to expire.
+     */
+    async pushRequest(entry) {
+        if (process.env.NODE_ENV !== 'production') {
+            assert.isType(entry, 'object', {
+                moduleName: 'workbox-background-sync',
+                className: 'Queue',
+                funcName: 'pushRequest',
+                paramName: 'entry',
+            });
+            assert.isInstance(entry.request, Request, {
+                moduleName: 'workbox-background-sync',
+                className: 'Queue',
+                funcName: 'pushRequest',
+                paramName: 'entry.request',
+            });
+        }
+        await this._addRequest(entry, 'push');
+    }
+    /**
+     * Stores the passed request in IndexedDB (with its timestamp and any
+     * metadata) at the beginning of the queue.
+     *
+     * @param {QueueEntry} entry
+     * @param {Request} entry.request The request to store in the queue.
+     * @param {Object} [entry.metadata] Any metadata you want associated with the
+     *     stored request. When requests are replayed you'll have access to this
+     *     metadata object in case you need to modify the request beforehand.
+     * @param {number} [entry.timestamp] The timestamp (Epoch time in
+     *     milliseconds) when the request was first added to the queue. This is
+     *     used along with `maxRetentionTime` to remove outdated requests. In
+     *     general you don't need to set this value, as it's automatically set
+     *     for you (defaulting to `Date.now()`), but you can update it if you
+     *     don't want particular requests to expire.
+     */
+    async unshiftRequest(entry) {
+        if (process.env.NODE_ENV !== 'production') {
+            assert.isType(entry, 'object', {
+                moduleName: 'workbox-background-sync',
+                className: 'Queue',
+                funcName: 'unshiftRequest',
+                paramName: 'entry',
+            });
+            assert.isInstance(entry.request, Request, {
+                moduleName: 'workbox-background-sync',
+                className: 'Queue',
+                funcName: 'unshiftRequest',
+                paramName: 'entry.request',
+            });
+        }
+        await this._addRequest(entry, 'unshift');
+    }
+    /**
+     * Removes and returns the last request in the queue (along with its
+     * timestamp and any metadata). The returned object takes the form:
+     * `{request, timestamp, metadata}`.
+     *
+     * @return {Promise<QueueEntry | undefined>}
+     */
+    async popRequest() {
+        return this._removeRequest('pop');
+    }
+    /**
+     * Removes and returns the first request in the queue (along with its
+     * timestamp and any metadata). The returned object takes the form:
+     * `{request, timestamp, metadata}`.
+     *
+     * @return {Promise<QueueEntry | undefined>}
+     */
+    async shiftRequest() {
+        return this._removeRequest('shift');
+    }
+    /**
+     * Returns all the entries that have not expired (per `maxRetentionTime`).
+     * Any expired entries are removed from the queue.
+     *
+     * @return {Promise<Array<QueueEntry>>}
+     */
+    async getAll() {
+        const allEntries = await this._queueStore.getAll();
+        const now = Date.now();
+        const unexpiredEntries = [];
+        for (const entry of allEntries) {
+            // Ignore requests older than maxRetentionTime. Call this function
+            // recursively until an unexpired request is found.
+            const maxRetentionTimeInMs = this._maxRetentionTime * 60 * 1000;
+            if (now - entry.timestamp > maxRetentionTimeInMs) {
+                await this._queueStore.deleteEntry(entry.id);
+            }
+            else {
+                unexpiredEntries.push(convertEntry(entry));
+            }
+        }
+        return unexpiredEntries;
+    }
+    /**
+     * Returns the number of entries present in the queue.
+     * Note that expired entries (per `maxRetentionTime`) are also included in this count.
+     *
+     * @return {Promise<number>}
+     */
+    async size() {
+        return await this._queueStore.size();
+    }
+    /**
+     * Adds the entry to the QueueStore and registers for a sync event.
+     *
+     * @param {Object} entry
+     * @param {Request} entry.request
+     * @param {Object} [entry.metadata]
+     * @param {number} [entry.timestamp=Date.now()]
+     * @param {string} operation ('push' or 'unshift')
+     * @private
+     */
+    async _addRequest({ request, metadata, timestamp = Date.now() }, operation) {
+        const storableRequest = await StorableRequest.fromRequest(request.clone());
+        const entry = {
+            requestData: storableRequest.toObject(),
+            timestamp,
+        };
+        // Only include metadata if it's present.
+        if (metadata) {
+            entry.metadata = metadata;
+        }
+        switch (operation) {
+            case 'push':
+                await this._queueStore.pushEntry(entry);
+                break;
+            case 'unshift':
+                await this._queueStore.unshiftEntry(entry);
+                break;
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            logger.log(`Request for '${getFriendlyURL(request.url)}' has ` +
+                `been added to background sync queue '${this._name}'.`);
+        }
+        // Don't register for a sync if we're in the middle of a sync. Instead,
+        // we wait until the sync is complete and call register if
+        // `this._requestsAddedDuringSync` is true.
+        if (this._syncInProgress) {
+            this._requestsAddedDuringSync = true;
+        }
+        else {
+            await this.registerSync();
+        }
+    }
+    /**
+     * Removes and returns the first or last (depending on `operation`) entry
+     * from the QueueStore that's not older than the `maxRetentionTime`.
+     *
+     * @param {string} operation ('pop' or 'shift')
+     * @return {Object|undefined}
+     * @private
+     */
+    async _removeRequest(operation) {
+        const now = Date.now();
+        let entry;
+        switch (operation) {
+            case 'pop':
+                entry = await this._queueStore.popEntry();
+                break;
+            case 'shift':
+                entry = await this._queueStore.shiftEntry();
+                break;
+        }
+        if (entry) {
+            // Ignore requests older than maxRetentionTime. Call this function
+            // recursively until an unexpired request is found.
+            const maxRetentionTimeInMs = this._maxRetentionTime * 60 * 1000;
+            if (now - entry.timestamp > maxRetentionTimeInMs) {
+                return this._removeRequest(operation);
+            }
+            return convertEntry(entry);
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * Loops through each request in the queue and attempts to re-fetch it.
+     * If any request fails to re-fetch, it's put back in the same position in
+     * the queue (which registers a retry for the next sync event).
+     */
+    async replayRequests() {
+        let entry;
+        while ((entry = await this.shiftRequest())) {
+            try {
+                await fetch(entry.request.clone());
+                if (process.env.NODE_ENV !== 'production') {
+                    logger.log(`Request for '${getFriendlyURL(entry.request.url)}' ` +
+                        `has been replayed in queue '${this._name}'`);
+                }
+            }
+            catch (error) {
+                await this.unshiftRequest(entry);
+                if (process.env.NODE_ENV !== 'production') {
+                    logger.log(`Request for '${getFriendlyURL(entry.request.url)}' ` +
+                        `failed to replay, putting it back in queue '${this._name}'`);
+                }
+                throw new WorkboxError('queue-replay-failed', { name: this._name });
+            }
+        }
+        if (process.env.NODE_ENV !== 'production') {
+            logger.log(`All requests in queue '${this.name}' have successfully ` +
+                `replayed; the queue is now empty!`);
+        }
+    }
+    /**
+     * Registers a sync event with a tag unique to this instance.
+     */
+    async registerSync() {
+        // See https://github.com/GoogleChrome/workbox/issues/2393
+        if ('sync' in self.registration && !this._forceSyncFallback) {
+            try {
+                await self.registration.sync.register(`${TAG_PREFIX}:${this._name}`);
+            }
+            catch (err) {
+                // This means the registration failed for some reason, possibly due to
+                // the user disabling it.
+                if (process.env.NODE_ENV !== 'production') {
+                    logger.warn(`Unable to register sync event for '${this._name}'.`, err);
+                }
+            }
+        }
+    }
+    /**
+     * In sync-supporting browsers, this adds a listener for the sync event.
+     * In non-sync-supporting browsers, or if _forceSyncFallback is true, this
+     * will retry the queue on service worker startup.
+     *
+     * @private
+     */
+    _addSyncListener() {
+        // See https://github.com/GoogleChrome/workbox/issues/2393
+        if ('sync' in self.registration && !this._forceSyncFallback) {
+            self.addEventListener('sync', (event) => {
+                if (event.tag === `${TAG_PREFIX}:${this._name}`) {
+                    if (process.env.NODE_ENV !== 'production') {
+                        logger.log(`Background sync for tag '${event.tag}' ` + `has been received`);
+                    }
+                    const syncComplete = async () => {
+                        this._syncInProgress = true;
+                        let syncError;
+                        try {
+                            await this._onSync({ queue: this });
+                        }
+                        catch (error) {
+                            if (error instanceof Error) {
+                                syncError = error;
+                                // Rethrow the error. Note: the logic in the finally clause
+                                // will run before this gets rethrown.
+                                throw syncError;
+                            }
+                        }
+                        finally {
+                            // New items may have been added to the queue during the sync,
+                            // so we need to register for a new sync if that's happened...
+                            // Unless there was an error during the sync, in which
+                            // case the browser will automatically retry later, as long
+                            // as `event.lastChance` is not true.
+                            if (this._requestsAddedDuringSync &&
+                                !(syncError && !event.lastChance)) {
+                                await this.registerSync();
+                            }
+                            this._syncInProgress = false;
+                            this._requestsAddedDuringSync = false;
+                        }
+                    };
+                    event.waitUntil(syncComplete());
+                }
+            });
+        }
+        else {
+            if (process.env.NODE_ENV !== 'production') {
+                logger.log(`Background sync replaying without background sync event`);
+            }
+            // If the browser doesn't support background sync, or the developer has
+            // opted-in to not using it, retry every time the service worker starts up
+            // as a fallback.
+            void this._onSync({ queue: this });
+        }
+    }
+    /**
+     * Returns the set of queue names. This is primarily used to reset the list
+     * of queue names in tests.
+     *
+     * @return {Set<string>}
+     *
+     * @private
+     */
+    static get _queueNames() {
+        return queueNames;
+    }
+}
+export { Queue };

pwa/node_modules/workbox-background-sync/Queue.mjs

@@ -0,0 +1 @@
+export * from './Queue.js';

pwa/node_modules/workbox-background-sync/QueueStore.d.ts

@@ -0,0 +1,2 @@
+import './_version.js';
+export { QueueStore } from './lib/QueueStore';

pwa/node_modules/workbox-background-sync/QueueStore.js

@@ -0,0 +1,12 @@
+/*
+  Copyright 2021 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+import './_version.js';
+// This is a temporary workaround to expose something from ./lib/ via our
+// top-level public API.
+// TODO: In Workbox v7, move the actual code from ./lib/ to this file.
+export { QueueStore } from './lib/QueueStore';

pwa/node_modules/workbox-background-sync/QueueStore.mjs

@@ -0,0 +1 @@
+export * from './QueueStore.js';

pwa/node_modules/workbox-background-sync/README.md

@@ -0,0 +1 @@
+This module's documentation can be found at https://developers.google.com/web/tools/workbox/modules/workbox-background-sync

pwa/node_modules/workbox-background-sync/StorableRequest.d.ts

@@ -0,0 +1,2 @@
+import './_version.js';
+export { StorableRequest } from './lib/StorableRequest';

pwa/node_modules/workbox-background-sync/StorableRequest.js

@@ -0,0 +1,12 @@
+/*
+  Copyright 2021 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+import './_version.js';
+// This is a temporary workaround to expose something from ./lib/ via our
+// top-level public API.
+// TODO: In Workbox v7, move the actual code from ./lib/ to this file.
+export { StorableRequest } from './lib/StorableRequest';

pwa/node_modules/workbox-background-sync/StorableRequest.mjs

@@ -0,0 +1 @@
+export * from './StorableRequest.js';

pwa/node_modules/workbox-background-sync/_version.js

@@ -0,0 +1,6 @@
+"use strict";
+// @ts-ignore
+try {
+    self['workbox:background-sync:7.3.0'] && _();
+}
+catch (e) { }

pwa/node_modules/workbox-background-sync/_version.mjs

@@ -0,0 +1 @@
+try{self['workbox:background-sync:7.4.0']&&_()}catch(e){}// eslint-disable-line

pwa/node_modules/workbox-background-sync/index.d.ts

@@ -0,0 +1,25 @@
+import { BackgroundSyncPlugin } from './BackgroundSyncPlugin.js';
+import { Queue, QueueOptions } from './Queue.js';
+import { QueueStore } from './QueueStore.js';
+import { StorableRequest } from './StorableRequest.js';
+import './_version.js';
+interface SyncManager {
+    getTags(): Promise<string[]>;
+    register(tag: string): Promise<void>;
+}
+declare global {
+    interface ServiceWorkerRegistration {
+        readonly sync: SyncManager;
+    }
+    interface SyncEvent extends ExtendableEvent {
+        readonly lastChance: boolean;
+        readonly tag: string;
+    }
+    interface ServiceWorkerGlobalScopeEventMap {
+        sync: SyncEvent;
+    }
+}
+/**
+ * @module workbox-background-sync
+ */
+export { BackgroundSyncPlugin, Queue, QueueOptions, QueueStore, StorableRequest };

pwa/node_modules/workbox-background-sync/index.js

@@ -0,0 +1,16 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+import { BackgroundSyncPlugin } from './BackgroundSyncPlugin.js';
+import { Queue } from './Queue.js';
+import { QueueStore } from './QueueStore.js';
+import { StorableRequest } from './StorableRequest.js';
+import './_version.js';
+/**
+ * @module workbox-background-sync
+ */
+export { BackgroundSyncPlugin, Queue, QueueStore, StorableRequest };

pwa/node_modules/workbox-background-sync/index.mjs

@@ -0,0 +1 @@
+export * from './index.js';

pwa/node_modules/workbox-background-sync/lib/QueueDb.d.ts

@@ -0,0 +1,90 @@
+import { RequestData } from './StorableRequest.js';
+import '../_version.js';
+export interface UnidentifiedQueueStoreEntry {
+    requestData: RequestData;
+    timestamp: number;
+    id?: number;
+    queueName?: string;
+    metadata?: object;
+}
+export interface QueueStoreEntry extends UnidentifiedQueueStoreEntry {
+    id: number;
+}
+/**
+ * A class to interact directly an IndexedDB created specifically to save and
+ * retrieve QueueStoreEntries. This class encapsulates all the schema details
+ * to store the representation of a Queue.
+ *
+ * @private
+ */
+export declare class QueueDb {
+    private _db;
+    /**
+     * Add QueueStoreEntry to underlying db.
+     *
+     * @param {UnidentifiedQueueStoreEntry} entry
+     */
+    addEntry(entry: UnidentifiedQueueStoreEntry): Promise<void>;
+    /**
+     * Returns the first entry id in the ObjectStore.
+     *
+     * @return {number | undefined}
+     */
+    getFirstEntryId(): Promise<number | undefined>;
+    /**
+     * Get all the entries filtered by index
+     *
+     * @param queueName
+     * @return {Promise<QueueStoreEntry[]>}
+     */
+    getAllEntriesByQueueName(queueName: string): Promise<QueueStoreEntry[]>;
+    /**
+     * Returns the number of entries filtered by index
+     *
+     * @param queueName
+     * @return {Promise<number>}
+     */
+    getEntryCountByQueueName(queueName: string): Promise<number>;
+    /**
+     * Deletes a single entry by id.
+     *
+     * @param {number} id the id of the entry to be deleted
+     */
+    deleteEntry(id: number): Promise<void>;
+    /**
+     *
+     * @param queueName
+     * @returns {Promise<QueueStoreEntry | undefined>}
+     */
+    getFirstEntryByQueueName(queueName: string): Promise<QueueStoreEntry | undefined>;
+    /**
+     *
+     * @param queueName
+     * @returns {Promise<QueueStoreEntry | undefined>}
+     */
+    getLastEntryByQueueName(queueName: string): Promise<QueueStoreEntry | undefined>;
+    /**
+     * Returns either the first or the last entries, depending on direction.
+     * Filtered by index.
+     *
+     * @param {IDBCursorDirection} direction
+     * @param {IDBKeyRange} query
+     * @return {Promise<QueueStoreEntry | undefined>}
+     * @private
+     */
+    getEndEntryFromIndex(query: IDBKeyRange, direction: IDBCursorDirection): Promise<QueueStoreEntry | undefined>;
+    /**
+     * Returns an open connection to the database.
+     *
+     * @private
+     */
+    private getDb;
+    /**
+     * Upgrades QueueDB
+     *
+     * @param {IDBPDatabase<QueueDBSchema>} db
+     * @param {number} oldVersion
+     * @private
+     */
+    private _upgradeDb;
+}

pwa/node_modules/workbox-background-sync/lib/QueueDb.js

@@ -0,0 +1,145 @@
+/*
+  Copyright 2021 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+import { openDB } from 'idb';
+import '../_version.js';
+const DB_VERSION = 3;
+const DB_NAME = 'workbox-background-sync';
+const REQUEST_OBJECT_STORE_NAME = 'requests';
+const QUEUE_NAME_INDEX = 'queueName';
+/**
+ * A class to interact directly an IndexedDB created specifically to save and
+ * retrieve QueueStoreEntries. This class encapsulates all the schema details
+ * to store the representation of a Queue.
+ *
+ * @private
+ */
+export class QueueDb {
+    constructor() {
+        this._db = null;
+    }
+    /**
+     * Add QueueStoreEntry to underlying db.
+     *
+     * @param {UnidentifiedQueueStoreEntry} entry
+     */
+    async addEntry(entry) {
+        const db = await this.getDb();
+        const tx = db.transaction(REQUEST_OBJECT_STORE_NAME, 'readwrite', {
+            durability: 'relaxed',
+        });
+        await tx.store.add(entry);
+        await tx.done;
+    }
+    /**
+     * Returns the first entry id in the ObjectStore.
+     *
+     * @return {number | undefined}
+     */
+    async getFirstEntryId() {
+        const db = await this.getDb();
+        const cursor = await db
+            .transaction(REQUEST_OBJECT_STORE_NAME)
+            .store.openCursor();
+        return cursor === null || cursor === void 0 ? void 0 : cursor.value.id;
+    }
+    /**
+     * Get all the entries filtered by index
+     *
+     * @param queueName
+     * @return {Promise<QueueStoreEntry[]>}
+     */
+    async getAllEntriesByQueueName(queueName) {
+        const db = await this.getDb();
+        const results = await db.getAllFromIndex(REQUEST_OBJECT_STORE_NAME, QUEUE_NAME_INDEX, IDBKeyRange.only(queueName));
+        return results ? results : new Array();
+    }
+    /**
+     * Returns the number of entries filtered by index
+     *
+     * @param queueName
+     * @return {Promise<number>}
+     */
+    async getEntryCountByQueueName(queueName) {
+        const db = await this.getDb();
+        return db.countFromIndex(REQUEST_OBJECT_STORE_NAME, QUEUE_NAME_INDEX, IDBKeyRange.only(queueName));
+    }
+    /**
+     * Deletes a single entry by id.
+     *
+     * @param {number} id the id of the entry to be deleted
+     */
+    async deleteEntry(id) {
+        const db = await this.getDb();
+        await db.delete(REQUEST_OBJECT_STORE_NAME, id);
+    }
+    /**
+     *
+     * @param queueName
+     * @returns {Promise<QueueStoreEntry | undefined>}
+     */
+    async getFirstEntryByQueueName(queueName) {
+        return await this.getEndEntryFromIndex(IDBKeyRange.only(queueName), 'next');
+    }
+    /**
+     *
+     * @param queueName
+     * @returns {Promise<QueueStoreEntry | undefined>}
+     */
+    async getLastEntryByQueueName(queueName) {
+        return await this.getEndEntryFromIndex(IDBKeyRange.only(queueName), 'prev');
+    }
+    /**
+     * Returns either the first or the last entries, depending on direction.
+     * Filtered by index.
+     *
+     * @param {IDBCursorDirection} direction
+     * @param {IDBKeyRange} query
+     * @return {Promise<QueueStoreEntry | undefined>}
+     * @private
+     */
+    async getEndEntryFromIndex(query, direction) {
+        const db = await this.getDb();
+        const cursor = await db
+            .transaction(REQUEST_OBJECT_STORE_NAME)
+            .store.index(QUEUE_NAME_INDEX)
+            .openCursor(query, direction);
+        return cursor === null || cursor === void 0 ? void 0 : cursor.value;
+    }
+    /**
+     * Returns an open connection to the database.
+     *
+     * @private
+     */
+    async getDb() {
+        if (!this._db) {
+            this._db = await openDB(DB_NAME, DB_VERSION, {
+                upgrade: this._upgradeDb,
+            });
+        }
+        return this._db;
+    }
+    /**
+     * Upgrades QueueDB
+     *
+     * @param {IDBPDatabase<QueueDBSchema>} db
+     * @param {number} oldVersion
+     * @private
+     */
+    _upgradeDb(db, oldVersion) {
+        if (oldVersion > 0 && oldVersion < DB_VERSION) {
+            if (db.objectStoreNames.contains(REQUEST_OBJECT_STORE_NAME)) {
+                db.deleteObjectStore(REQUEST_OBJECT_STORE_NAME);
+            }
+        }
+        const objStore = db.createObjectStore(REQUEST_OBJECT_STORE_NAME, {
+            autoIncrement: true,
+            keyPath: 'id',
+        });
+        objStore.createIndex(QUEUE_NAME_INDEX, QUEUE_NAME_INDEX, { unique: false });
+    }
+}

pwa/node_modules/workbox-background-sync/lib/QueueDb.mjs

@@ -0,0 +1 @@
+export * from './QueueDb.js';

pwa/node_modules/workbox-background-sync/lib/QueueStore.d.ts

@@ -0,0 +1,83 @@
+import { UnidentifiedQueueStoreEntry, QueueStoreEntry } from './QueueDb.js';
+import '../_version.js';
+/**
+ * A class to manage storing requests from a Queue in IndexedDB,
+ * indexed by their queue name for easier access.
+ *
+ * Most developers will not need to access this class directly;
+ * it is exposed for advanced use cases.
+ */
+export declare class QueueStore {
+    private readonly _queueName;
+    private readonly _queueDb;
+    /**
+     * Associates this instance with a Queue instance, so entries added can be
+     * identified by their queue name.
+     *
+     * @param {string} queueName
+     */
+    constructor(queueName: string);
+    /**
+     * Append an entry last in the queue.
+     *
+     * @param {Object} entry
+     * @param {Object} entry.requestData
+     * @param {number} [entry.timestamp]
+     * @param {Object} [entry.metadata]
+     */
+    pushEntry(entry: UnidentifiedQueueStoreEntry): Promise<void>;
+    /**
+     * Prepend an entry first in the queue.
+     *
+     * @param {Object} entry
+     * @param {Object} entry.requestData
+     * @param {number} [entry.timestamp]
+     * @param {Object} [entry.metadata]
+     */
+    unshiftEntry(entry: UnidentifiedQueueStoreEntry): Promise<void>;
+    /**
+     * Removes and returns the last entry in the queue matching the `queueName`.
+     *
+     * @return {Promise<QueueStoreEntry|undefined>}
+     */
+    popEntry(): Promise<QueueStoreEntry | undefined>;
+    /**
+     * Removes and returns the first entry in the queue matching the `queueName`.
+     *
+     * @return {Promise<QueueStoreEntry|undefined>}
+     */
+    shiftEntry(): Promise<QueueStoreEntry | undefined>;
+    /**
+     * Returns all entries in the store matching the `queueName`.
+     *
+     * @param {Object} options See {@link workbox-background-sync.Queue~getAll}
+     * @return {Promise<Array<Object>>}
+     */
+    getAll(): Promise<QueueStoreEntry[]>;
+    /**
+     * Returns the number of entries in the store matching the `queueName`.
+     *
+     * @param {Object} options See {@link workbox-background-sync.Queue~size}
+     * @return {Promise<number>}
+     */
+    size(): Promise<number>;
+    /**
+     * Deletes the entry for the given ID.
+     *
+     * WARNING: this method does not ensure the deleted entry belongs to this
+     * queue (i.e. matches the `queueName`). But this limitation is acceptable
+     * as this class is not publicly exposed. An additional check would make
+     * this method slower than it needs to be.
+     *
+     * @param {number} id
+     */
+    deleteEntry(id: number): Promise<void>;
+    /**
+     * Removes and returns the first or last entry in the queue (based on the
+     * `direction` argument) matching the `queueName`.
+     *
+     * @return {Promise<QueueStoreEntry|undefined>}
+     * @private
+     */
+    _removeEntry(entry?: QueueStoreEntry): Promise<QueueStoreEntry | undefined>;
+}

pwa/node_modules/workbox-background-sync/lib/QueueStore.js

@@ -0,0 +1,152 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+import { assert } from 'workbox-core/_private/assert.js';
+import { QueueDb, } from './QueueDb.js';
+import '../_version.js';
+/**
+ * A class to manage storing requests from a Queue in IndexedDB,
+ * indexed by their queue name for easier access.
+ *
+ * Most developers will not need to access this class directly;
+ * it is exposed for advanced use cases.
+ */
+export class QueueStore {
+    /**
+     * Associates this instance with a Queue instance, so entries added can be
+     * identified by their queue name.
+     *
+     * @param {string} queueName
+     */
+    constructor(queueName) {
+        this._queueName = queueName;
+        this._queueDb = new QueueDb();
+    }
+    /**
+     * Append an entry last in the queue.
+     *
+     * @param {Object} entry
+     * @param {Object} entry.requestData
+     * @param {number} [entry.timestamp]
+     * @param {Object} [entry.metadata]
+     */
+    async pushEntry(entry) {
+        if (process.env.NODE_ENV !== 'production') {
+            assert.isType(entry, 'object', {
+                moduleName: 'workbox-background-sync',
+                className: 'QueueStore',
+                funcName: 'pushEntry',
+                paramName: 'entry',
+            });
+            assert.isType(entry.requestData, 'object', {
+                moduleName: 'workbox-background-sync',
+                className: 'QueueStore',
+                funcName: 'pushEntry',
+                paramName: 'entry.requestData',
+            });
+        }
+        // Don't specify an ID since one is automatically generated.
+        delete entry.id;
+        entry.queueName = this._queueName;
+        await this._queueDb.addEntry(entry);
+    }
+    /**
+     * Prepend an entry first in the queue.
+     *
+     * @param {Object} entry
+     * @param {Object} entry.requestData
+     * @param {number} [entry.timestamp]
+     * @param {Object} [entry.metadata]
+     */
+    async unshiftEntry(entry) {
+        if (process.env.NODE_ENV !== 'production') {
+            assert.isType(entry, 'object', {
+                moduleName: 'workbox-background-sync',
+                className: 'QueueStore',
+                funcName: 'unshiftEntry',
+                paramName: 'entry',
+            });
+            assert.isType(entry.requestData, 'object', {
+                moduleName: 'workbox-background-sync',
+                className: 'QueueStore',
+                funcName: 'unshiftEntry',
+                paramName: 'entry.requestData',
+            });
+        }
+        const firstId = await this._queueDb.getFirstEntryId();
+        if (firstId) {
+            // Pick an ID one less than the lowest ID in the object store.
+            entry.id = firstId - 1;
+        }
+        else {
+            // Otherwise let the auto-incrementor assign the ID.
+            delete entry.id;
+        }
+        entry.queueName = this._queueName;
+        await this._queueDb.addEntry(entry);
+    }
+    /**
+     * Removes and returns the last entry in the queue matching the `queueName`.
+     *
+     * @return {Promise<QueueStoreEntry|undefined>}
+     */
+    async popEntry() {
+        return this._removeEntry(await this._queueDb.getLastEntryByQueueName(this._queueName));
+    }
+    /**
+     * Removes and returns the first entry in the queue matching the `queueName`.
+     *
+     * @return {Promise<QueueStoreEntry|undefined>}
+     */
+    async shiftEntry() {
+        return this._removeEntry(await this._queueDb.getFirstEntryByQueueName(this._queueName));
+    }
+    /**
+     * Returns all entries in the store matching the `queueName`.
+     *
+     * @param {Object} options See {@link workbox-background-sync.Queue~getAll}
+     * @return {Promise<Array<Object>>}
+     */
+    async getAll() {
+        return await this._queueDb.getAllEntriesByQueueName(this._queueName);
+    }
+    /**
+     * Returns the number of entries in the store matching the `queueName`.
+     *
+     * @param {Object} options See {@link workbox-background-sync.Queue~size}
+     * @return {Promise<number>}
+     */
+    async size() {
+        return await this._queueDb.getEntryCountByQueueName(this._queueName);
+    }
+    /**
+     * Deletes the entry for the given ID.
+     *
+     * WARNING: this method does not ensure the deleted entry belongs to this
+     * queue (i.e. matches the `queueName`). But this limitation is acceptable
+     * as this class is not publicly exposed. An additional check would make
+     * this method slower than it needs to be.
+     *
+     * @param {number} id
+     */
+    async deleteEntry(id) {
+        await this._queueDb.deleteEntry(id);
+    }
+    /**
+     * Removes and returns the first or last entry in the queue (based on the
+     * `direction` argument) matching the `queueName`.
+     *
+     * @return {Promise<QueueStoreEntry|undefined>}
+     * @private
+     */
+    async _removeEntry(entry) {
+        if (entry) {
+            await this.deleteEntry(entry.id);
+        }
+        return entry;
+    }
+}

pwa/node_modules/workbox-background-sync/lib/QueueStore.mjs

@@ -0,0 +1 @@
+export * from './QueueStore.js';

pwa/node_modules/workbox-background-sync/lib/StorableRequest.d.ts

@@ -0,0 +1,53 @@
+import { MapLikeObject } from 'workbox-core/types.js';
+import '../_version.js';
+export interface RequestData extends MapLikeObject {
+    url: string;
+    headers: MapLikeObject;
+    body?: ArrayBuffer;
+}
+/**
+ * A class to make it easier to serialize and de-serialize requests so they
+ * can be stored in IndexedDB.
+ *
+ * Most developers will not need to access this class directly;
+ * it is exposed for advanced use cases.
+ */
+declare class StorableRequest {
+    private readonly _requestData;
+    /**
+     * Converts a Request object to a plain object that can be structured
+     * cloned or JSON-stringified.
+     *
+     * @param {Request} request
+     * @return {Promise<StorableRequest>}
+     */
+    static fromRequest(request: Request): Promise<StorableRequest>;
+    /**
+     * Accepts an object of request data that can be used to construct a
+     * `Request` but can also be stored in IndexedDB.
+     *
+     * @param {Object} requestData An object of request data that includes the
+     *     `url` plus any relevant properties of
+     *     [requestInit]{@link https://fetch.spec.whatwg.org/#requestinit}.
+     */
+    constructor(requestData: RequestData);
+    /**
+     * Returns a deep clone of the instances `_requestData` object.
+     *
+     * @return {Object}
+     */
+    toObject(): RequestData;
+    /**
+     * Converts this instance to a Request.
+     *
+     * @return {Request}
+     */
+    toRequest(): Request;
+    /**
+     * Creates and returns a deep clone of the instance.
+     *
+     * @return {StorableRequest}
+     */
+    clone(): StorableRequest;
+}
+export { StorableRequest };

pwa/node_modules/workbox-background-sync/lib/StorableRequest.js

@@ -0,0 +1,121 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+import { assert } from 'workbox-core/_private/assert.js';
+import '../_version.js';
+const serializableProperties = [
+    'method',
+    'referrer',
+    'referrerPolicy',
+    'mode',
+    'credentials',
+    'cache',
+    'redirect',
+    'integrity',
+    'keepalive',
+];
+/**
+ * A class to make it easier to serialize and de-serialize requests so they
+ * can be stored in IndexedDB.
+ *
+ * Most developers will not need to access this class directly;
+ * it is exposed for advanced use cases.
+ */
+class StorableRequest {
+    /**
+     * Converts a Request object to a plain object that can be structured
+     * cloned or JSON-stringified.
+     *
+     * @param {Request} request
+     * @return {Promise<StorableRequest>}
+     */
+    static async fromRequest(request) {
+        const requestData = {
+            url: request.url,
+            headers: {},
+        };
+        // Set the body if present.
+        if (request.method !== 'GET') {
+            // Use ArrayBuffer to support non-text request bodies.
+            // NOTE: we can't use Blobs becuse Safari doesn't support storing
+            // Blobs in IndexedDB in some cases:
+            // https://github.com/dfahlander/Dexie.js/issues/618#issuecomment-398348457
+            requestData.body = await request.clone().arrayBuffer();
+        }
+        // Convert the headers from an iterable to an object.
+        for (const [key, value] of request.headers.entries()) {
+            requestData.headers[key] = value;
+        }
+        // Add all other serializable request properties
+        for (const prop of serializableProperties) {
+            if (request[prop] !== undefined) {
+                requestData[prop] = request[prop];
+            }
+        }
+        return new StorableRequest(requestData);
+    }
+    /**
+     * Accepts an object of request data that can be used to construct a
+     * `Request` but can also be stored in IndexedDB.
+     *
+     * @param {Object} requestData An object of request data that includes the
+     *     `url` plus any relevant properties of
+     *     [requestInit]{@link https://fetch.spec.whatwg.org/#requestinit}.
+     */
+    constructor(requestData) {
+        if (process.env.NODE_ENV !== 'production') {
+            assert.isType(requestData, 'object', {
+                moduleName: 'workbox-background-sync',
+                className: 'StorableRequest',
+                funcName: 'constructor',
+                paramName: 'requestData',
+            });
+            assert.isType(requestData.url, 'string', {
+                moduleName: 'workbox-background-sync',
+                className: 'StorableRequest',
+                funcName: 'constructor',
+                paramName: 'requestData.url',
+            });
+        }
+        // If the request's mode is `navigate`, convert it to `same-origin` since
+        // navigation requests can't be constructed via script.
+        if (requestData['mode'] === 'navigate') {
+            requestData['mode'] = 'same-origin';
+        }
+        this._requestData = requestData;
+    }
+    /**
+     * Returns a deep clone of the instances `_requestData` object.
+     *
+     * @return {Object}
+     */
+    toObject() {
+        const requestData = Object.assign({}, this._requestData);
+        requestData.headers = Object.assign({}, this._requestData.headers);
+        if (requestData.body) {
+            requestData.body = requestData.body.slice(0);
+        }
+        return requestData;
+    }
+    /**
+     * Converts this instance to a Request.
+     *
+     * @return {Request}
+     */
+    toRequest() {
+        return new Request(this._requestData.url, this._requestData);
+    }
+    /**
+     * Creates and returns a deep clone of the instance.
+     *
+     * @return {StorableRequest}
+     */
+    clone() {
+        return new StorableRequest(this.toObject());
+    }
+}
+export { StorableRequest };

pwa/node_modules/workbox-background-sync/lib/StorableRequest.mjs

@@ -0,0 +1 @@
+export * from './StorableRequest.js';

pwa/node_modules/workbox-background-sync/node_modules/idb/CHANGELOG.md

@@ -0,0 +1,87 @@
+# Breaking changes in 7.x
+
+- No longer committing `build` to GitHub.
+- Renamed files in dist.
+- Added conditional exports.
+- iife build is now a umd.
+
+# Breaking changes in 6.x
+
+Some TypeScript definitions changed so write-methods are missing from 'readonly' transactions. This might be backwards-incompatible with code that performs a lot of type wrangling.
+
+# Breaking changes in 5.x
+
+I moved some files around, so I bumped the major version for safety.
+
+# Changes in 4.x
+
+## Breaking changes
+
+### Opening a database
+
+```js
+// Old 3.x way
+import { openDb } from 'idb';
+
+openDb('db-name', 1, (upgradeDb) => {
+  console.log(upgradeDb.oldVersion);
+  console.log(upgradeDb.transaction);
+});
+```
+
+```js
+// New 4.x way
+import { openDB } from 'idb';
+
+openDB('db-name', 1, {
+  upgrade(db, oldVersion, newVersion, transaction) {
+    console.log(oldVersion);
+    console.log(transaction);
+  },
+});
+```
+
+- `openDb` and `deleteDb` were renamed `openDB` and `deleteDB` to be more consistent with DOM naming.
+- The signature of `openDB` changed. The third parameter used to be the upgrade callback, it's now an option object which can include an `upgrade` method.
+- There's no `UpgradeDB` anymore. You get the same database `openDB` resolves with. Versions numbers and the upgrade transaction are included as additional parameters.
+
+### Promises & throwing
+
+The library turns all `IDBRequest` objects into promises, but it doesn't know in advance which methods may return promises.
+
+As a result, methods such as `store.put` may throw instead of returning a promise.
+
+If you're using async functions, there isn't a difference.
+
+### Other breaking changes
+
+- `iterateCursor` and `iterateKeyCursor` have been removed. These existed to work around browsers microtask issues which have since been fixed. Async iterators provide similar functionality.
+- All pseudo-private properties (those beginning with an underscore) are gone. Use `unwrap()` to get access to bare IDB objects.
+- `transaction.complete` was renamed to `transaction.done` to be shorter and more consistent with the DOM.
+- `getAll` is no longer polyfilled on indexes and stores.
+- The library no longer officially supports IE11.
+
+## New stuff
+
+- The library now uses proxies, so objects will include everything from their plain-IDB equivalents.
+- TypeScript support has massively improved, including the ability to provide types for your database.
+- Optional support for async iterators, which makes handling cursors much easier.
+- Database objects now have shortcuts for single actions (like `get`, `put`, `add`, `getAll` etc etc).
+- For transactions that cover a single store `transaction.store` is a reference to that store.
+- `openDB` lets you add callbacks for when your database is blocking another connection, or when you're blocked by another connection.
+
+# Changes in 3.x
+
+The library became a module.
+
+```js
+// Old 2.x way:
+import idb from 'idb';
+idb.open(…);
+idb.delete(…);
+
+// 3.x way:
+import { openDb, deleteDb } from 'idb';
+openDb(…);
+deleteDb(…);
+```

pwa/node_modules/workbox-background-sync/node_modules/idb/LICENSE

@@ -0,0 +1,6 @@
+ISC License (ISC)
+Copyright (c) 2016, Jake Archibald <jaffathecake@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

pwa/node_modules/workbox-background-sync/node_modules/idb/README.md

@@ -0,0 +1,506 @@
+# IndexedDB with usability.
+
+This is a tiny (~1.06kB brotli'd) library that mostly mirrors the IndexedDB API, but with small improvements that make a big difference to usability.
+
+1. [Installation](#installation)
+1. [Changes](#changes)
+1. [Browser support](#browser-support)
+1. [API](#api)
+   1. [`openDB`](#opendb)
+   1. [`deleteDB`](#deletedb)
+   1. [`unwrap`](#unwrap)
+   1. [`wrap`](#wrap)
+   1. [General enhancements](#general-enhancements)
+   1. [`IDBDatabase` enhancements](#idbdatabase-enhancements)
+   1. [`IDBTransaction` enhancements](#idbtransaction-enhancements)
+   1. [`IDBCursor` enhancements](#idbcursor-enhancements)
+   1. [Async iterators](#async-iterators)
+1. [Examples](#examples)
+1. [TypeScript](#typescript)
+
+# Installation
+
+## Using npm
+
+```sh
+npm install idb
+```
+
+Then, assuming you're using a module-compatible system (like webpack, Rollup etc):
+
+```js
+import { openDB, deleteDB, wrap, unwrap } from 'idb';
+
+async function doDatabaseStuff() {
+  const db = await openDB(…);
+}
+```
+
+## Directly in a browser
+
+### Using the modules method directly via jsdelivr:
+
+```html
+<script type="module">
+  import { openDB, deleteDB, wrap, unwrap } from 'https://cdn.jsdelivr.net/npm/idb@7/+esm';
+
+  async function doDatabaseStuff() {
+    const db = await openDB(…);
+  }
+</script>
+```
+
+### Using external script reference
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/idb@7/build/umd.js"></script>
+<script>
+  async function doDatabaseStuff() {
+    const db = await idb.openDB(…);
+  }
+</script>
+```
+
+A global, `idb`, will be created, containing all exports of the module version.
+
+# Changes
+
+[See details of (potentially) breaking changes](CHANGELOG.md).
+
+# Browser support
+
+This library targets modern browsers, as in Chrome, Firefox, Safari, and other browsers that use those engines, such as Edge. IE is not supported.
+
+If you want to target much older versions of those browsers, you can transpile the library using something like [Babel](https://babeljs.io/). You can't transpile the library for IE, as it relies on a proper implementation of [JavaScript proxies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy).
+
+# API
+
+## `openDB`
+
+This method opens a database, and returns a promise for an enhanced [`IDBDatabase`](https://w3c.github.io/IndexedDB/#database-interface).
+
+```js
+const db = await openDB(name, version, {
+  upgrade(db, oldVersion, newVersion, transaction, event) {
+    // …
+  },
+  blocked(currentVersion, blockedVersion, event) {
+    // …
+  },
+  blocking(currentVersion, blockedVersion, event) {
+    // …
+  },
+  terminated() {
+    // …
+  },
+});
+```
+
+- `name`: Name of the database.
+- `version` (optional): Schema version, or `undefined` to open the current version.
+- `upgrade` (optional): Called if this version of the database has never been opened before. Use it to specify the schema for the database. This is similar to the [`upgradeneeded` event](https://developer.mozilla.org/en-US/docs/Web/API/IDBOpenDBRequest/upgradeneeded_event) in plain IndexedDB.
+  - `db`: An enhanced `IDBDatabase`.
+  - `oldVersion`: Last version of the database opened by the user.
+  - `newVersion`: Whatever new version you provided.
+  - `transaction`: An enhanced transaction for this upgrade. This is useful if you need to get data from other stores as part of a migration.
+  - `event`: The event object for the associated `upgradeneeded` event.
+- `blocked` (optional): Called if there are older versions of the database open on the origin, so this version cannot open. This is similar to the [`blocked` event](https://developer.mozilla.org/en-US/docs/Web/API/IDBOpenDBRequest/blocked_event) in plain IndexedDB.
+  - `currentVersion`: Version of the database that's blocking this one.
+  - `blockedVersion`: The version of the database being blocked (whatever version you provided to `openDB`).
+  - `event`: The event object for the associated `blocked` event.
+- `blocking` (optional): Called if this connection is blocking a future version of the database from opening. This is similar to the [`versionchange` event](https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase/versionchange_event) in plain IndexedDB.
+  - `currentVersion`: Version of the open database (whatever version you provided to `openDB`).
+  - `blockedVersion`: The version of the database that's being blocked.
+  - `event`: The event object for the associated `versionchange` event.
+- `terminated` (optional): Called if the browser abnormally terminates the connection, but not on regular closures like calling `db.close()`. This is similar to the [`close` event](https://developer.mozilla.org/en-US/docs/Web/API/IDBDatabase/close_event) in plain IndexedDB.
+
+## `deleteDB`
+
+Deletes a database.
+
+```js
+await deleteDB(name, {
+  blocked() {
+    // …
+  },
+});
+```
+
+- `name`: Name of the database.
+- `blocked` (optional): Called if the database already exists and there are open connections that don’t close in response to a versionchange event, the request will be blocked until they all close.
+  - `currentVersion`: Version of the database that's blocking the delete operation.
+  - `event`: The event object for the associated 'versionchange' event.
+
+## `unwrap`
+
+Takes an enhanced IndexedDB object and returns the plain unmodified one.
+
+```js
+const unwrapped = unwrap(wrapped);
+```
+
+This is useful if, for some reason, you want to drop back into plain IndexedDB. Promises will also be converted back into `IDBRequest` objects.
+
+## `wrap`
+
+Takes an IDB object and returns a version enhanced by this library.
+
+```js
+const wrapped = wrap(unwrapped);
+```
+
+This is useful if some third party code gives you an `IDBDatabase` object and you want it to have the features of this library.
+
+This doesn't work with `IDBCursor`, [due to missing primitives](https://github.com/w3c/IndexedDB/issues/255). Also, if you wrap an `IDBTransaction`, `tx.store` and `tx.objectStoreNames` won't work in Edge. To avoid these issues, wrap the `IDBDatabase` object, and use the wrapped object to create a new transaction.
+
+## General enhancements
+
+Once you've opened the database the API is the same as IndexedDB, except for a few changes to make things easier.
+
+Firstly, any method that usually returns an `IDBRequest` object will now return a promise for the result.
+
+```js
+const store = db.transaction(storeName).objectStore(storeName);
+const value = await store.get(key);
+```
+
+### Promises & throwing
+
+The library turns all `IDBRequest` objects into promises, but it doesn't know in advance which methods may return promises.
+
+As a result, methods such as `store.put` may throw instead of returning a promise.
+
+If you're using async functions, there's no observable difference.
+
+### Transaction lifetime
+
+TL;DR: **Do not `await` other things between the start and end of your transaction**, otherwise the transaction will close before you're done.
+
+An IDB transaction auto-closes if it doesn't have anything left do once microtasks have been processed. As a result, this works fine:
+
+```js
+const tx = db.transaction('keyval', 'readwrite');
+const store = tx.objectStore('keyval');
+const val = (await store.get('counter')) || 0;
+await store.put(val + 1, 'counter');
+await tx.done;
+```
+
+But this doesn't:
+
+```js
+const tx = db.transaction('keyval', 'readwrite');
+const store = tx.objectStore('keyval');
+const val = (await store.get('counter')) || 0;
+// This is where things go wrong:
+const newVal = await fetch('/increment?val=' + val);
+// And this throws an error:
+await store.put(newVal, 'counter');
+await tx.done;
+```
+
+In this case, the transaction closes while the browser is fetching, so `store.put` fails.
+
+## `IDBDatabase` enhancements
+
+### Shortcuts to get/set from an object store
+
+It's common to create a transaction for a single action, so helper methods are included for this:
+
+```js
+// Get a value from a store:
+const value = await db.get(storeName, key);
+// Set a value in a store:
+await db.put(storeName, value, key);
+```
+
+The shortcuts are: `get`, `getKey`, `getAll`, `getAllKeys`, `count`, `put`, `add`, `delete`, and `clear`. Each method takes a `storeName` argument, the name of the object store, and the rest of the arguments are the same as the equivalent `IDBObjectStore` method.
+
+### Shortcuts to get from an index
+
+The shortcuts are: `getFromIndex`, `getKeyFromIndex`, `getAllFromIndex`, `getAllKeysFromIndex`, and `countFromIndex`.
+
+```js
+// Get a value from an index:
+const value = await db.getFromIndex(storeName, indexName, key);
+```
+
+Each method takes `storeName` and `indexName` arguments, followed by the rest of the arguments from the equivalent `IDBIndex` method.
+
+## `IDBTransaction` enhancements
+
+### `tx.store`
+
+If a transaction involves a single store, the `store` property will reference that store.
+
+```js
+const tx = db.transaction('whatever');
+const store = tx.store;
+```
+
+If a transaction involves multiple stores, `tx.store` is undefined, you need to use `tx.objectStore(storeName)` to get the stores.
+
+### `tx.done`
+
+Transactions have a `.done` promise which resolves when the transaction completes successfully, and otherwise rejects with the [transaction error](https://developer.mozilla.org/en-US/docs/Web/API/IDBTransaction/error).
+
+```js
+const tx = db.transaction(storeName, 'readwrite');
+await Promise.all([
+  tx.store.put('bar', 'foo'),
+  tx.store.put('world', 'hello'),
+  tx.done,
+]);
+```
+
+If you're writing to the database, `tx.done` is the signal that everything was successfully committed to the database. However, it's still beneficial to await the individual operations, as you'll see the error that caused the transaction to fail.
+
+## `IDBCursor` enhancements
+
+Cursor advance methods (`advance`, `continue`, `continuePrimaryKey`) return a promise for the cursor, or null if there are no further values to provide.
+
+```js
+let cursor = await db.transaction(storeName).store.openCursor();
+
+while (cursor) {
+  console.log(cursor.key, cursor.value);
+  cursor = await cursor.continue();
+}
+```
+
+## Async iterators
+
+Async iterator support isn't included by default (Edge doesn't support them). To include them, import `idb/with-async-ittr` instead of `idb` (this increases the library size to ~1.29kB brotli'd):
+
+```js
+import { openDB } from 'idb/with-async-ittr';
+```
+
+Or `https://cdn.jsdelivr.net/npm/idb@7/build/umd-with-async-ittr.js` if you're using the non-module version.
+
+Now you can iterate over stores, indexes, and cursors:
+
+```js
+const tx = db.transaction(storeName);
+
+for await (const cursor of tx.store) {
+  // …
+}
+```
+
+Each yielded object is an `IDBCursor`. You can optionally use the advance methods to skip items (within an async iterator they return void):
+
+```js
+const tx = db.transaction(storeName);
+
+for await (const cursor of tx.store) {
+  console.log(cursor.value);
+  // Skip the next item
+  cursor.advance(2);
+}
+```
+
+If you don't manually advance the cursor, `cursor.continue()` is called for you.
+
+Stores and indexes also have an `iterate` method which has the same signature as `openCursor`, but returns an async iterator:
+
+```js
+const index = db.transaction('books').store.index('author');
+
+for await (const cursor of index.iterate('Douglas Adams')) {
+  console.log(cursor.value);
+}
+```
+
+# Examples
+
+## Keyval store
+
+This is very similar to `localStorage`, but async. If this is _all_ you need, you may be interested in [idb-keyval](https://www.npmjs.com/package/idb-keyval). You can always upgrade to this library later.
+
+```js
+import { openDB } from 'idb';
+
+const dbPromise = openDB('keyval-store', 1, {
+  upgrade(db) {
+    db.createObjectStore('keyval');
+  },
+});
+
+export async function get(key) {
+  return (await dbPromise).get('keyval', key);
+}
+export async function set(key, val) {
+  return (await dbPromise).put('keyval', val, key);
+}
+export async function del(key) {
+  return (await dbPromise).delete('keyval', key);
+}
+export async function clear() {
+  return (await dbPromise).clear('keyval');
+}
+export async function keys() {
+  return (await dbPromise).getAllKeys('keyval');
+}
+```
+
+## Article store
+
+```js
+import { openDB } from 'idb/with-async-ittr.js';
+
+async function demo() {
+  const db = await openDB('Articles', 1, {
+    upgrade(db) {
+      // Create a store of objects
+      const store = db.createObjectStore('articles', {
+        // The 'id' property of the object will be the key.
+        keyPath: 'id',
+        // If it isn't explicitly set, create a value by auto incrementing.
+        autoIncrement: true,
+      });
+      // Create an index on the 'date' property of the objects.
+      store.createIndex('date', 'date');
+    },
+  });
+
+  // Add an article:
+  await db.add('articles', {
+    title: 'Article 1',
+    date: new Date('2019-01-01'),
+    body: '…',
+  });
+
+  // Add multiple articles in one transaction:
+  {
+    const tx = db.transaction('articles', 'readwrite');
+    await Promise.all([
+      tx.store.add({
+        title: 'Article 2',
+        date: new Date('2019-01-01'),
+        body: '…',
+      }),
+      tx.store.add({
+        title: 'Article 3',
+        date: new Date('2019-01-02'),
+        body: '…',
+      }),
+      tx.done,
+    ]);
+  }
+
+  // Get all the articles in date order:
+  console.log(await db.getAllFromIndex('articles', 'date'));
+
+  // Add 'And, happy new year!' to all articles on 2019-01-01:
+  {
+    const tx = db.transaction('articles', 'readwrite');
+    const index = tx.store.index('date');
+
+    for await (const cursor of index.iterate(new Date('2019-01-01'))) {
+      const article = { ...cursor.value };
+      article.body += ' And, happy new year!';
+      cursor.update(article);
+    }
+
+    await tx.done;
+  }
+}
+```
+
+# TypeScript
+
+This library is fully typed, and you can improve things by providing types for your database:
+
+```ts
+import { openDB, DBSchema } from 'idb';
+
+interface MyDB extends DBSchema {
+  'favourite-number': {
+    key: string;
+    value: number;
+  };
+  products: {
+    value: {
+      name: string;
+      price: number;
+      productCode: string;
+    };
+    key: string;
+    indexes: { 'by-price': number };
+  };
+}
+
+async function demo() {
+  const db = await openDB<MyDB>('my-db', 1, {
+    upgrade(db) {
+      db.createObjectStore('favourite-number');
+
+      const productStore = db.createObjectStore('products', {
+        keyPath: 'productCode',
+      });
+      productStore.createIndex('by-price', 'price');
+    },
+  });
+
+  // This works
+  await db.put('favourite-number', 7, 'Jen');
+  // This fails at compile time, as the 'favourite-number' store expects a number.
+  await db.put('favourite-number', 'Twelve', 'Jake');
+}
+```
+
+To define types for your database, extend `DBSchema` with an interface where the keys are the names of your object stores.
+
+For each value, provide an object where `value` is the type of values within the store, and `key` is the type of keys within the store.
+
+Optionally, `indexes` can contain a map of index names, to the type of key within that index.
+
+Provide this interface when calling `openDB`, and from then on your database will be strongly typed. This also allows your IDE to autocomplete the names of stores and indexes.
+
+## Opting out of types
+
+If you call `openDB` without providing types, your database will use basic types. However, sometimes you'll need to interact with stores that aren't in your schema, perhaps during upgrades. In that case you can cast.
+
+Let's say we were renaming the 'favourite-number' store to 'fave-nums':
+
+```ts
+import { openDB, DBSchema, IDBPDatabase } from 'idb';
+
+interface MyDBV1 extends DBSchema {
+  'favourite-number': { key: string; value: number };
+}
+
+interface MyDBV2 extends DBSchema {
+  'fave-num': { key: string; value: number };
+}
+
+const db = await openDB<MyDBV2>('my-db', 2, {
+  async upgrade(db, oldVersion) {
+    // Cast a reference of the database to the old schema.
+    const v1Db = db as unknown as IDBPDatabase<MyDBV1>;
+
+    if (oldVersion < 1) {
+      v1Db.createObjectStore('favourite-number');
+    }
+    if (oldVersion < 2) {
+      const store = v1Db.createObjectStore('favourite-number');
+      store.name = 'fave-num';
+    }
+  },
+});
+```
+
+You can also cast to a typeless database by omitting the type, eg `db as IDBPDatabase`.
+
+Note: Types like `IDBPDatabase` are used by TypeScript only. The implementation uses proxies under the hood.
+
+# Developing
+
+```sh
+npm run dev
+```
+
+This will also perform type testing.
+
+To test, navigate to `build/test/` in a browser. You'll need to set up a [basic web server](https://www.npmjs.com/package/serve) for this.

pwa/node_modules/workbox-background-sync/node_modules/idb/build/async-iterators.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+var wrapIdbValue = require('./wrap-idb-value.cjs');
+
+const advanceMethodProps = ['continue', 'continuePrimaryKey', 'advance'];
+const methodMap = {};
+const advanceResults = new WeakMap();
+const ittrProxiedCursorToOriginalProxy = new WeakMap();
+const cursorIteratorTraps = {
+    get(target, prop) {
+        if (!advanceMethodProps.includes(prop))
+            return target[prop];
+        let cachedFunc = methodMap[prop];
+        if (!cachedFunc) {
+            cachedFunc = methodMap[prop] = function (...args) {
+                advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
+            };
+        }
+        return cachedFunc;
+    },
+};
+async function* iterate(...args) {
+    // tslint:disable-next-line:no-this-assignment
+    let cursor = this;
+    if (!(cursor instanceof IDBCursor)) {
+        cursor = await cursor.openCursor(...args);
+    }
+    if (!cursor)
+        return;
+    cursor = cursor;
+    const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+    ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+    // Map this double-proxy back to the original, so other cursor methods work.
+    wrapIdbValue.reverseTransformCache.set(proxiedCursor, wrapIdbValue.unwrap(cursor));
+    while (cursor) {
+        yield proxiedCursor;
+        // If one of the advancing methods was not called, call continue().
+        cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
+        advanceResults.delete(proxiedCursor);
+    }
+}
+function isIteratorProp(target, prop) {
+    return ((prop === Symbol.asyncIterator &&
+        wrapIdbValue.instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor])) ||
+        (prop === 'iterate' && wrapIdbValue.instanceOfAny(target, [IDBIndex, IDBObjectStore])));
+}
+wrapIdbValue.replaceTraps((oldTraps) => ({
+    ...oldTraps,
+    get(target, prop, receiver) {
+        if (isIteratorProp(target, prop))
+            return iterate;
+        return oldTraps.get(target, prop, receiver);
+    },
+    has(target, prop) {
+        return isIteratorProp(target, prop) || oldTraps.has(target, prop);
+    },
+}));

pwa/node_modules/workbox-background-sync/node_modules/idb/build/async-iterators.d.ts

@@ -0,0 +1 @@
+export {};

pwa/node_modules/workbox-background-sync/node_modules/idb/build/async-iterators.js

@@ -0,0 +1,55 @@
+import { r as replaceTraps, a as reverseTransformCache, u as unwrap, i as instanceOfAny } from './wrap-idb-value.js';
+
+const advanceMethodProps = ['continue', 'continuePrimaryKey', 'advance'];
+const methodMap = {};
+const advanceResults = new WeakMap();
+const ittrProxiedCursorToOriginalProxy = new WeakMap();
+const cursorIteratorTraps = {
+    get(target, prop) {
+        if (!advanceMethodProps.includes(prop))
+            return target[prop];
+        let cachedFunc = methodMap[prop];
+        if (!cachedFunc) {
+            cachedFunc = methodMap[prop] = function (...args) {
+                advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
+            };
+        }
+        return cachedFunc;
+    },
+};
+async function* iterate(...args) {
+    // tslint:disable-next-line:no-this-assignment
+    let cursor = this;
+    if (!(cursor instanceof IDBCursor)) {
+        cursor = await cursor.openCursor(...args);
+    }
+    if (!cursor)
+        return;
+    cursor = cursor;
+    const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+    ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+    // Map this double-proxy back to the original, so other cursor methods work.
+    reverseTransformCache.set(proxiedCursor, unwrap(cursor));
+    while (cursor) {
+        yield proxiedCursor;
+        // If one of the advancing methods was not called, call continue().
+        cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
+        advanceResults.delete(proxiedCursor);
+    }
+}
+function isIteratorProp(target, prop) {
+    return ((prop === Symbol.asyncIterator &&
+        instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor])) ||
+        (prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore])));
+}
+replaceTraps((oldTraps) => ({
+    ...oldTraps,
+    get(target, prop, receiver) {
+        if (isIteratorProp(target, prop))
+            return iterate;
+        return oldTraps.get(target, prop, receiver);
+    },
+    has(target, prop) {
+        return isIteratorProp(target, prop) || oldTraps.has(target, prop);
+    },
+}));

pwa/node_modules/workbox-background-sync/node_modules/idb/build/database-extras.d.ts

@@ -0,0 +1 @@
+export {};

pwa/node_modules/workbox-background-sync/node_modules/idb/build/entry.d.ts

@@ -0,0 +1,627 @@
+export interface OpenDBCallbacks<DBTypes extends DBSchema | unknown> {
+    /**
+     * Called if this version of the database has never been opened before. Use it to specify the
+     * schema for the database.
+     *
+     * @param database A database instance that you can use to add/remove stores and indexes.
+     * @param oldVersion Last version of the database opened by the user.
+     * @param newVersion Whatever new version you provided.
+     * @param transaction The transaction for this upgrade.
+     * This is useful if you need to get data from other stores as part of a migration.
+     * @param event The event object for the associated 'upgradeneeded' event.
+     */
+    upgrade?(database: IDBPDatabase<DBTypes>, oldVersion: number, newVersion: number | null, transaction: IDBPTransaction<DBTypes, StoreNames<DBTypes>[], 'versionchange'>, event: IDBVersionChangeEvent): void;
+    /**
+     * Called if there are older versions of the database open on the origin, so this version cannot
+     * open.
+     *
+     * @param currentVersion Version of the database that's blocking this one.
+     * @param blockedVersion The version of the database being blocked (whatever version you provided to `openDB`).
+     * @param event The event object for the associated `blocked` event.
+     */
+    blocked?(currentVersion: number, blockedVersion: number | null, event: IDBVersionChangeEvent): void;
+    /**
+     * Called if this connection is blocking a future version of the database from opening.
+     *
+     * @param currentVersion Version of the open database (whatever version you provided to `openDB`).
+     * @param blockedVersion The version of the database that's being blocked.
+     * @param event The event object for the associated `versionchange` event.
+     */
+    blocking?(currentVersion: number, blockedVersion: number | null, event: IDBVersionChangeEvent): void;
+    /**
+     * Called if the browser abnormally terminates the connection.
+     * This is not called when `db.close()` is called.
+     */
+    terminated?(): void;
+}
+/**
+ * Open a database.
+ *
+ * @param name Name of the database.
+ * @param version Schema version.
+ * @param callbacks Additional callbacks.
+ */
+export declare function openDB<DBTypes extends DBSchema | unknown = unknown>(name: string, version?: number, { blocked, upgrade, blocking, terminated }?: OpenDBCallbacks<DBTypes>): Promise<IDBPDatabase<DBTypes>>;
+export interface DeleteDBCallbacks {
+    /**
+     * Called if there are connections to this database open, so it cannot be deleted.
+     *
+     * @param currentVersion Version of the database that's blocking the delete operation.
+     * @param event The event object for the associated `blocked` event.
+     */
+    blocked?(currentVersion: number, event: IDBVersionChangeEvent): void;
+}
+/**
+ * Delete a database.
+ *
+ * @param name Name of the database.
+ */
+export declare function deleteDB(name: string, { blocked }?: DeleteDBCallbacks): Promise<void>;
+export { unwrap, wrap } from './wrap-idb-value.js';
+declare type KeyToKeyNoIndex<T> = {
+    [K in keyof T]: string extends K ? never : number extends K ? never : K;
+};
+declare type ValuesOf<T> = T extends {
+    [K in keyof T]: infer U;
+} ? U : never;
+declare type KnownKeys<T> = ValuesOf<KeyToKeyNoIndex<T>>;
+declare type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
+export interface DBSchema {
+    [s: string]: DBSchemaValue;
+}
+interface IndexKeys {
+    [s: string]: IDBValidKey;
+}
+interface DBSchemaValue {
+    key: IDBValidKey;
+    value: any;
+    indexes?: IndexKeys;
+}
+/**
+ * Extract known object store names from the DB schema type.
+ *
+ * @template DBTypes DB schema type, or unknown if the DB isn't typed.
+ */
+export declare type StoreNames<DBTypes extends DBSchema | unknown> = DBTypes extends DBSchema ? KnownKeys<DBTypes> : string;
+/**
+ * Extract database value types from the DB schema type.
+ *
+ * @template DBTypes DB schema type, or unknown if the DB isn't typed.
+ * @template StoreName Names of the object stores to get the types of.
+ */
+export declare type StoreValue<DBTypes extends DBSchema | unknown, StoreName extends StoreNames<DBTypes>> = DBTypes extends DBSchema ? DBTypes[StoreName]['value'] : any;
+/**
+ * Extract database key types from the DB schema type.
+ *
+ * @template DBTypes DB schema type, or unknown if the DB isn't typed.
+ * @template StoreName Names of the object stores to get the types of.
+ */
+export declare type StoreKey<DBTypes extends DBSchema | unknown, StoreName extends StoreNames<DBTypes>> = DBTypes extends DBSchema ? DBTypes[StoreName]['key'] : IDBValidKey;
+/**
+ * Extract the names of indexes in certain object stores from the DB schema type.
+ *
+ * @template DBTypes DB schema type, or unknown if the DB isn't typed.
+ * @template StoreName Names of the object stores to get the types of.
+ */
+export declare type IndexNames<DBTypes extends DBSchema | unknown, StoreName extends StoreNames<DBTypes>> = DBTypes extends DBSchema ? keyof DBTypes[StoreName]['indexes'] : string;
+/**
+ * Extract the types of indexes in certain object stores from the DB schema type.
+ *
+ * @template DBTypes DB schema type, or unknown if the DB isn't typed.
+ * @template StoreName Names of the object stores to get the types of.
+ * @template IndexName Names of the indexes to get the types of.
+ */
+export declare type IndexKey<DBTypes extends DBSchema | unknown, StoreName extends StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName>> = DBTypes extends DBSchema ? IndexName extends keyof DBTypes[StoreName]['indexes'] ? DBTypes[StoreName]['indexes'][IndexName] : IDBValidKey : IDBValidKey;
+declare type CursorSource<DBTypes extends DBSchema | unknown, TxStores extends ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown, Mode extends IDBTransactionMode = 'readonly'> = IndexName extends IndexNames<DBTypes, StoreName> ? IDBPIndex<DBTypes, TxStores, StoreName, IndexName, Mode> : IDBPObjectStore<DBTypes, TxStores, StoreName, Mode>;
+declare type CursorKey<DBTypes extends DBSchema | unknown, StoreName extends StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown> = IndexName extends IndexNames<DBTypes, StoreName> ? IndexKey<DBTypes, StoreName, IndexName> : StoreKey<DBTypes, StoreName>;
+declare type IDBPDatabaseExtends = Omit<IDBDatabase, 'createObjectStore' | 'deleteObjectStore' | 'transaction' | 'objectStoreNames'>;
+/**
+ * A variation of DOMStringList with precise string types
+ */
+export interface TypedDOMStringList<T extends string> extends DOMStringList {
+    contains(string: T): boolean;
+    item(index: number): T | null;
+    [index: number]: T;
+    [Symbol.iterator](): IterableIterator<T>;
+}
+interface IDBTransactionOptions {
+    /**
+     * The durability of the transaction.
+     *
+     * The default is "default". Using "relaxed" provides better performance, but with fewer
+     * guarantees. Web applications are encouraged to use "relaxed" for ephemeral data such as caches
+     * or quickly changing records, and "strict" in cases where reducing the risk of data loss
+     * outweighs the impact to performance and power.
+     */
+    durability?: 'default' | 'strict' | 'relaxed';
+}
+export interface IDBPDatabase<DBTypes extends DBSchema | unknown = unknown> extends IDBPDatabaseExtends {
+    /**
+     * The names of stores in the database.
+     */
+    readonly objectStoreNames: TypedDOMStringList<StoreNames<DBTypes>>;
+    /**
+     * Creates a new object store.
+     *
+     * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
+     */
+    createObjectStore<Name extends StoreNames<DBTypes>>(name: Name, optionalParameters?: IDBObjectStoreParameters): IDBPObjectStore<DBTypes, ArrayLike<StoreNames<DBTypes>>, Name, 'versionchange'>;
+    /**
+     * Deletes the object store with the given name.
+     *
+     * Throws a "InvalidStateError" DOMException if not called within an upgrade transaction.
+     */
+    deleteObjectStore(name: StoreNames<DBTypes>): void;
+    /**
+     * Start a new transaction.
+     *
+     * @param storeNames The object store(s) this transaction needs.
+     * @param mode
+     * @param options
+     */
+    transaction<Name extends StoreNames<DBTypes>, Mode extends IDBTransactionMode = 'readonly'>(storeNames: Name, mode?: Mode, options?: IDBTransactionOptions): IDBPTransaction<DBTypes, [Name], Mode>;
+    transaction<Names extends ArrayLike<StoreNames<DBTypes>>, Mode extends IDBTransactionMode = 'readonly'>(storeNames: Names, mode?: Mode, options?: IDBTransactionOptions): IDBPTransaction<DBTypes, Names, Mode>;
+    /**
+     * Add a value to a store.
+     *
+     * Rejects if an item of a given key already exists in the store.
+     *
+     * This is a shortcut that creates a transaction for this single action. If you need to do more
+     * than one action, create a transaction instead.
+     *
+     * @param storeName Name of the store.
+     * @param value
+     * @param key
+     */
+    add<Name extends StoreNames<DBTypes>>(storeName: Name, value: StoreValue<DBTypes, Name>, key?: StoreKey<DBTypes, Name> | IDBKeyRange): Promise<StoreKey<DBTypes, Name>>;
+    /**
+     * Deletes all records in a store.
+     *
+     * This is a shortcut that creates a transaction for this single action. If you need to do more
+     * than one action, create a transaction instead.
+     *
+     * @param storeName Name of the store.
+     */
+    clear(name: StoreNames<DBTypes>): Promise<void>;
+    /**
+     * Retrieves the number of records matching the given query in a store.
+     *
+     * This is a shortcut that creates a transaction for this single action. If you need to do more
+     * than one action, create a transaction instead.
+     *
+     * @param storeName Name of the store.
+     * @param key
+     */
+    count<Name extends StoreNames<DBTypes>>(storeName: Name, key?: StoreKey<DBTypes, Name> | IDBKeyRange | null): Promise<number>;
+    /**
+     * Retrieves the number of records matching the given query in an index.
+     *
+     * This is a shortcut that creates a transaction for this single action. If you need to do more
+     * than one action, create a transaction instead.
+     *
+     * @param storeName Name of the store.
+     * @param indexName Name of the index within the store.
+     * @param key
+     */
+    countFromIndex<Name extends StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, Name>>(storeName: Name, indexName: IndexName, key?: IndexKey<DBTypes, Name, IndexName> | IDBKeyRange | null): Promise<number>;
+    /**
+     * Deletes records in a store matching the given query.
+     *
+     * This is a shortcut that creates a transaction for this single action. If you need to do more
+     * than one action, create a transaction instead.
+     *
+     * @param storeName Name of the store.
+     * @param key
+     */
+    delete<Name extends StoreNames<DBTypes>>(storeName: Name, key: StoreKey<DBTypes, Name> | IDBKeyRange): Promise<void>;
+    /**
+     * Retrieves the value of the first record in a store matching the query.
+     *
+     * Resolves with undefined if no match is found.
+     *
+     * This is a shortcut that creates a transaction for this single action. If you need to do more
+     * than one action, create a transaction instead.
+     *
+     * @param storeName Name of the store.
+     * @param query
+     */
+    get<Name extends StoreNames<DBTypes>>(storeName: Name, query: StoreKey<DBTypes, Name> | IDBKeyRange): Promise<StoreValue<DBTypes, Name> | undefined>;
+    /**
+     * Retrieves the value of the first record in an index matching the query.
+     *
+     * Resolves with undefined if no match is found.
+     *
+     * This is a shortcut that creates a transaction for this single action. If you need to do more
+     * than one action, create a transaction instead.
+     *
+     * @param storeName Name of the store.
+     * @param indexName Name of the index within the store.
+     * @param query
+     */
+    getFromIndex<Name extends StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, Name>>(storeName: Name, indexName: IndexName, query: IndexKey<DBTypes, Name, IndexName> | IDBKeyRange): Promise<StoreValue<DBTypes, Name> | undefined>;
+    /**
+     * Retrieves all values in a store that match the query.
+     *
+     * This is a shortcut that creates a transaction for this single action. If you need to do more
+     * than one action, create a transaction instead.
+     *
+     * @param storeName Name of the store.
+     * @param query
+     * @param count Maximum number of values to return.
+     */
+    getAll<Name extends StoreNames<DBTypes>>(storeName: Name, query?: StoreKey<DBTypes, Name> | IDBKeyRange | null, count?: number): Promise<StoreValue<DBTypes, Name>[]>;
+    /**
+     * Retrieves all values in an index that match the query.
+     *
+     * This is a shortcut that creates a transaction for this single action. If you need to do more
+     * than one action, create a transaction instead.
+     *
+     * @param storeName Name of the store.
+     * @param indexName Name of the index within the store.
+     * @param query
+     * @param count Maximum number of values to return.
+     */
+    getAllFromIndex<Name extends StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, Name>>(storeName: Name, indexName: IndexName, query?: IndexKey<DBTypes, Name, IndexName> | IDBKeyRange | null, count?: number): Promise<StoreValue<DBTypes, Name>[]>;
+    /**
+     * Retrieves the keys of records in a store matching the query.
+     *
+     * This is a shortcut that creates a transaction for this single action. If you need to do more
+     * than one action, create a transaction instead.
+     *
+     * @param storeName Name of the store.
+     * @param query
+     * @param count Maximum number of keys to return.
+     */
+    getAllKeys<Name extends StoreNames<DBTypes>>(storeName: Name, query?: StoreKey<DBTypes, Name> | IDBKeyRange | null, count?: number): Promise<StoreKey<DBTypes, Name>[]>;
+    /**
+     * Retrieves the keys of records in an index matching the query.
+     *
+     * This is a shortcut that creates a transaction for this single action. If you need to do more
+     * than one action, create a transaction instead.
+     *
+     * @param storeName Name of the store.
+     * @param indexName Name of the index within the store.
+     * @param query
+     * @param count Maximum number of keys to return.
+     */
+    getAllKeysFromIndex<Name extends StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, Name>>(storeName: Name, indexName: IndexName, query?: IndexKey<DBTypes, Name, IndexName> | IDBKeyRange | null, count?: number): Promise<StoreKey<DBTypes, Name>[]>;
+    /**
+     * Retrieves the key of the first record in a store that matches the query.
+     *
+     * Resolves with undefined if no match is found.
+     *
+     * This is a shortcut that creates a transaction for this single action. If you need to do more
+     * than one action, create a transaction instead.
+     *
+     * @param storeName Name of the store.
+     * @param query
+     */
+    getKey<Name extends StoreNames<DBTypes>>(storeName: Name, query: StoreKey<DBTypes, Name> | IDBKeyRange): Promise<StoreKey<DBTypes, Name> | undefined>;
+    /**
+     * Retrieves the key of the first record in an index that matches the query.
+     *
+     * Resolves with undefined if no match is found.
+     *
+     * This is a shortcut that creates a transaction for this single action. If you need to do more
+     * than one action, create a transaction instead.
+     *
+     * @param storeName Name of the store.
+     * @param indexName Name of the index within the store.
+     * @param query
+     */
+    getKeyFromIndex<Name extends StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, Name>>(storeName: Name, indexName: IndexName, query: IndexKey<DBTypes, Name, IndexName> | IDBKeyRange): Promise<StoreKey<DBTypes, Name> | undefined>;
+    /**
+     * Put an item in the database.
+     *
+     * Replaces any item with the same key.
+     *
+     * This is a shortcut that creates a transaction for this single action. If you need to do more
+     * than one action, create a transaction instead.
+     *
+     * @param storeName Name of the store.
+     * @param value
+     * @param key
+     */
+    put<Name extends StoreNames<DBTypes>>(storeName: Name, value: StoreValue<DBTypes, Name>, key?: StoreKey<DBTypes, Name> | IDBKeyRange): Promise<StoreKey<DBTypes, Name>>;
+}
+declare type IDBPTransactionExtends = Omit<IDBTransaction, 'db' | 'objectStore' | 'objectStoreNames'>;
+export interface IDBPTransaction<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, Mode extends IDBTransactionMode = 'readonly'> extends IDBPTransactionExtends {
+    /**
+     * The transaction's mode.
+     */
+    readonly mode: Mode;
+    /**
+     * The names of stores in scope for this transaction.
+     */
+    readonly objectStoreNames: TypedDOMStringList<TxStores[number]>;
+    /**
+     * The transaction's connection.
+     */
+    readonly db: IDBPDatabase<DBTypes>;
+    /**
+     * Promise for the completion of this transaction.
+     */
+    readonly done: Promise<void>;
+    /**
+     * The associated object store, if the transaction covers a single store, otherwise undefined.
+     */
+    readonly store: TxStores[1] extends undefined ? IDBPObjectStore<DBTypes, TxStores, TxStores[0], Mode> : undefined;
+    /**
+     * Returns an IDBObjectStore in the transaction's scope.
+     */
+    objectStore<StoreName extends TxStores[number]>(name: StoreName): IDBPObjectStore<DBTypes, TxStores, StoreName, Mode>;
+}
+declare type IDBPObjectStoreExtends = Omit<IDBObjectStore, 'transaction' | 'add' | 'clear' | 'count' | 'createIndex' | 'delete' | 'get' | 'getAll' | 'getAllKeys' | 'getKey' | 'index' | 'openCursor' | 'openKeyCursor' | 'put' | 'indexNames'>;
+export interface IDBPObjectStore<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, Mode extends IDBTransactionMode = 'readonly'> extends IDBPObjectStoreExtends {
+    /**
+     * The names of indexes in the store.
+     */
+    readonly indexNames: TypedDOMStringList<IndexNames<DBTypes, StoreName>>;
+    /**
+     * The associated transaction.
+     */
+    readonly transaction: IDBPTransaction<DBTypes, TxStores, Mode>;
+    /**
+     * Add a value to the store.
+     *
+     * Rejects if an item of a given key already exists in the store.
+     */
+    add: Mode extends 'readonly' ? undefined : (value: StoreValue<DBTypes, StoreName>, key?: StoreKey<DBTypes, StoreName> | IDBKeyRange) => Promise<StoreKey<DBTypes, StoreName>>;
+    /**
+     * Deletes all records in store.
+     */
+    clear: Mode extends 'readonly' ? undefined : () => Promise<void>;
+    /**
+     * Retrieves the number of records matching the given query.
+     */
+    count(key?: StoreKey<DBTypes, StoreName> | IDBKeyRange | null): Promise<number>;
+    /**
+     * Creates a new index in store.
+     *
+     * Throws an "InvalidStateError" DOMException if not called within an upgrade transaction.
+     */
+    createIndex: Mode extends 'versionchange' ? <IndexName extends IndexNames<DBTypes, StoreName>>(name: IndexName, keyPath: string | string[], options?: IDBIndexParameters) => IDBPIndex<DBTypes, TxStores, StoreName, IndexName, Mode> : undefined;
+    /**
+     * Deletes records in store matching the given query.
+     */
+    delete: Mode extends 'readonly' ? undefined : (key: StoreKey<DBTypes, StoreName> | IDBKeyRange) => Promise<void>;
+    /**
+     * Retrieves the value of the first record matching the query.
+     *
+     * Resolves with undefined if no match is found.
+     */
+    get(query: StoreKey<DBTypes, StoreName> | IDBKeyRange): Promise<StoreValue<DBTypes, StoreName> | undefined>;
+    /**
+     * Retrieves all values that match the query.
+     *
+     * @param query
+     * @param count Maximum number of values to return.
+     */
+    getAll(query?: StoreKey<DBTypes, StoreName> | IDBKeyRange | null, count?: number): Promise<StoreValue<DBTypes, StoreName>[]>;
+    /**
+     * Retrieves the keys of records matching the query.
+     *
+     * @param query
+     * @param count Maximum number of keys to return.
+     */
+    getAllKeys(query?: StoreKey<DBTypes, StoreName> | IDBKeyRange | null, count?: number): Promise<StoreKey<DBTypes, StoreName>[]>;
+    /**
+     * Retrieves the key of the first record that matches the query.
+     *
+     * Resolves with undefined if no match is found.
+     */
+    getKey(query: StoreKey<DBTypes, StoreName> | IDBKeyRange): Promise<StoreKey<DBTypes, StoreName> | undefined>;
+    /**
+     * Get a query of a given name.
+     */
+    index<IndexName extends IndexNames<DBTypes, StoreName>>(name: IndexName): IDBPIndex<DBTypes, TxStores, StoreName, IndexName, Mode>;
+    /**
+     * Opens a cursor over the records matching the query.
+     *
+     * Resolves with null if no matches are found.
+     *
+     * @param query If null, all records match.
+     * @param direction
+     */
+    openCursor(query?: StoreKey<DBTypes, StoreName> | IDBKeyRange | null, direction?: IDBCursorDirection): Promise<IDBPCursorWithValue<DBTypes, TxStores, StoreName, unknown, Mode> | null>;
+    /**
+     * Opens a cursor over the keys matching the query.
+     *
+     * Resolves with null if no matches are found.
+     *
+     * @param query If null, all records match.
+     * @param direction
+     */
+    openKeyCursor(query?: StoreKey<DBTypes, StoreName> | IDBKeyRange | null, direction?: IDBCursorDirection): Promise<IDBPCursor<DBTypes, TxStores, StoreName, unknown, Mode> | null>;
+    /**
+     * Put an item in the store.
+     *
+     * Replaces any item with the same key.
+     */
+    put: Mode extends 'readonly' ? undefined : (value: StoreValue<DBTypes, StoreName>, key?: StoreKey<DBTypes, StoreName> | IDBKeyRange) => Promise<StoreKey<DBTypes, StoreName>>;
+    /**
+     * Iterate over the store.
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<IDBPCursorWithValueIteratorValue<DBTypes, TxStores, StoreName, unknown, Mode>>;
+    /**
+     * Iterate over the records matching the query.
+     *
+     * @param query If null, all records match.
+     * @param direction
+     */
+    iterate(query?: StoreKey<DBTypes, StoreName> | IDBKeyRange | null, direction?: IDBCursorDirection): AsyncIterableIterator<IDBPCursorWithValueIteratorValue<DBTypes, TxStores, StoreName, unknown, Mode>>;
+}
+declare type IDBPIndexExtends = Omit<IDBIndex, 'objectStore' | 'count' | 'get' | 'getAll' | 'getAllKeys' | 'getKey' | 'openCursor' | 'openKeyCursor'>;
+export interface IDBPIndex<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> = IndexNames<DBTypes, StoreName>, Mode extends IDBTransactionMode = 'readonly'> extends IDBPIndexExtends {
+    /**
+     * The IDBObjectStore the index belongs to.
+     */
+    readonly objectStore: IDBPObjectStore<DBTypes, TxStores, StoreName, Mode>;
+    /**
+     * Retrieves the number of records matching the given query.
+     */
+    count(key?: IndexKey<DBTypes, StoreName, IndexName> | IDBKeyRange | null): Promise<number>;
+    /**
+     * Retrieves the value of the first record matching the query.
+     *
+     * Resolves with undefined if no match is found.
+     */
+    get(query: IndexKey<DBTypes, StoreName, IndexName> | IDBKeyRange): Promise<StoreValue<DBTypes, StoreName> | undefined>;
+    /**
+     * Retrieves all values that match the query.
+     *
+     * @param query
+     * @param count Maximum number of values to return.
+     */
+    getAll(query?: IndexKey<DBTypes, StoreName, IndexName> | IDBKeyRange | null, count?: number): Promise<StoreValue<DBTypes, StoreName>[]>;
+    /**
+     * Retrieves the keys of records matching the query.
+     *
+     * @param query
+     * @param count Maximum number of keys to return.
+     */
+    getAllKeys(query?: IndexKey<DBTypes, StoreName, IndexName> | IDBKeyRange | null, count?: number): Promise<StoreKey<DBTypes, StoreName>[]>;
+    /**
+     * Retrieves the key of the first record that matches the query.
+     *
+     * Resolves with undefined if no match is found.
+     */
+    getKey(query: IndexKey<DBTypes, StoreName, IndexName> | IDBKeyRange): Promise<StoreKey<DBTypes, StoreName> | undefined>;
+    /**
+     * Opens a cursor over the records matching the query.
+     *
+     * Resolves with null if no matches are found.
+     *
+     * @param query If null, all records match.
+     * @param direction
+     */
+    openCursor(query?: IndexKey<DBTypes, StoreName, IndexName> | IDBKeyRange | null, direction?: IDBCursorDirection): Promise<IDBPCursorWithValue<DBTypes, TxStores, StoreName, IndexName, Mode> | null>;
+    /**
+     * Opens a cursor over the keys matching the query.
+     *
+     * Resolves with null if no matches are found.
+     *
+     * @param query If null, all records match.
+     * @param direction
+     */
+    openKeyCursor(query?: IndexKey<DBTypes, StoreName, IndexName> | IDBKeyRange | null, direction?: IDBCursorDirection): Promise<IDBPCursor<DBTypes, TxStores, StoreName, IndexName, Mode> | null>;
+    /**
+     * Iterate over the index.
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<IDBPCursorWithValueIteratorValue<DBTypes, TxStores, StoreName, IndexName, Mode>>;
+    /**
+     * Iterate over the records matching the query.
+     *
+     * Resolves with null if no matches are found.
+     *
+     * @param query If null, all records match.
+     * @param direction
+     */
+    iterate(query?: IndexKey<DBTypes, StoreName, IndexName> | IDBKeyRange | null, direction?: IDBCursorDirection): AsyncIterableIterator<IDBPCursorWithValueIteratorValue<DBTypes, TxStores, StoreName, IndexName, Mode>>;
+}
+declare type IDBPCursorExtends = Omit<IDBCursor, 'key' | 'primaryKey' | 'source' | 'advance' | 'continue' | 'continuePrimaryKey' | 'delete' | 'update'>;
+export interface IDBPCursor<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> extends IDBPCursorExtends {
+    /**
+     * The key of the current index or object store item.
+     */
+    readonly key: CursorKey<DBTypes, StoreName, IndexName>;
+    /**
+     * The key of the current object store item.
+     */
+    readonly primaryKey: StoreKey<DBTypes, StoreName>;
+    /**
+     * Returns the IDBObjectStore or IDBIndex the cursor was opened from.
+     */
+    readonly source: CursorSource<DBTypes, TxStores, StoreName, IndexName, Mode>;
+    /**
+     * Advances the cursor a given number of records.
+     *
+     * Resolves to null if no matching records remain.
+     */
+    advance<T>(this: T, count: number): Promise<T | null>;
+    /**
+     * Advance the cursor by one record (unless 'key' is provided).
+     *
+     * Resolves to null if no matching records remain.
+     *
+     * @param key Advance to the index or object store with a key equal to or greater than this value.
+     */
+    continue<T>(this: T, key?: CursorKey<DBTypes, StoreName, IndexName>): Promise<T | null>;
+    /**
+     * Advance the cursor by given keys.
+     *
+     * The operation is 'and' – both keys must be satisfied.
+     *
+     * Resolves to null if no matching records remain.
+     *
+     * @param key Advance to the index or object store with a key equal to or greater than this value.
+     * @param primaryKey and where the object store has a key equal to or greater than this value.
+     */
+    continuePrimaryKey<T>(this: T, key: CursorKey<DBTypes, StoreName, IndexName>, primaryKey: StoreKey<DBTypes, StoreName>): Promise<T | null>;
+    /**
+     * Delete the current record.
+     */
+    delete: Mode extends 'readonly' ? undefined : () => Promise<void>;
+    /**
+     * Updated the current record.
+     */
+    update: Mode extends 'readonly' ? undefined : (value: StoreValue<DBTypes, StoreName>) => Promise<StoreKey<DBTypes, StoreName>>;
+    /**
+     * Iterate over the cursor.
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<IDBPCursorIteratorValue<DBTypes, TxStores, StoreName, IndexName, Mode>>;
+}
+declare type IDBPCursorIteratorValueExtends<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> = Omit<IDBPCursor<DBTypes, TxStores, StoreName, IndexName, Mode>, 'advance' | 'continue' | 'continuePrimaryKey'>;
+export interface IDBPCursorIteratorValue<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> extends IDBPCursorIteratorValueExtends<DBTypes, TxStores, StoreName, IndexName, Mode> {
+    /**
+     * Advances the cursor a given number of records.
+     */
+    advance<T>(this: T, count: number): void;
+    /**
+     * Advance the cursor by one record (unless 'key' is provided).
+     *
+     * @param key Advance to the index or object store with a key equal to or greater than this value.
+     */
+    continue<T>(this: T, key?: CursorKey<DBTypes, StoreName, IndexName>): void;
+    /**
+     * Advance the cursor by given keys.
+     *
+     * The operation is 'and' – both keys must be satisfied.
+     *
+     * @param key Advance to the index or object store with a key equal to or greater than this value.
+     * @param primaryKey and where the object store has a key equal to or greater than this value.
+     */
+    continuePrimaryKey<T>(this: T, key: CursorKey<DBTypes, StoreName, IndexName>, primaryKey: StoreKey<DBTypes, StoreName>): void;
+}
+export interface IDBPCursorWithValue<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> extends IDBPCursor<DBTypes, TxStores, StoreName, IndexName, Mode> {
+    /**
+     * The value of the current item.
+     */
+    readonly value: StoreValue<DBTypes, StoreName>;
+    /**
+     * Iterate over the cursor.
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<IDBPCursorWithValueIteratorValue<DBTypes, TxStores, StoreName, IndexName, Mode>>;
+}
+declare type IDBPCursorWithValueIteratorValueExtends<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> = Omit<IDBPCursorWithValue<DBTypes, TxStores, StoreName, IndexName, Mode>, 'advance' | 'continue' | 'continuePrimaryKey'>;
+export interface IDBPCursorWithValueIteratorValue<DBTypes extends DBSchema | unknown = unknown, TxStores extends ArrayLike<StoreNames<DBTypes>> = ArrayLike<StoreNames<DBTypes>>, StoreName extends StoreNames<DBTypes> = StoreNames<DBTypes>, IndexName extends IndexNames<DBTypes, StoreName> | unknown = unknown, Mode extends IDBTransactionMode = 'readonly'> extends IDBPCursorWithValueIteratorValueExtends<DBTypes, TxStores, StoreName, IndexName, Mode> {
+    /**
+     * Advances the cursor a given number of records.
+     */
+    advance<T>(this: T, count: number): void;
+    /**
+     * Advance the cursor by one record (unless 'key' is provided).
+     *
+     * @param key Advance to the index or object store with a key equal to or greater than this value.
+     */
+    continue<T>(this: T, key?: CursorKey<DBTypes, StoreName, IndexName>): void;
+    /**
+     * Advance the cursor by given keys.
+     *
+     * The operation is 'and' – both keys must be satisfied.
+     *
+     * @param key Advance to the index or object store with a key equal to or greater than this value.
+     * @param primaryKey and where the object store has a key equal to or greater than this value.
+     */
+    continuePrimaryKey<T>(this: T, key: CursorKey<DBTypes, StoreName, IndexName>, primaryKey: StoreKey<DBTypes, StoreName>): void;
+}

pwa/node_modules/workbox-background-sync/node_modules/idb/build/index.cjs

@@ -0,0 +1,101 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var wrapIdbValue = require('./wrap-idb-value.cjs');
+
+/**
+ * Open a database.
+ *
+ * @param name Name of the database.
+ * @param version Schema version.
+ * @param callbacks Additional callbacks.
+ */
+function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
+    const request = indexedDB.open(name, version);
+    const openPromise = wrapIdbValue.wrap(request);
+    if (upgrade) {
+        request.addEventListener('upgradeneeded', (event) => {
+            upgrade(wrapIdbValue.wrap(request.result), event.oldVersion, event.newVersion, wrapIdbValue.wrap(request.transaction), event);
+        });
+    }
+    if (blocked) {
+        request.addEventListener('blocked', (event) => blocked(
+        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+        event.oldVersion, event.newVersion, event));
+    }
+    openPromise
+        .then((db) => {
+        if (terminated)
+            db.addEventListener('close', () => terminated());
+        if (blocking) {
+            db.addEventListener('versionchange', (event) => blocking(event.oldVersion, event.newVersion, event));
+        }
+    })
+        .catch(() => { });
+    return openPromise;
+}
+/**
+ * Delete a database.
+ *
+ * @param name Name of the database.
+ */
+function deleteDB(name, { blocked } = {}) {
+    const request = indexedDB.deleteDatabase(name);
+    if (blocked) {
+        request.addEventListener('blocked', (event) => blocked(
+        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+        event.oldVersion, event));
+    }
+    return wrapIdbValue.wrap(request).then(() => undefined);
+}
+
+const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
+const writeMethods = ['put', 'add', 'delete', 'clear'];
+const cachedMethods = new Map();
+function getMethod(target, prop) {
+    if (!(target instanceof IDBDatabase &&
+        !(prop in target) &&
+        typeof prop === 'string')) {
+        return;
+    }
+    if (cachedMethods.get(prop))
+        return cachedMethods.get(prop);
+    const targetFuncName = prop.replace(/FromIndex$/, '');
+    const useIndex = prop !== targetFuncName;
+    const isWrite = writeMethods.includes(targetFuncName);
+    if (
+    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) ||
+        !(isWrite || readMethods.includes(targetFuncName))) {
+        return;
+    }
+    const method = async function (storeName, ...args) {
+        // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
+        const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
+        let target = tx.store;
+        if (useIndex)
+            target = target.index(args.shift());
+        // Must reject if op rejects.
+        // If it's a write operation, must reject if tx.done rejects.
+        // Must reject with op rejection first.
+        // Must resolve with op value.
+        // Must handle both promises (no unhandled rejections)
+        return (await Promise.all([
+            target[targetFuncName](...args),
+            isWrite && tx.done,
+        ]))[0];
+    };
+    cachedMethods.set(prop, method);
+    return method;
+}
+wrapIdbValue.replaceTraps((oldTraps) => ({
+    ...oldTraps,
+    get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+    has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),
+}));
+
+exports.unwrap = wrapIdbValue.unwrap;
+exports.wrap = wrapIdbValue.wrap;
+exports.deleteDB = deleteDB;
+exports.openDB = openDB;

pwa/node_modules/workbox-background-sync/node_modules/idb/build/index.d.ts

@@ -0,0 +1,2 @@
+export * from './entry.js';
+import './database-extras.js';

pwa/node_modules/workbox-background-sync/node_modules/idb/build/index.js

@@ -0,0 +1,95 @@
+import { w as wrap, r as replaceTraps } from './wrap-idb-value.js';
+export { u as unwrap, w as wrap } from './wrap-idb-value.js';
+
+/**
+ * Open a database.
+ *
+ * @param name Name of the database.
+ * @param version Schema version.
+ * @param callbacks Additional callbacks.
+ */
+function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
+    const request = indexedDB.open(name, version);
+    const openPromise = wrap(request);
+    if (upgrade) {
+        request.addEventListener('upgradeneeded', (event) => {
+            upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
+        });
+    }
+    if (blocked) {
+        request.addEventListener('blocked', (event) => blocked(
+        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+        event.oldVersion, event.newVersion, event));
+    }
+    openPromise
+        .then((db) => {
+        if (terminated)
+            db.addEventListener('close', () => terminated());
+        if (blocking) {
+            db.addEventListener('versionchange', (event) => blocking(event.oldVersion, event.newVersion, event));
+        }
+    })
+        .catch(() => { });
+    return openPromise;
+}
+/**
+ * Delete a database.
+ *
+ * @param name Name of the database.
+ */
+function deleteDB(name, { blocked } = {}) {
+    const request = indexedDB.deleteDatabase(name);
+    if (blocked) {
+        request.addEventListener('blocked', (event) => blocked(
+        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+        event.oldVersion, event));
+    }
+    return wrap(request).then(() => undefined);
+}
+
+const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
+const writeMethods = ['put', 'add', 'delete', 'clear'];
+const cachedMethods = new Map();
+function getMethod(target, prop) {
+    if (!(target instanceof IDBDatabase &&
+        !(prop in target) &&
+        typeof prop === 'string')) {
+        return;
+    }
+    if (cachedMethods.get(prop))
+        return cachedMethods.get(prop);
+    const targetFuncName = prop.replace(/FromIndex$/, '');
+    const useIndex = prop !== targetFuncName;
+    const isWrite = writeMethods.includes(targetFuncName);
+    if (
+    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) ||
+        !(isWrite || readMethods.includes(targetFuncName))) {
+        return;
+    }
+    const method = async function (storeName, ...args) {
+        // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
+        const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
+        let target = tx.store;
+        if (useIndex)
+            target = target.index(args.shift());
+        // Must reject if op rejects.
+        // If it's a write operation, must reject if tx.done rejects.
+        // Must reject with op rejection first.
+        // Must resolve with op value.
+        // Must handle both promises (no unhandled rejections)
+        return (await Promise.all([
+            target[targetFuncName](...args),
+            isWrite && tx.done,
+        ]))[0];
+    };
+    cachedMethods.set(prop, method);
+    return method;
+}
+replaceTraps((oldTraps) => ({
+    ...oldTraps,
+    get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+    has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),
+}));
+
+export { deleteDB, openDB };

pwa/node_modules/workbox-background-sync/node_modules/idb/build/umd-with-async-ittr.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).idb={})}(this,(function(e){"use strict";const t=(e,t)=>t.some((t=>e instanceof t));let n,r;const o=new WeakMap,s=new WeakMap,i=new WeakMap,a=new WeakMap,c=new WeakMap;let u={get(e,t,n){if(e instanceof IDBTransaction){if("done"===t)return s.get(e);if("objectStoreNames"===t)return e.objectStoreNames||i.get(e);if("store"===t)return n.objectStoreNames[1]?void 0:n.objectStore(n.objectStoreNames[0])}return p(e[t])},set:(e,t,n)=>(e[t]=n,!0),has:(e,t)=>e instanceof IDBTransaction&&("done"===t||"store"===t)||t in e};function d(e){u=e(u)}function f(e){return e!==IDBDatabase.prototype.transaction||"objectStoreNames"in IDBTransaction.prototype?(r||(r=[IDBCursor.prototype.advance,IDBCursor.prototype.continue,IDBCursor.prototype.continuePrimaryKey])).includes(e)?function(...t){return e.apply(D(this),t),p(o.get(this))}:function(...t){return p(e.apply(D(this),t))}:function(t,...n){const r=e.call(D(this),t,...n);return i.set(r,t.sort?t.sort():[t]),p(r)}}function l(e){return"function"==typeof e?f(e):(e instanceof IDBTransaction&&function(e){if(s.has(e))return;const t=new Promise(((t,n)=>{const r=()=>{e.removeEventListener("complete",o),e.removeEventListener("error",s),e.removeEventListener("abort",s)},o=()=>{t(),r()},s=()=>{n(e.error||new DOMException("AbortError","AbortError")),r()};e.addEventListener("complete",o),e.addEventListener("error",s),e.addEventListener("abort",s)}));s.set(e,t)}(e),t(e,n||(n=[IDBDatabase,IDBObjectStore,IDBIndex,IDBCursor,IDBTransaction]))?new Proxy(e,u):e)}function p(e){if(e instanceof IDBRequest)return function(e){const t=new Promise(((t,n)=>{const r=()=>{e.removeEventListener("success",o),e.removeEventListener("error",s)},o=()=>{t(p(e.result)),r()},s=()=>{n(e.error),r()};e.addEventListener("success",o),e.addEventListener("error",s)}));return t.then((t=>{t instanceof IDBCursor&&o.set(t,e)})).catch((()=>{})),c.set(t,e),t}(e);if(a.has(e))return a.get(e);const t=l(e);return t!==e&&(a.set(e,t),c.set(t,e)),t}const D=e=>c.get(e);const I=["get","getKey","getAll","getAllKeys","count"],b=["put","add","delete","clear"],y=new Map;function B(e,t){if(!(e instanceof IDBDatabase)||t in e||"string"!=typeof t)return;if(y.get(t))return y.get(t);const n=t.replace(/FromIndex$/,""),r=t!==n,o=b.includes(n);if(!(n in(r?IDBIndex:IDBObjectStore).prototype)||!o&&!I.includes(n))return;const s=async function(e,...t){const s=this.transaction(e,o?"readwrite":"readonly");let i=s.store;return r&&(i=i.index(t.shift())),(await Promise.all([i[n](...t),o&&s.done]))[0]};return y.set(t,s),s}d((e=>({...e,get:(t,n,r)=>B(t,n)||e.get(t,n,r),has:(t,n)=>!!B(t,n)||e.has(t,n)})));const g=["continue","continuePrimaryKey","advance"],h={},v=new WeakMap,m=new WeakMap,w={get(e,t){if(!g.includes(t))return e[t];let n=h[t];return n||(n=h[t]=function(...e){v.set(this,m.get(this)[t](...e))}),n}};async function*E(...e){let t=this;if(t instanceof IDBCursor||(t=await t.openCursor(...e)),!t)return;const n=new Proxy(t,w);for(m.set(n,t),c.set(n,D(t));t;)yield n,t=await(v.get(n)||t.continue()),v.delete(n)}function L(e,n){return n===Symbol.asyncIterator&&t(e,[IDBIndex,IDBObjectStore,IDBCursor])||"iterate"===n&&t(e,[IDBIndex,IDBObjectStore])}d((e=>({...e,get:(t,n,r)=>L(t,n)?E:e.get(t,n,r),has:(t,n)=>L(t,n)||e.has(t,n)}))),e.deleteDB=function(e,{blocked:t}={}){const n=indexedDB.deleteDatabase(e);return t&&n.addEventListener("blocked",(e=>t(e.oldVersion,e))),p(n).then((()=>{}))},e.openDB=function(e,t,{blocked:n,upgrade:r,blocking:o,terminated:s}={}){const i=indexedDB.open(e,t),a=p(i);return r&&i.addEventListener("upgradeneeded",(e=>{r(p(i.result),e.oldVersion,e.newVersion,p(i.transaction),e)})),n&&i.addEventListener("blocked",(e=>n(e.oldVersion,e.newVersion,e))),a.then((e=>{s&&e.addEventListener("close",(()=>s())),o&&e.addEventListener("versionchange",(e=>o(e.oldVersion,e.newVersion,e)))})).catch((()=>{})),a},e.unwrap=D,e.wrap=p}));

pwa/node_modules/workbox-background-sync/node_modules/idb/build/umd.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).idb={})}(this,(function(e){"use strict";let t,n;const r=new WeakMap,o=new WeakMap,s=new WeakMap,i=new WeakMap,a=new WeakMap;let c={get(e,t,n){if(e instanceof IDBTransaction){if("done"===t)return o.get(e);if("objectStoreNames"===t)return e.objectStoreNames||s.get(e);if("store"===t)return n.objectStoreNames[1]?void 0:n.objectStore(n.objectStoreNames[0])}return f(e[t])},set:(e,t,n)=>(e[t]=n,!0),has:(e,t)=>e instanceof IDBTransaction&&("done"===t||"store"===t)||t in e};function d(e){return e!==IDBDatabase.prototype.transaction||"objectStoreNames"in IDBTransaction.prototype?(n||(n=[IDBCursor.prototype.advance,IDBCursor.prototype.continue,IDBCursor.prototype.continuePrimaryKey])).includes(e)?function(...t){return e.apply(l(this),t),f(r.get(this))}:function(...t){return f(e.apply(l(this),t))}:function(t,...n){const r=e.call(l(this),t,...n);return s.set(r,t.sort?t.sort():[t]),f(r)}}function u(e){return"function"==typeof e?d(e):(e instanceof IDBTransaction&&function(e){if(o.has(e))return;const t=new Promise(((t,n)=>{const r=()=>{e.removeEventListener("complete",o),e.removeEventListener("error",s),e.removeEventListener("abort",s)},o=()=>{t(),r()},s=()=>{n(e.error||new DOMException("AbortError","AbortError")),r()};e.addEventListener("complete",o),e.addEventListener("error",s),e.addEventListener("abort",s)}));o.set(e,t)}(e),n=e,(t||(t=[IDBDatabase,IDBObjectStore,IDBIndex,IDBCursor,IDBTransaction])).some((e=>n instanceof e))?new Proxy(e,c):e);var n}function f(e){if(e instanceof IDBRequest)return function(e){const t=new Promise(((t,n)=>{const r=()=>{e.removeEventListener("success",o),e.removeEventListener("error",s)},o=()=>{t(f(e.result)),r()},s=()=>{n(e.error),r()};e.addEventListener("success",o),e.addEventListener("error",s)}));return t.then((t=>{t instanceof IDBCursor&&r.set(t,e)})).catch((()=>{})),a.set(t,e),t}(e);if(i.has(e))return i.get(e);const t=u(e);return t!==e&&(i.set(e,t),a.set(t,e)),t}const l=e=>a.get(e);const p=["get","getKey","getAll","getAllKeys","count"],D=["put","add","delete","clear"],b=new Map;function v(e,t){if(!(e instanceof IDBDatabase)||t in e||"string"!=typeof t)return;if(b.get(t))return b.get(t);const n=t.replace(/FromIndex$/,""),r=t!==n,o=D.includes(n);if(!(n in(r?IDBIndex:IDBObjectStore).prototype)||!o&&!p.includes(n))return;const s=async function(e,...t){const s=this.transaction(e,o?"readwrite":"readonly");let i=s.store;return r&&(i=i.index(t.shift())),(await Promise.all([i[n](...t),o&&s.done]))[0]};return b.set(t,s),s}c=(e=>({...e,get:(t,n,r)=>v(t,n)||e.get(t,n,r),has:(t,n)=>!!v(t,n)||e.has(t,n)}))(c),e.deleteDB=function(e,{blocked:t}={}){const n=indexedDB.deleteDatabase(e);return t&&n.addEventListener("blocked",(e=>t(e.oldVersion,e))),f(n).then((()=>{}))},e.openDB=function(e,t,{blocked:n,upgrade:r,blocking:o,terminated:s}={}){const i=indexedDB.open(e,t),a=f(i);return r&&i.addEventListener("upgradeneeded",(e=>{r(f(i.result),e.oldVersion,e.newVersion,f(i.transaction),e)})),n&&i.addEventListener("blocked",(e=>n(e.oldVersion,e.newVersion,e))),a.then((e=>{s&&e.addEventListener("close",(()=>s())),o&&e.addEventListener("versionchange",(e=>o(e.oldVersion,e.newVersion,e)))})).catch((()=>{})),a},e.unwrap=l,e.wrap=f}));

pwa/node_modules/workbox-background-sync/node_modules/idb/build/util.d.ts

@@ -0,0 +1,3 @@
+export declare type Constructor = new (...args: any[]) => any;
+export declare type Func = (...args: any[]) => any;
+export declare const instanceOfAny: (object: any, constructors: Constructor[]) => boolean;

pwa/node_modules/workbox-background-sync/node_modules/idb/build/wrap-idb-value.cjs

@@ -0,0 +1,191 @@
+'use strict';
+
+const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+
+let idbProxyableTypes;
+let cursorAdvanceMethods;
+// This is a function to prevent it throwing up in node environments.
+function getIdbProxyableTypes() {
+    return (idbProxyableTypes ||
+        (idbProxyableTypes = [
+            IDBDatabase,
+            IDBObjectStore,
+            IDBIndex,
+            IDBCursor,
+            IDBTransaction,
+        ]));
+}
+// This is a function to prevent it throwing up in node environments.
+function getCursorAdvanceMethods() {
+    return (cursorAdvanceMethods ||
+        (cursorAdvanceMethods = [
+            IDBCursor.prototype.advance,
+            IDBCursor.prototype.continue,
+            IDBCursor.prototype.continuePrimaryKey,
+        ]));
+}
+const cursorRequestMap = new WeakMap();
+const transactionDoneMap = new WeakMap();
+const transactionStoreNamesMap = new WeakMap();
+const transformCache = new WeakMap();
+const reverseTransformCache = new WeakMap();
+function promisifyRequest(request) {
+    const promise = new Promise((resolve, reject) => {
+        const unlisten = () => {
+            request.removeEventListener('success', success);
+            request.removeEventListener('error', error);
+        };
+        const success = () => {
+            resolve(wrap(request.result));
+            unlisten();
+        };
+        const error = () => {
+            reject(request.error);
+            unlisten();
+        };
+        request.addEventListener('success', success);
+        request.addEventListener('error', error);
+    });
+    promise
+        .then((value) => {
+        // Since cursoring reuses the IDBRequest (*sigh*), we cache it for later retrieval
+        // (see wrapFunction).
+        if (value instanceof IDBCursor) {
+            cursorRequestMap.set(value, request);
+        }
+        // Catching to avoid "Uncaught Promise exceptions"
+    })
+        .catch(() => { });
+    // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This
+    // is because we create many promises from a single IDBRequest.
+    reverseTransformCache.set(promise, request);
+    return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+    // Early bail if we've already created a done promise for this transaction.
+    if (transactionDoneMap.has(tx))
+        return;
+    const done = new Promise((resolve, reject) => {
+        const unlisten = () => {
+            tx.removeEventListener('complete', complete);
+            tx.removeEventListener('error', error);
+            tx.removeEventListener('abort', error);
+        };
+        const complete = () => {
+            resolve();
+            unlisten();
+        };
+        const error = () => {
+            reject(tx.error || new DOMException('AbortError', 'AbortError'));
+            unlisten();
+        };
+        tx.addEventListener('complete', complete);
+        tx.addEventListener('error', error);
+        tx.addEventListener('abort', error);
+    });
+    // Cache it for later retrieval.
+    transactionDoneMap.set(tx, done);
+}
+let idbProxyTraps = {
+    get(target, prop, receiver) {
+        if (target instanceof IDBTransaction) {
+            // Special handling for transaction.done.
+            if (prop === 'done')
+                return transactionDoneMap.get(target);
+            // Polyfill for objectStoreNames because of Edge.
+            if (prop === 'objectStoreNames') {
+                return target.objectStoreNames || transactionStoreNamesMap.get(target);
+            }
+            // Make tx.store return the only store in the transaction, or undefined if there are many.
+            if (prop === 'store') {
+                return receiver.objectStoreNames[1]
+                    ? undefined
+                    : receiver.objectStore(receiver.objectStoreNames[0]);
+            }
+        }
+        // Else transform whatever we get back.
+        return wrap(target[prop]);
+    },
+    set(target, prop, value) {
+        target[prop] = value;
+        return true;
+    },
+    has(target, prop) {
+        if (target instanceof IDBTransaction &&
+            (prop === 'done' || prop === 'store')) {
+            return true;
+        }
+        return prop in target;
+    },
+};
+function replaceTraps(callback) {
+    idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+    // Due to expected object equality (which is enforced by the caching in `wrap`), we
+    // only create one new func per func.
+    // Edge doesn't support objectStoreNames (booo), so we polyfill it here.
+    if (func === IDBDatabase.prototype.transaction &&
+        !('objectStoreNames' in IDBTransaction.prototype)) {
+        return function (storeNames, ...args) {
+            const tx = func.call(unwrap(this), storeNames, ...args);
+            transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
+            return wrap(tx);
+        };
+    }
+    // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
+    // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
+    // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
+    // with real promises, so each advance methods returns a new promise for the cursor object, or
+    // undefined if the end of the cursor has been reached.
+    if (getCursorAdvanceMethods().includes(func)) {
+        return function (...args) {
+            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+            // the original object.
+            func.apply(unwrap(this), args);
+            return wrap(cursorRequestMap.get(this));
+        };
+    }
+    return function (...args) {
+        // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+        // the original object.
+        return wrap(func.apply(unwrap(this), args));
+    };
+}
+function transformCachableValue(value) {
+    if (typeof value === 'function')
+        return wrapFunction(value);
+    // This doesn't return, it just creates a 'done' promise for the transaction,
+    // which is later returned for transaction.done (see idbObjectHandler).
+    if (value instanceof IDBTransaction)
+        cacheDonePromiseForTransaction(value);
+    if (instanceOfAny(value, getIdbProxyableTypes()))
+        return new Proxy(value, idbProxyTraps);
+    // Return the same value back if we're not going to transform it.
+    return value;
+}
+function wrap(value) {
+    // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
+    // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
+    if (value instanceof IDBRequest)
+        return promisifyRequest(value);
+    // If we've already transformed this value before, reuse the transformed value.
+    // This is faster, but it also provides object equality.
+    if (transformCache.has(value))
+        return transformCache.get(value);
+    const newValue = transformCachableValue(value);
+    // Not all types are transformed.
+    // These may be primitive types, so they can't be WeakMap keys.
+    if (newValue !== value) {
+        transformCache.set(value, newValue);
+        reverseTransformCache.set(newValue, value);
+    }
+    return newValue;
+}
+const unwrap = (value) => reverseTransformCache.get(value);
+
+exports.instanceOfAny = instanceOfAny;
+exports.replaceTraps = replaceTraps;
+exports.reverseTransformCache = reverseTransformCache;
+exports.unwrap = unwrap;
+exports.wrap = wrap;

pwa/node_modules/workbox-background-sync/node_modules/idb/build/wrap-idb-value.d.ts

@@ -0,0 +1,34 @@
+import { IDBPCursor, IDBPCursorWithValue, IDBPDatabase, IDBPIndex, IDBPObjectStore, IDBPTransaction } from './entry.js';
+export declare const reverseTransformCache: WeakMap<object, any>;
+export declare function replaceTraps(callback: (currentTraps: ProxyHandler<any>) => ProxyHandler<any>): void;
+/**
+ * Enhance an IDB object with helpers.
+ *
+ * @param value The thing to enhance.
+ */
+export declare function wrap(value: IDBDatabase): IDBPDatabase;
+export declare function wrap(value: IDBIndex): IDBPIndex;
+export declare function wrap(value: IDBObjectStore): IDBPObjectStore;
+export declare function wrap(value: IDBTransaction): IDBPTransaction;
+export declare function wrap(value: IDBOpenDBRequest): Promise<IDBPDatabase | undefined>;
+export declare function wrap<T>(value: IDBRequest<T>): Promise<T>;
+/**
+ * Revert an enhanced IDB object to a plain old miserable IDB one.
+ *
+ * Will also revert a promise back to an IDBRequest.
+ *
+ * @param value The enhanced object to revert.
+ */
+interface Unwrap {
+    (value: IDBPCursorWithValue<any, any, any, any, any>): IDBCursorWithValue;
+    (value: IDBPCursor<any, any, any, any, any>): IDBCursor;
+    (value: IDBPDatabase): IDBDatabase;
+    (value: IDBPIndex<any, any, any, any, any>): IDBIndex;
+    (value: IDBPObjectStore<any, any, any, any>): IDBObjectStore;
+    (value: IDBPTransaction<any, any, any>): IDBTransaction;
+    <T extends any>(value: Promise<IDBPDatabase<T>>): IDBOpenDBRequest;
+    (value: Promise<IDBPDatabase>): IDBOpenDBRequest;
+    <T>(value: Promise<T>): IDBRequest<T>;
+}
+export declare const unwrap: Unwrap;
+export {};

pwa/node_modules/workbox-background-sync/node_modules/idb/build/wrap-idb-value.js

@@ -0,0 +1,185 @@
+const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+
+let idbProxyableTypes;
+let cursorAdvanceMethods;
+// This is a function to prevent it throwing up in node environments.
+function getIdbProxyableTypes() {
+    return (idbProxyableTypes ||
+        (idbProxyableTypes = [
+            IDBDatabase,
+            IDBObjectStore,
+            IDBIndex,
+            IDBCursor,
+            IDBTransaction,
+        ]));
+}
+// This is a function to prevent it throwing up in node environments.
+function getCursorAdvanceMethods() {
+    return (cursorAdvanceMethods ||
+        (cursorAdvanceMethods = [
+            IDBCursor.prototype.advance,
+            IDBCursor.prototype.continue,
+            IDBCursor.prototype.continuePrimaryKey,
+        ]));
+}
+const cursorRequestMap = new WeakMap();
+const transactionDoneMap = new WeakMap();
+const transactionStoreNamesMap = new WeakMap();
+const transformCache = new WeakMap();
+const reverseTransformCache = new WeakMap();
+function promisifyRequest(request) {
+    const promise = new Promise((resolve, reject) => {
+        const unlisten = () => {
+            request.removeEventListener('success', success);
+            request.removeEventListener('error', error);
+        };
+        const success = () => {
+            resolve(wrap(request.result));
+            unlisten();
+        };
+        const error = () => {
+            reject(request.error);
+            unlisten();
+        };
+        request.addEventListener('success', success);
+        request.addEventListener('error', error);
+    });
+    promise
+        .then((value) => {
+        // Since cursoring reuses the IDBRequest (*sigh*), we cache it for later retrieval
+        // (see wrapFunction).
+        if (value instanceof IDBCursor) {
+            cursorRequestMap.set(value, request);
+        }
+        // Catching to avoid "Uncaught Promise exceptions"
+    })
+        .catch(() => { });
+    // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This
+    // is because we create many promises from a single IDBRequest.
+    reverseTransformCache.set(promise, request);
+    return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+    // Early bail if we've already created a done promise for this transaction.
+    if (transactionDoneMap.has(tx))
+        return;
+    const done = new Promise((resolve, reject) => {
+        const unlisten = () => {
+            tx.removeEventListener('complete', complete);
+            tx.removeEventListener('error', error);
+            tx.removeEventListener('abort', error);
+        };
+        const complete = () => {
+            resolve();
+            unlisten();
+        };
+        const error = () => {
+            reject(tx.error || new DOMException('AbortError', 'AbortError'));
+            unlisten();
+        };
+        tx.addEventListener('complete', complete);
+        tx.addEventListener('error', error);
+        tx.addEventListener('abort', error);
+    });
+    // Cache it for later retrieval.
+    transactionDoneMap.set(tx, done);
+}
+let idbProxyTraps = {
+    get(target, prop, receiver) {
+        if (target instanceof IDBTransaction) {
+            // Special handling for transaction.done.
+            if (prop === 'done')
+                return transactionDoneMap.get(target);
+            // Polyfill for objectStoreNames because of Edge.
+            if (prop === 'objectStoreNames') {
+                return target.objectStoreNames || transactionStoreNamesMap.get(target);
+            }
+            // Make tx.store return the only store in the transaction, or undefined if there are many.
+            if (prop === 'store') {
+                return receiver.objectStoreNames[1]
+                    ? undefined
+                    : receiver.objectStore(receiver.objectStoreNames[0]);
+            }
+        }
+        // Else transform whatever we get back.
+        return wrap(target[prop]);
+    },
+    set(target, prop, value) {
+        target[prop] = value;
+        return true;
+    },
+    has(target, prop) {
+        if (target instanceof IDBTransaction &&
+            (prop === 'done' || prop === 'store')) {
+            return true;
+        }
+        return prop in target;
+    },
+};
+function replaceTraps(callback) {
+    idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+    // Due to expected object equality (which is enforced by the caching in `wrap`), we
+    // only create one new func per func.
+    // Edge doesn't support objectStoreNames (booo), so we polyfill it here.
+    if (func === IDBDatabase.prototype.transaction &&
+        !('objectStoreNames' in IDBTransaction.prototype)) {
+        return function (storeNames, ...args) {
+            const tx = func.call(unwrap(this), storeNames, ...args);
+            transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
+            return wrap(tx);
+        };
+    }
+    // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
+    // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
+    // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
+    // with real promises, so each advance methods returns a new promise for the cursor object, or
+    // undefined if the end of the cursor has been reached.
+    if (getCursorAdvanceMethods().includes(func)) {
+        return function (...args) {
+            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+            // the original object.
+            func.apply(unwrap(this), args);
+            return wrap(cursorRequestMap.get(this));
+        };
+    }
+    return function (...args) {
+        // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+        // the original object.
+        return wrap(func.apply(unwrap(this), args));
+    };
+}
+function transformCachableValue(value) {
+    if (typeof value === 'function')
+        return wrapFunction(value);
+    // This doesn't return, it just creates a 'done' promise for the transaction,
+    // which is later returned for transaction.done (see idbObjectHandler).
+    if (value instanceof IDBTransaction)
+        cacheDonePromiseForTransaction(value);
+    if (instanceOfAny(value, getIdbProxyableTypes()))
+        return new Proxy(value, idbProxyTraps);
+    // Return the same value back if we're not going to transform it.
+    return value;
+}
+function wrap(value) {
+    // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
+    // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
+    if (value instanceof IDBRequest)
+        return promisifyRequest(value);
+    // If we've already transformed this value before, reuse the transformed value.
+    // This is faster, but it also provides object equality.
+    if (transformCache.has(value))
+        return transformCache.get(value);
+    const newValue = transformCachableValue(value);
+    // Not all types are transformed.
+    // These may be primitive types, so they can't be WeakMap keys.
+    if (newValue !== value) {
+        transformCache.set(value, newValue);
+        reverseTransformCache.set(newValue, value);
+    }
+    return newValue;
+}
+const unwrap = (value) => reverseTransformCache.get(value);
+
+export { reverseTransformCache as a, instanceOfAny as i, replaceTraps as r, unwrap as u, wrap as w };

pwa/node_modules/workbox-background-sync/node_modules/idb/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "idb",
+  "version": "7.1.1",
+  "description": "A small wrapper that makes IndexedDB usable",
+  "main": "./build/index.cjs",
+  "module": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "module": "./build/index.js",
+      "import": "./build/index.js",
+      "default": "./build/index.cjs"
+    },
+    "./with-async-ittr": {
+      "types": "./with-async-ittr.d.ts",
+      "module": "./with-async-ittr.js",
+      "import": "./with-async-ittr.js",
+      "default": "./with-async-ittr.cjs"
+    },
+    "./build/*": "./build/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "build/**",
+    "with-*",
+    "CHANGELOG.md"
+  ],
+  "type": "module",
+  "scripts": {
+    "build": "PRODUCTION=1 rollup -c && node --experimental-modules lib/size-report.mjs",
+    "dev": "rollup -c --watch",
+    "prepack": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jakearchibald/idb.git"
+  },
+  "author": "Jake Archibald",
+  "license": "ISC",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^22.0.2",
+    "@rollup/plugin-node-resolve": "^14.1.0",
+    "@types/chai": "^4.3.3",
+    "@types/estree": "^1.0.0",
+    "@types/mocha": "^9.1.1",
+    "chai": "^4.3.6",
+    "conditional-type-checks": "^1.0.6",
+    "del": "^7.0.0",
+    "filesize": "^9.0.11",
+    "glob": "^8.0.3",
+    "mocha": "^10.0.0",
+    "prettier": "^2.7.1",
+    "rollup": "^2.79.0",
+    "rollup-plugin-terser": "^7.0.2",
+    "typescript": "^4.8.3"
+  }
+}

pwa/node_modules/workbox-background-sync/node_modules/idb/with-async-ittr.cjs

@@ -0,0 +1,2 @@
+module.exports = require('./build/index.cjs');
+require('./build/async-iterators.cjs');

pwa/node_modules/workbox-background-sync/node_modules/idb/with-async-ittr.d.ts

@@ -0,0 +1 @@
+export * from './build/index.js';

pwa/node_modules/workbox-background-sync/node_modules/idb/with-async-ittr.js

@@ -0,0 +1,2 @@
+export * from './build/index.js';
+import './build/async-iterators.js';

pwa/node_modules/workbox-background-sync/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "workbox-background-sync",
+  "version": "7.4.0",
+  "license": "MIT",
+  "author": "Google's Web DevRel Team and Google's Aurora Team",
+  "description": "Queues failed requests and uses the Background Sync API to replay them when the network is available",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/googlechrome/workbox.git"
+  },
+  "bugs": "https://github.com/googlechrome/workbox/issues",
+  "homepage": "https://github.com/GoogleChrome/workbox",
+  "keywords": [
+    "workbox",
+    "workboxjs",
+    "service worker",
+    "sw",
+    "background",
+    "sync",
+    "workbox-plugin"
+  ],
+  "workbox": {
+    "browserNamespace": "workbox.backgroundSync",
+    "packageType": "sw"
+  },
+  "main": "index.js",
+  "module": "index.mjs",
+  "types": "index.d.ts",
+  "dependencies": {
+    "idb": "^7.0.1",
+    "workbox-core": "7.4.0"
+  },
+  "gitHead": "fa702feeddd417fcdfa495cd9428fb4a28632e92"
+}

pwa/node_modules/workbox-background-sync/src/BackgroundSyncPlugin.ts

@@ -0,0 +1,43 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import {WorkboxPlugin} from 'workbox-core/types.js';
+import {Queue, QueueOptions} from './Queue.js';
+import './_version.js';
+
+/**
+ * A class implementing the `fetchDidFail` lifecycle callback. This makes it
+ * easier to add failed requests to a background sync Queue.
+ *
+ * @memberof workbox-background-sync
+ */
+class BackgroundSyncPlugin implements WorkboxPlugin {
+  private readonly _queue: Queue;
+
+  /**
+   * @param {string} name See the {@link workbox-background-sync.Queue}
+   *     documentation for parameter details.
+   * @param {Object} [options] See the
+   *     {@link workbox-background-sync.Queue} documentation for
+   *     parameter details.
+   */
+  constructor(name: string, options?: QueueOptions) {
+    this._queue = new Queue(name, options);
+  }
+
+  /**
+   * @param {Object} options
+   * @param {Request} options.request
+   * @private
+   */
+  fetchDidFail: WorkboxPlugin['fetchDidFail'] = async ({request}) => {
+    await this._queue.pushRequest({request});
+  };
+}
+
+export {BackgroundSyncPlugin};

pwa/node_modules/workbox-background-sync/src/Queue.ts

@@ -0,0 +1,487 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import {WorkboxError} from 'workbox-core/_private/WorkboxError.js';
+import {logger} from 'workbox-core/_private/logger.js';
+import {assert} from 'workbox-core/_private/assert.js';
+import {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.js';
+import {QueueStore} from './lib/QueueStore.js';
+import {QueueStoreEntry, UnidentifiedQueueStoreEntry} from './lib/QueueDb.js';
+import {StorableRequest} from './lib/StorableRequest.js';
+import './_version.js';
+
+// Give TypeScript the correct global.
+declare let self: ServiceWorkerGlobalScope;
+
+interface OnSyncCallbackOptions {
+  queue: Queue;
+}
+
+interface OnSyncCallback {
+  (options: OnSyncCallbackOptions): void | Promise<void>;
+}
+
+export interface QueueOptions {
+  forceSyncFallback?: boolean;
+  maxRetentionTime?: number;
+  onSync?: OnSyncCallback;
+}
+
+interface QueueEntry {
+  request: Request;
+  timestamp?: number;
+  // We could use Record<string, unknown> as a type but that would be a breaking
+  // change, better do it in next major release.
+  // eslint-disable-next-line  @typescript-eslint/ban-types
+  metadata?: object;
+}
+
+const TAG_PREFIX = 'workbox-background-sync';
+const MAX_RETENTION_TIME = 60 * 24 * 7; // 7 days in minutes
+
+const queueNames = new Set<string>();
+
+/**
+ * Converts a QueueStore entry into the format exposed by Queue. This entails
+ * converting the request data into a real request and omitting the `id` and
+ * `queueName` properties.
+ *
+ * @param {UnidentifiedQueueStoreEntry} queueStoreEntry
+ * @return {Queue}
+ * @private
+ */
+const convertEntry = (
+  queueStoreEntry: UnidentifiedQueueStoreEntry,
+): QueueEntry => {
+  const queueEntry: QueueEntry = {
+    request: new StorableRequest(queueStoreEntry.requestData).toRequest(),
+    timestamp: queueStoreEntry.timestamp,
+  };
+  if (queueStoreEntry.metadata) {
+    queueEntry.metadata = queueStoreEntry.metadata;
+  }
+  return queueEntry;
+};
+
+/**
+ * A class to manage storing failed requests in IndexedDB and retrying them
+ * later. All parts of the storing and replaying process are observable via
+ * callbacks.
+ *
+ * @memberof workbox-background-sync
+ */
+class Queue {
+  private readonly _name: string;
+  private readonly _onSync: OnSyncCallback;
+  private readonly _maxRetentionTime: number;
+  private readonly _queueStore: QueueStore;
+  private readonly _forceSyncFallback: boolean;
+  private _syncInProgress = false;
+  private _requestsAddedDuringSync = false;
+
+  /**
+   * Creates an instance of Queue with the given options
+   *
+   * @param {string} name The unique name for this queue. This name must be
+   *     unique as it's used to register sync events and store requests
+   *     in IndexedDB specific to this instance. An error will be thrown if
+   *     a duplicate name is detected.
+   * @param {Object} [options]
+   * @param {Function} [options.onSync] A function that gets invoked whenever
+   *     the 'sync' event fires. The function is invoked with an object
+   *     containing the `queue` property (referencing this instance), and you
+   *     can use the callback to customize the replay behavior of the queue.
+   *     When not set the `replayRequests()` method is called.
+   *     Note: if the replay fails after a sync event, make sure you throw an
+   *     error, so the browser knows to retry the sync event later.
+   * @param {number} [options.maxRetentionTime=7 days] The amount of time (in
+   *     minutes) a request may be retried. After this amount of time has
+   *     passed, the request will be deleted from the queue.
+   * @param {boolean} [options.forceSyncFallback=false] If `true`, instead
+   *     of attempting to use background sync events, always attempt to replay
+   *     queued request at service worker startup. Most folks will not need
+   *     this, unless you explicitly target a runtime like Electron that
+   *     exposes the interfaces for background sync, but does not have a working
+   *     implementation.
+   */
+  constructor(
+    name: string,
+    {forceSyncFallback, onSync, maxRetentionTime}: QueueOptions = {},
+  ) {
+    // Ensure the store name is not already being used
+    if (queueNames.has(name)) {
+      throw new WorkboxError('duplicate-queue-name', {name});
+    } else {
+      queueNames.add(name);
+    }
+
+    this._name = name;
+    this._onSync = onSync || this.replayRequests;
+    this._maxRetentionTime = maxRetentionTime || MAX_RETENTION_TIME;
+    this._forceSyncFallback = Boolean(forceSyncFallback);
+    this._queueStore = new QueueStore(this._name);
+
+    this._addSyncListener();
+  }
+
+  /**
+   * @return {string}
+   */
+  get name(): string {
+    return this._name;
+  }
+
+  /**
+   * Stores the passed request in IndexedDB (with its timestamp and any
+   * metadata) at the end of the queue.
+   *
+   * @param {QueueEntry} entry
+   * @param {Request} entry.request The request to store in the queue.
+   * @param {Object} [entry.metadata] Any metadata you want associated with the
+   *     stored request. When requests are replayed you'll have access to this
+   *     metadata object in case you need to modify the request beforehand.
+   * @param {number} [entry.timestamp] The timestamp (Epoch time in
+   *     milliseconds) when the request was first added to the queue. This is
+   *     used along with `maxRetentionTime` to remove outdated requests. In
+   *     general you don't need to set this value, as it's automatically set
+   *     for you (defaulting to `Date.now()`), but you can update it if you
+   *     don't want particular requests to expire.
+   */
+  async pushRequest(entry: QueueEntry): Promise<void> {
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isType(entry, 'object', {
+        moduleName: 'workbox-background-sync',
+        className: 'Queue',
+        funcName: 'pushRequest',
+        paramName: 'entry',
+      });
+      assert!.isInstance(entry.request, Request, {
+        moduleName: 'workbox-background-sync',
+        className: 'Queue',
+        funcName: 'pushRequest',
+        paramName: 'entry.request',
+      });
+    }
+
+    await this._addRequest(entry, 'push');
+  }
+
+  /**
+   * Stores the passed request in IndexedDB (with its timestamp and any
+   * metadata) at the beginning of the queue.
+   *
+   * @param {QueueEntry} entry
+   * @param {Request} entry.request The request to store in the queue.
+   * @param {Object} [entry.metadata] Any metadata you want associated with the
+   *     stored request. When requests are replayed you'll have access to this
+   *     metadata object in case you need to modify the request beforehand.
+   * @param {number} [entry.timestamp] The timestamp (Epoch time in
+   *     milliseconds) when the request was first added to the queue. This is
+   *     used along with `maxRetentionTime` to remove outdated requests. In
+   *     general you don't need to set this value, as it's automatically set
+   *     for you (defaulting to `Date.now()`), but you can update it if you
+   *     don't want particular requests to expire.
+   */
+  async unshiftRequest(entry: QueueEntry): Promise<void> {
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isType(entry, 'object', {
+        moduleName: 'workbox-background-sync',
+        className: 'Queue',
+        funcName: 'unshiftRequest',
+        paramName: 'entry',
+      });
+      assert!.isInstance(entry.request, Request, {
+        moduleName: 'workbox-background-sync',
+        className: 'Queue',
+        funcName: 'unshiftRequest',
+        paramName: 'entry.request',
+      });
+    }
+
+    await this._addRequest(entry, 'unshift');
+  }
+
+  /**
+   * Removes and returns the last request in the queue (along with its
+   * timestamp and any metadata). The returned object takes the form:
+   * `{request, timestamp, metadata}`.
+   *
+   * @return {Promise<QueueEntry | undefined>}
+   */
+  async popRequest(): Promise<QueueEntry | undefined> {
+    return this._removeRequest('pop');
+  }
+
+  /**
+   * Removes and returns the first request in the queue (along with its
+   * timestamp and any metadata). The returned object takes the form:
+   * `{request, timestamp, metadata}`.
+   *
+   * @return {Promise<QueueEntry | undefined>}
+   */
+  async shiftRequest(): Promise<QueueEntry | undefined> {
+    return this._removeRequest('shift');
+  }
+
+  /**
+   * Returns all the entries that have not expired (per `maxRetentionTime`).
+   * Any expired entries are removed from the queue.
+   *
+   * @return {Promise<Array<QueueEntry>>}
+   */
+  async getAll(): Promise<Array<QueueEntry>> {
+    const allEntries = await this._queueStore.getAll();
+    const now = Date.now();
+
+    const unexpiredEntries = [];
+    for (const entry of allEntries) {
+      // Ignore requests older than maxRetentionTime. Call this function
+      // recursively until an unexpired request is found.
+      const maxRetentionTimeInMs = this._maxRetentionTime * 60 * 1000;
+      if (now - entry.timestamp > maxRetentionTimeInMs) {
+        await this._queueStore.deleteEntry(entry.id);
+      } else {
+        unexpiredEntries.push(convertEntry(entry));
+      }
+    }
+
+    return unexpiredEntries;
+  }
+
+  /**
+   * Returns the number of entries present in the queue.
+   * Note that expired entries (per `maxRetentionTime`) are also included in this count.
+   *
+   * @return {Promise<number>}
+   */
+  async size(): Promise<number> {
+    return await this._queueStore.size();
+  }
+
+  /**
+   * Adds the entry to the QueueStore and registers for a sync event.
+   *
+   * @param {Object} entry
+   * @param {Request} entry.request
+   * @param {Object} [entry.metadata]
+   * @param {number} [entry.timestamp=Date.now()]
+   * @param {string} operation ('push' or 'unshift')
+   * @private
+   */
+  async _addRequest(
+    {request, metadata, timestamp = Date.now()}: QueueEntry,
+    operation: 'push' | 'unshift',
+  ): Promise<void> {
+    const storableRequest = await StorableRequest.fromRequest(request.clone());
+    const entry: UnidentifiedQueueStoreEntry = {
+      requestData: storableRequest.toObject(),
+      timestamp,
+    };
+
+    // Only include metadata if it's present.
+    if (metadata) {
+      entry.metadata = metadata;
+    }
+
+    switch (operation) {
+      case 'push':
+        await this._queueStore.pushEntry(entry);
+        break;
+      case 'unshift':
+        await this._queueStore.unshiftEntry(entry);
+        break;
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      logger.log(
+        `Request for '${getFriendlyURL(request.url)}' has ` +
+          `been added to background sync queue '${this._name}'.`,
+      );
+    }
+
+    // Don't register for a sync if we're in the middle of a sync. Instead,
+    // we wait until the sync is complete and call register if
+    // `this._requestsAddedDuringSync` is true.
+    if (this._syncInProgress) {
+      this._requestsAddedDuringSync = true;
+    } else {
+      await this.registerSync();
+    }
+  }
+
+  /**
+   * Removes and returns the first or last (depending on `operation`) entry
+   * from the QueueStore that's not older than the `maxRetentionTime`.
+   *
+   * @param {string} operation ('pop' or 'shift')
+   * @return {Object|undefined}
+   * @private
+   */
+  async _removeRequest(
+    operation: 'pop' | 'shift',
+  ): Promise<QueueEntry | undefined> {
+    const now = Date.now();
+    let entry: QueueStoreEntry | undefined;
+    switch (operation) {
+      case 'pop':
+        entry = await this._queueStore.popEntry();
+        break;
+      case 'shift':
+        entry = await this._queueStore.shiftEntry();
+        break;
+    }
+
+    if (entry) {
+      // Ignore requests older than maxRetentionTime. Call this function
+      // recursively until an unexpired request is found.
+      const maxRetentionTimeInMs = this._maxRetentionTime * 60 * 1000;
+      if (now - entry.timestamp > maxRetentionTimeInMs) {
+        return this._removeRequest(operation);
+      }
+
+      return convertEntry(entry);
+    } else {
+      return undefined;
+    }
+  }
+
+  /**
+   * Loops through each request in the queue and attempts to re-fetch it.
+   * If any request fails to re-fetch, it's put back in the same position in
+   * the queue (which registers a retry for the next sync event).
+   */
+  async replayRequests(): Promise<void> {
+    let entry;
+    while ((entry = await this.shiftRequest())) {
+      try {
+        await fetch(entry.request.clone());
+
+        if (process.env.NODE_ENV !== 'production') {
+          logger.log(
+            `Request for '${getFriendlyURL(entry.request.url)}' ` +
+              `has been replayed in queue '${this._name}'`,
+          );
+        }
+      } catch (error) {
+        await this.unshiftRequest(entry);
+
+        if (process.env.NODE_ENV !== 'production') {
+          logger.log(
+            `Request for '${getFriendlyURL(entry.request.url)}' ` +
+              `failed to replay, putting it back in queue '${this._name}'`,
+          );
+        }
+        throw new WorkboxError('queue-replay-failed', {name: this._name});
+      }
+    }
+    if (process.env.NODE_ENV !== 'production') {
+      logger.log(
+        `All requests in queue '${this.name}' have successfully ` +
+          `replayed; the queue is now empty!`,
+      );
+    }
+  }
+
+  /**
+   * Registers a sync event with a tag unique to this instance.
+   */
+  async registerSync(): Promise<void> {
+    // See https://github.com/GoogleChrome/workbox/issues/2393
+    if ('sync' in self.registration && !this._forceSyncFallback) {
+      try {
+        await self.registration.sync.register(`${TAG_PREFIX}:${this._name}`);
+      } catch (err) {
+        // This means the registration failed for some reason, possibly due to
+        // the user disabling it.
+        if (process.env.NODE_ENV !== 'production') {
+          logger.warn(
+            `Unable to register sync event for '${this._name}'.`,
+            err,
+          );
+        }
+      }
+    }
+  }
+
+  /**
+   * In sync-supporting browsers, this adds a listener for the sync event.
+   * In non-sync-supporting browsers, or if _forceSyncFallback is true, this
+   * will retry the queue on service worker startup.
+   *
+   * @private
+   */
+  private _addSyncListener() {
+    // See https://github.com/GoogleChrome/workbox/issues/2393
+    if ('sync' in self.registration && !this._forceSyncFallback) {
+      self.addEventListener('sync', (event: SyncEvent) => {
+        if (event.tag === `${TAG_PREFIX}:${this._name}`) {
+          if (process.env.NODE_ENV !== 'production') {
+            logger.log(
+              `Background sync for tag '${event.tag}' ` + `has been received`,
+            );
+          }
+
+          const syncComplete = async () => {
+            this._syncInProgress = true;
+
+            let syncError;
+            try {
+              await this._onSync({queue: this});
+            } catch (error) {
+              if (error instanceof Error) {
+                syncError = error;
+
+                // Rethrow the error. Note: the logic in the finally clause
+                // will run before this gets rethrown.
+                throw syncError;
+              }
+            } finally {
+              // New items may have been added to the queue during the sync,
+              // so we need to register for a new sync if that's happened...
+              // Unless there was an error during the sync, in which
+              // case the browser will automatically retry later, as long
+              // as `event.lastChance` is not true.
+              if (
+                this._requestsAddedDuringSync &&
+                !(syncError && !event.lastChance)
+              ) {
+                await this.registerSync();
+              }
+
+              this._syncInProgress = false;
+              this._requestsAddedDuringSync = false;
+            }
+          };
+          event.waitUntil(syncComplete());
+        }
+      });
+    } else {
+      if (process.env.NODE_ENV !== 'production') {
+        logger.log(`Background sync replaying without background sync event`);
+      }
+      // If the browser doesn't support background sync, or the developer has
+      // opted-in to not using it, retry every time the service worker starts up
+      // as a fallback.
+      void this._onSync({queue: this});
+    }
+  }
+
+  /**
+   * Returns the set of queue names. This is primarily used to reset the list
+   * of queue names in tests.
+   *
+   * @return {Set<string>}
+   *
+   * @private
+   */
+  static get _queueNames(): Set<string> {
+    return queueNames;
+  }
+}
+
+export {Queue};

pwa/node_modules/workbox-background-sync/src/QueueStore.ts

@@ -0,0 +1,14 @@
+/*
+  Copyright 2021 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import './_version.js';
+
+// This is a temporary workaround to expose something from ./lib/ via our
+// top-level public API.
+// TODO: In Workbox v7, move the actual code from ./lib/ to this file.
+export {QueueStore} from './lib/QueueStore';

pwa/node_modules/workbox-background-sync/src/StorableRequest.ts

@@ -0,0 +1,14 @@
+/*
+  Copyright 2021 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import './_version.js';
+
+// This is a temporary workaround to expose something from ./lib/ via our
+// top-level public API.
+// TODO: In Workbox v7, move the actual code from ./lib/ to this file.
+export {StorableRequest} from './lib/StorableRequest';

pwa/node_modules/workbox-background-sync/src/_version.ts

@@ -0,0 +1,2 @@
+// @ts-ignore
+try{self['workbox:background-sync:7.4.0']&&_()}catch(e){}

pwa/node_modules/workbox-background-sync/src/index.ts

@@ -0,0 +1,40 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import {BackgroundSyncPlugin} from './BackgroundSyncPlugin.js';
+import {Queue, QueueOptions} from './Queue.js';
+import {QueueStore} from './QueueStore.js';
+import {StorableRequest} from './StorableRequest.js';
+
+import './_version.js';
+
+// See https://github.com/GoogleChrome/workbox/issues/2946
+interface SyncManager {
+  getTags(): Promise<string[]>;
+  register(tag: string): Promise<void>;
+}
+
+declare global {
+  interface ServiceWorkerRegistration {
+    readonly sync: SyncManager;
+  }
+
+  interface SyncEvent extends ExtendableEvent {
+    readonly lastChance: boolean;
+    readonly tag: string;
+  }
+
+  interface ServiceWorkerGlobalScopeEventMap {
+    sync: SyncEvent;
+  }
+}
+
+/**
+ * @module workbox-background-sync
+ */
+export {BackgroundSyncPlugin, Queue, QueueOptions, QueueStore, StorableRequest};

pwa/node_modules/workbox-background-sync/src/lib/QueueDb.ts

@@ -0,0 +1,200 @@
+/*
+  Copyright 2021 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import {openDB, DBSchema, IDBPDatabase} from 'idb';
+import {RequestData} from './StorableRequest.js';
+import '../_version.js';
+
+interface QueueDBSchema extends DBSchema {
+  requests: {
+    key: number;
+    value: QueueStoreEntry;
+    indexes: {queueName: string};
+  };
+}
+
+const DB_VERSION = 3;
+const DB_NAME = 'workbox-background-sync';
+const REQUEST_OBJECT_STORE_NAME = 'requests';
+const QUEUE_NAME_INDEX = 'queueName';
+
+export interface UnidentifiedQueueStoreEntry {
+  requestData: RequestData;
+  timestamp: number;
+  id?: number;
+  queueName?: string;
+  // We could use Record<string, unknown> as a type but that would be a breaking
+  // change, better do it in next major release.
+  // eslint-disable-next-line  @typescript-eslint/ban-types
+  metadata?: object;
+}
+
+export interface QueueStoreEntry extends UnidentifiedQueueStoreEntry {
+  id: number;
+}
+
+/**
+ * A class to interact directly an IndexedDB created specifically to save and
+ * retrieve QueueStoreEntries. This class encapsulates all the schema details
+ * to store the representation of a Queue.
+ *
+ * @private
+ */
+
+export class QueueDb {
+  private _db: IDBPDatabase<QueueDBSchema> | null = null;
+
+  /**
+   * Add QueueStoreEntry to underlying db.
+   *
+   * @param {UnidentifiedQueueStoreEntry} entry
+   */
+  async addEntry(entry: UnidentifiedQueueStoreEntry): Promise<void> {
+    const db = await this.getDb();
+    const tx = db.transaction(REQUEST_OBJECT_STORE_NAME, 'readwrite', {
+      durability: 'relaxed',
+    });
+    await tx.store.add(entry as QueueStoreEntry);
+    await tx.done;
+  }
+
+  /**
+   * Returns the first entry id in the ObjectStore.
+   *
+   * @return {number | undefined}
+   */
+  async getFirstEntryId(): Promise<number | undefined> {
+    const db = await this.getDb();
+    const cursor = await db
+      .transaction(REQUEST_OBJECT_STORE_NAME)
+      .store.openCursor();
+    return cursor?.value.id;
+  }
+
+  /**
+   * Get all the entries filtered by index
+   *
+   * @param queueName
+   * @return {Promise<QueueStoreEntry[]>}
+   */
+  async getAllEntriesByQueueName(
+    queueName: string,
+  ): Promise<QueueStoreEntry[]> {
+    const db = await this.getDb();
+    const results = await db.getAllFromIndex(
+      REQUEST_OBJECT_STORE_NAME,
+      QUEUE_NAME_INDEX,
+      IDBKeyRange.only(queueName),
+    );
+    return results ? results : new Array<QueueStoreEntry>();
+  }
+
+  /**
+   * Returns the number of entries filtered by index
+   *
+   * @param queueName
+   * @return {Promise<number>}
+   */
+  async getEntryCountByQueueName(queueName: string): Promise<number> {
+    const db = await this.getDb();
+    return db.countFromIndex(
+      REQUEST_OBJECT_STORE_NAME,
+      QUEUE_NAME_INDEX,
+      IDBKeyRange.only(queueName),
+    );
+  }
+
+  /**
+   * Deletes a single entry by id.
+   *
+   * @param {number} id the id of the entry to be deleted
+   */
+  async deleteEntry(id: number): Promise<void> {
+    const db = await this.getDb();
+    await db.delete(REQUEST_OBJECT_STORE_NAME, id);
+  }
+
+  /**
+   *
+   * @param queueName
+   * @returns {Promise<QueueStoreEntry | undefined>}
+   */
+  async getFirstEntryByQueueName(
+    queueName: string,
+  ): Promise<QueueStoreEntry | undefined> {
+    return await this.getEndEntryFromIndex(IDBKeyRange.only(queueName), 'next');
+  }
+
+  /**
+   *
+   * @param queueName
+   * @returns {Promise<QueueStoreEntry | undefined>}
+   */
+  async getLastEntryByQueueName(
+    queueName: string,
+  ): Promise<QueueStoreEntry | undefined> {
+    return await this.getEndEntryFromIndex(IDBKeyRange.only(queueName), 'prev');
+  }
+
+  /**
+   * Returns either the first or the last entries, depending on direction.
+   * Filtered by index.
+   *
+   * @param {IDBCursorDirection} direction
+   * @param {IDBKeyRange} query
+   * @return {Promise<QueueStoreEntry | undefined>}
+   * @private
+   */
+  async getEndEntryFromIndex(
+    query: IDBKeyRange,
+    direction: IDBCursorDirection,
+  ): Promise<QueueStoreEntry | undefined> {
+    const db = await this.getDb();
+
+    const cursor = await db
+      .transaction(REQUEST_OBJECT_STORE_NAME)
+      .store.index(QUEUE_NAME_INDEX)
+      .openCursor(query, direction);
+    return cursor?.value;
+  }
+
+  /**
+   * Returns an open connection to the database.
+   *
+   * @private
+   */
+  private async getDb() {
+    if (!this._db) {
+      this._db = await openDB(DB_NAME, DB_VERSION, {
+        upgrade: this._upgradeDb,
+      });
+    }
+    return this._db;
+  }
+
+  /**
+   * Upgrades QueueDB
+   *
+   * @param {IDBPDatabase<QueueDBSchema>} db
+   * @param {number} oldVersion
+   * @private
+   */
+  private _upgradeDb(db: IDBPDatabase<QueueDBSchema>, oldVersion: number) {
+    if (oldVersion > 0 && oldVersion < DB_VERSION) {
+      if (db.objectStoreNames.contains(REQUEST_OBJECT_STORE_NAME)) {
+        db.deleteObjectStore(REQUEST_OBJECT_STORE_NAME);
+      }
+    }
+
+    const objStore = db.createObjectStore(REQUEST_OBJECT_STORE_NAME, {
+      autoIncrement: true,
+      keyPath: 'id',
+    });
+    objStore.createIndex(QUEUE_NAME_INDEX, QUEUE_NAME_INDEX, {unique: false});
+  }
+}

pwa/node_modules/workbox-background-sync/src/lib/QueueStore.ts

@@ -0,0 +1,179 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import {assert} from 'workbox-core/_private/assert.js';
+import {
+  UnidentifiedQueueStoreEntry,
+  QueueStoreEntry,
+  QueueDb,
+} from './QueueDb.js';
+import '../_version.js';
+
+/**
+ * A class to manage storing requests from a Queue in IndexedDB,
+ * indexed by their queue name for easier access.
+ *
+ * Most developers will not need to access this class directly;
+ * it is exposed for advanced use cases.
+ */
+export class QueueStore {
+  private readonly _queueName: string;
+  private readonly _queueDb: QueueDb;
+
+  /**
+   * Associates this instance with a Queue instance, so entries added can be
+   * identified by their queue name.
+   *
+   * @param {string} queueName
+   */
+  constructor(queueName: string) {
+    this._queueName = queueName;
+    this._queueDb = new QueueDb();
+  }
+
+  /**
+   * Append an entry last in the queue.
+   *
+   * @param {Object} entry
+   * @param {Object} entry.requestData
+   * @param {number} [entry.timestamp]
+   * @param {Object} [entry.metadata]
+   */
+  async pushEntry(entry: UnidentifiedQueueStoreEntry): Promise<void> {
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isType(entry, 'object', {
+        moduleName: 'workbox-background-sync',
+        className: 'QueueStore',
+        funcName: 'pushEntry',
+        paramName: 'entry',
+      });
+      assert!.isType(entry.requestData, 'object', {
+        moduleName: 'workbox-background-sync',
+        className: 'QueueStore',
+        funcName: 'pushEntry',
+        paramName: 'entry.requestData',
+      });
+    }
+
+    // Don't specify an ID since one is automatically generated.
+    delete entry.id;
+    entry.queueName = this._queueName;
+
+    await this._queueDb.addEntry(entry);
+  }
+
+  /**
+   * Prepend an entry first in the queue.
+   *
+   * @param {Object} entry
+   * @param {Object} entry.requestData
+   * @param {number} [entry.timestamp]
+   * @param {Object} [entry.metadata]
+   */
+  async unshiftEntry(entry: UnidentifiedQueueStoreEntry): Promise<void> {
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isType(entry, 'object', {
+        moduleName: 'workbox-background-sync',
+        className: 'QueueStore',
+        funcName: 'unshiftEntry',
+        paramName: 'entry',
+      });
+      assert!.isType(entry.requestData, 'object', {
+        moduleName: 'workbox-background-sync',
+        className: 'QueueStore',
+        funcName: 'unshiftEntry',
+        paramName: 'entry.requestData',
+      });
+    }
+
+    const firstId = await this._queueDb.getFirstEntryId();
+
+    if (firstId) {
+      // Pick an ID one less than the lowest ID in the object store.
+      entry.id = firstId - 1;
+    } else {
+      // Otherwise let the auto-incrementor assign the ID.
+      delete entry.id;
+    }
+    entry.queueName = this._queueName;
+
+    await this._queueDb.addEntry(entry);
+  }
+
+  /**
+   * Removes and returns the last entry in the queue matching the `queueName`.
+   *
+   * @return {Promise<QueueStoreEntry|undefined>}
+   */
+  async popEntry(): Promise<QueueStoreEntry | undefined> {
+    return this._removeEntry(
+      await this._queueDb.getLastEntryByQueueName(this._queueName),
+    );
+  }
+
+  /**
+   * Removes and returns the first entry in the queue matching the `queueName`.
+   *
+   * @return {Promise<QueueStoreEntry|undefined>}
+   */
+  async shiftEntry(): Promise<QueueStoreEntry | undefined> {
+    return this._removeEntry(
+      await this._queueDb.getFirstEntryByQueueName(this._queueName),
+    );
+  }
+
+  /**
+   * Returns all entries in the store matching the `queueName`.
+   *
+   * @param {Object} options See {@link workbox-background-sync.Queue~getAll}
+   * @return {Promise<Array<Object>>}
+   */
+  async getAll(): Promise<QueueStoreEntry[]> {
+    return await this._queueDb.getAllEntriesByQueueName(this._queueName);
+  }
+
+  /**
+   * Returns the number of entries in the store matching the `queueName`.
+   *
+   * @param {Object} options See {@link workbox-background-sync.Queue~size}
+   * @return {Promise<number>}
+   */
+  async size(): Promise<number> {
+    return await this._queueDb.getEntryCountByQueueName(this._queueName);
+  }
+
+  /**
+   * Deletes the entry for the given ID.
+   *
+   * WARNING: this method does not ensure the deleted entry belongs to this
+   * queue (i.e. matches the `queueName`). But this limitation is acceptable
+   * as this class is not publicly exposed. An additional check would make
+   * this method slower than it needs to be.
+   *
+   * @param {number} id
+   */
+  async deleteEntry(id: number): Promise<void> {
+    await this._queueDb.deleteEntry(id);
+  }
+
+  /**
+   * Removes and returns the first or last entry in the queue (based on the
+   * `direction` argument) matching the `queueName`.
+   *
+   * @return {Promise<QueueStoreEntry|undefined>}
+   * @private
+   */
+  async _removeEntry(
+    entry?: QueueStoreEntry,
+  ): Promise<QueueStoreEntry | undefined> {
+    if (entry) {
+      await this.deleteEntry(entry.id);
+    }
+    return entry;
+  }
+}

pwa/node_modules/workbox-background-sync/src/lib/StorableRequest.ts

@@ -0,0 +1,156 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import {assert} from 'workbox-core/_private/assert.js';
+import {MapLikeObject} from 'workbox-core/types.js';
+import '../_version.js';
+
+type SerializableProperties =
+  | 'method'
+  | 'referrer'
+  | 'referrerPolicy'
+  | 'mode'
+  | 'credentials'
+  | 'cache'
+  | 'redirect'
+  | 'integrity'
+  | 'keepalive';
+
+const serializableProperties: SerializableProperties[] = [
+  'method',
+  'referrer',
+  'referrerPolicy',
+  'mode',
+  'credentials',
+  'cache',
+  'redirect',
+  'integrity',
+  'keepalive',
+];
+
+export interface RequestData extends MapLikeObject {
+  url: string;
+  headers: MapLikeObject;
+  body?: ArrayBuffer;
+}
+
+/**
+ * A class to make it easier to serialize and de-serialize requests so they
+ * can be stored in IndexedDB.
+ *
+ * Most developers will not need to access this class directly;
+ * it is exposed for advanced use cases.
+ */
+class StorableRequest {
+  private readonly _requestData: RequestData;
+
+  /**
+   * Converts a Request object to a plain object that can be structured
+   * cloned or JSON-stringified.
+   *
+   * @param {Request} request
+   * @return {Promise<StorableRequest>}
+   */
+  static async fromRequest(request: Request): Promise<StorableRequest> {
+    const requestData: RequestData = {
+      url: request.url,
+      headers: {},
+    };
+
+    // Set the body if present.
+    if (request.method !== 'GET') {
+      // Use ArrayBuffer to support non-text request bodies.
+      // NOTE: we can't use Blobs becuse Safari doesn't support storing
+      // Blobs in IndexedDB in some cases:
+      // https://github.com/dfahlander/Dexie.js/issues/618#issuecomment-398348457
+      requestData.body = await request.clone().arrayBuffer();
+    }
+
+    // Convert the headers from an iterable to an object.
+    for (const [key, value] of request.headers.entries()) {
+      requestData.headers[key] = value;
+    }
+
+    // Add all other serializable request properties
+    for (const prop of serializableProperties) {
+      if (request[prop] !== undefined) {
+        requestData[prop] = request[prop];
+      }
+    }
+
+    return new StorableRequest(requestData);
+  }
+
+  /**
+   * Accepts an object of request data that can be used to construct a
+   * `Request` but can also be stored in IndexedDB.
+   *
+   * @param {Object} requestData An object of request data that includes the
+   *     `url` plus any relevant properties of
+   *     [requestInit]{@link https://fetch.spec.whatwg.org/#requestinit}.
+   */
+  constructor(requestData: RequestData) {
+    if (process.env.NODE_ENV !== 'production') {
+      assert!.isType(requestData, 'object', {
+        moduleName: 'workbox-background-sync',
+        className: 'StorableRequest',
+        funcName: 'constructor',
+        paramName: 'requestData',
+      });
+      assert!.isType(requestData.url, 'string', {
+        moduleName: 'workbox-background-sync',
+        className: 'StorableRequest',
+        funcName: 'constructor',
+        paramName: 'requestData.url',
+      });
+    }
+
+    // If the request's mode is `navigate`, convert it to `same-origin` since
+    // navigation requests can't be constructed via script.
+    if (requestData['mode'] === 'navigate') {
+      requestData['mode'] = 'same-origin';
+    }
+
+    this._requestData = requestData;
+  }
+
+  /**
+   * Returns a deep clone of the instances `_requestData` object.
+   *
+   * @return {Object}
+   */
+  toObject(): RequestData {
+    const requestData = Object.assign({}, this._requestData);
+    requestData.headers = Object.assign({}, this._requestData.headers);
+    if (requestData.body) {
+      requestData.body = requestData.body.slice(0);
+    }
+
+    return requestData;
+  }
+
+  /**
+   * Converts this instance to a Request.
+   *
+   * @return {Request}
+   */
+  toRequest(): Request {
+    return new Request(this._requestData.url, this._requestData);
+  }
+
+  /**
+   * Creates and returns a deep clone of the instance.
+   *
+   * @return {StorableRequest}
+   */
+  clone(): StorableRequest {
+    return new StorableRequest(this.toObject());
+  }
+}
+
+export {StorableRequest};

pwa/node_modules/workbox-background-sync/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig",
+  "compilerOptions": {
+    "composite": true,
+    "outDir": "./",
+    "rootDir": "./src",
+    "tsBuildInfoFile": "./tsconfig.tsbuildinfo"
+  },
+  "include": ["src/**/*.ts"],
+  "references": [{"path": "../workbox-core/"}]
+}