jekyll-pwa-workbox 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99d5c666fb858984797f3d5627be43978bd9acbc3397c48af4236050d24d65a6
-  data.tar.gz: ad393eaa5f9a47fd91d4e59fbf2e9055c61fe5f9771b136618e2e12f9b8c59f4
+  metadata.gz: 234ea801a15bb040fe073a728463d30e6a77c1c3b7926f0e313a7a05779a4c1a
+  data.tar.gz: '080ad85b50b54fc84a8e19c858293e75a18c8d15db331acf2a7f92c5ccda89d8'
 SHA512:
-  metadata.gz: 0fca82d406128d4f29676a68b60fc174214b3145d1a446b98b760c013ac6d9f393af835dec2b8bc030029d6067e64841a9909f27abc0f31fd8000edf266b37bf
-  data.tar.gz: 10927ceff647b574d6ae83b0fd8b3373cb43c27a96773df3ffb2368bbb81f4d008139fe0d14a869570b388dbdb6a697db479eecbe57f69d89208e390efc0430e
+  metadata.gz: 561f322b94e934e90d2ee80a9931ccfa5b8c7dc40e5f2e41f5b6de47a0e4b314af297c903307f82d55cc92e45894176e7217c124037c568f7ace0c94fddff8a6
+  data.tar.gz: 6c0216d49f99e254f71edcbb9c0b911be185cf2508321ff2052c091ca5a21ef64e2e6871330f2a8c4b1358a26e2eb3f902229b1cba7baee9be97d572cba8fd4a

data/lib/jekyll-pwa-workbox.rb

@@ -1,5 +1,5 @@
 class SWHelper
-    WORKBOX_VERSION = 'v5.1.1'
+    WORKBOX_VERSION = 'v5.1.3'
     def initialize(site, config)
         @site = site
         @config = config

data/lib/vendor/{workbox-v5.1.1 → workbox-v5.1.3}/workbox-background-sync.dev.js

@@ -1,818 +1,818 @@
-this.workbox = this.workbox || {};
-this.workbox.backgroundSync = (function (exports, WorkboxError_js, logger_js, assert_js, getFriendlyURL_js, DBWrapper_js) {
-    'use strict';
-
-    try {
-      self['workbox:background-sync:5.1.1'] && _();
-    } catch (e) {}
-
-    /*
-      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.
-    */
-    const DB_VERSION = 3;
-    const DB_NAME = 'workbox-background-sync';
-    const OBJECT_STORE_NAME = 'requests';
-    const INDEXED_PROP = 'queueName';
-    /**
-     * A class to manage storing requests from a Queue in IndexedDB,
-     * indexed by their queue name for easier access.
-     *
-     * @private
-     */
-
-    class QueueStore {
-      /**
-       * Associates this instance with a Queue instance, so entries added can be
-       * identified by their queue name.
-       *
-       * @param {string} queueName
-       * @private
-       */
-      constructor(queueName) {
-        this._queueName = queueName;
-        this._db = new DBWrapper_js.DBWrapper(DB_NAME, DB_VERSION, {
-          onupgradeneeded: this._upgradeDb
-        });
-      }
-      /**
-       * Append an entry last in the queue.
-       *
-       * @param {Object} entry
-       * @param {Object} entry.requestData
-       * @param {number} [entry.timestamp]
-       * @param {Object} [entry.metadata]
-       * @private
-       */
-
-
-      async pushEntry(entry) {
-        {
-          assert_js.assert.isType(entry, 'object', {
-            moduleName: 'workbox-background-sync',
-            className: 'QueueStore',
-            funcName: 'pushEntry',
-            paramName: 'entry'
-          });
-          assert_js.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._db.add(OBJECT_STORE_NAME, entry);
-      }
-      /**
-       * Prepend an entry first in the queue.
-       *
-       * @param {Object} entry
-       * @param {Object} entry.requestData
-       * @param {number} [entry.timestamp]
-       * @param {Object} [entry.metadata]
-       * @private
-       */
-
-
-      async unshiftEntry(entry) {
-        {
-          assert_js.assert.isType(entry, 'object', {
-            moduleName: 'workbox-background-sync',
-            className: 'QueueStore',
-            funcName: 'unshiftEntry',
-            paramName: 'entry'
-          });
-          assert_js.assert.isType(entry.requestData, 'object', {
-            moduleName: 'workbox-background-sync',
-            className: 'QueueStore',
-            funcName: 'unshiftEntry',
-            paramName: 'entry.requestData'
-          });
-        }
-
-        const [firstEntry] = await this._db.getAllMatching(OBJECT_STORE_NAME, {
-          count: 1
-        });
-
-        if (firstEntry) {
-          // Pick an ID one less than the lowest ID in the object store.
-          entry.id = firstEntry.id - 1;
-        } else {
-          // Otherwise let the auto-incrementor assign the ID.
-          delete entry.id;
-        }
-
-        entry.queueName = this._queueName;
-        await this._db.add(OBJECT_STORE_NAME, entry);
-      }
-      /**
-       * Removes and returns the last entry in the queue matching the `queueName`.
-       *
-       * @return {Promise<Object>}
-       * @private
-       */
-
-
-      async popEntry() {
-        return this._removeEntry({
-          direction: 'prev'
-        });
-      }
-      /**
-       * Removes and returns the first entry in the queue matching the `queueName`.
-       *
-       * @return {Promise<Object>}
-       * @private
-       */
-
-
-      async shiftEntry() {
-        return this._removeEntry({
-          direction: 'next'
-        });
-      }
-      /**
-       * Returns all entries in the store matching the `queueName`.
-       *
-       * @param {Object} options See {@link module:workbox-background-sync.Queue~getAll}
-       * @return {Promise<Array<Object>>}
-       * @private
-       */
-
-
-      async getAll() {
-        return await this._db.getAllMatching(OBJECT_STORE_NAME, {
-          index: INDEXED_PROP,
-          query: IDBKeyRange.only(this._queueName)
-        });
-      }
-      /**
-       * Deletes the entry for the given ID.
-       *
-       * WARNING: this method does not ensure the deleted enry 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.
-       *
-       * @private
-       * @param {number} id
-       */
-
-
-      async deleteEntry(id) {
-        await this._db.delete(OBJECT_STORE_NAME, id);
-      }
-      /**
-       * Removes and returns the first or last entry in the queue (based on the
-       * `direction` argument) matching the `queueName`.
-       *
-       * @return {Promise<Object>}
-       * @private
-       */
-
-
-      async _removeEntry({
-        direction
-      }) {
-        const [entry] = await this._db.getAllMatching(OBJECT_STORE_NAME, {
-          direction,
-          index: INDEXED_PROP,
-          query: IDBKeyRange.only(this._queueName),
-          count: 1
-        });
-
-        if (entry) {
-          await this.deleteEntry(entry.id);
-          return entry;
-        }
-      }
-      /**
-       * Upgrades the database given an `upgradeneeded` event.
-       *
-       * @param {Event} event
-       * @private
-       */
-
-
-      _upgradeDb(event) {
-        const db = event.target.result;
-
-        if (event.oldVersion > 0 && event.oldVersion < DB_VERSION) {
-          if (db.objectStoreNames.contains(OBJECT_STORE_NAME)) {
-            db.deleteObjectStore(OBJECT_STORE_NAME);
-          }
-        }
-
-        const objStore = db.createObjectStore(OBJECT_STORE_NAME, {
-          autoIncrement: true,
-          keyPath: 'id'
-        });
-        objStore.createIndex(INDEXED_PROP, INDEXED_PROP, {
-          unique: false
-        });
-      }
-
-    }
-
-    /*
-      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.
-    */
-    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.
-     *
-     * @private
-     */
-
-    class 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}.
-       * @private
-       */
-      constructor(requestData) {
-        {
-          assert_js.assert.isType(requestData, 'object', {
-            moduleName: 'workbox-background-sync',
-            className: 'StorableRequest',
-            funcName: 'constructor',
-            paramName: 'requestData'
-          });
-          assert_js.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;
-      }
-      /**
-       * Converts a Request object to a plain object that can be structured
-       * cloned or JSON-stringified.
-       *
-       * @param {Request} request
-       * @return {Promise<StorableRequest>}
-       *
-       * @private
-       */
-
-
-      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);
-      }
-      /**
-       * Returns a deep clone of the instances `_requestData` object.
-       *
-       * @return {Object}
-       *
-       * @private
-       */
-
-
-      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}
-       *
-       * @private
-       */
-
-
-      toRequest() {
-        return new Request(this._requestData.url, this._requestData);
-      }
-      /**
-       * Creates and returns a deep clone of the instance.
-       *
-       * @return {StorableRequest}
-       *
-       * @private
-       */
-
-
-      clone() {
-        return new StorableRequest(this.toObject());
-      }
-
-    }
-
-    /*
-      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.
-    */
-    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 {Object} queueStoreEntry
-     * @return {Object}
-     * @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 module: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.
-       */
-      constructor(name, {
-        onSync,
-        maxRetentionTime
-      } = {}) {
-        this._syncInProgress = false;
-        this._requestsAddedDuringSync = false; // Ensure the store name is not already being used
-
-        if (queueNames.has(name)) {
-          throw new WorkboxError_js.WorkboxError('duplicate-queue-name', {
-            name
-          });
-        } else {
-          queueNames.add(name);
-        }
-
-        this._name = name;
-        this._onSync = onSync || this.replayRequests;
-        this._maxRetentionTime = maxRetentionTime || MAX_RETENTION_TIME;
-        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 {Object} 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) {
-        {
-          assert_js.assert.isType(entry, 'object', {
-            moduleName: 'workbox-background-sync',
-            className: 'Queue',
-            funcName: 'pushRequest',
-            paramName: 'entry'
-          });
-          assert_js.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 {Object} 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) {
-        {
-          assert_js.assert.isType(entry, 'object', {
-            moduleName: 'workbox-background-sync',
-            className: 'Queue',
-            funcName: 'unshiftRequest',
-            paramName: 'entry'
-          });
-          assert_js.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<Object>}
-       */
-
-
-      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<Object>}
-       */
-
-
-      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<Object>>}
-       */
-
-
-      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;
-      }
-      /**
-       * 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;
-        }
-
-        await this._queueStore[`${operation}Entry`](entry);
-
-        {
-          logger_js.logger.log(`Request for '${getFriendlyURL_js.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();
-        const entry = await this._queueStore[`${operation}Entry`]();
-
-        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 ("dev" !== 'production') {
-              logger_js.logger.log(`Request for '${getFriendlyURL_js.getFriendlyURL(entry.request.url)}'` + `has been replayed in queue '${this._name}'`);
-            }
-          } catch (error) {
-            await this.unshiftRequest(entry);
-
-            {
-              logger_js.logger.log(`Request for '${getFriendlyURL_js.getFriendlyURL(entry.request.url)}'` + `failed to replay, putting it back in queue '${this._name}'`);
-            }
-
-            throw new WorkboxError_js.WorkboxError('queue-replay-failed', {
-              name: this._name
-            });
-          }
-        }
-
-        {
-          logger_js.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() {
-        if ('sync' in self.registration) {
-          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.
-            {
-              logger_js.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, this will retry the queue on service
-       * worker startup.
-       *
-       * @private
-       */
-
-
-      _addSyncListener() {
-        if ('sync' in self.registration) {
-          self.addEventListener('sync', event => {
-            if (event.tag === `${TAG_PREFIX}:${this._name}`) {
-              {
-                logger_js.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) {
-                  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 {
-          {
-            logger_js.logger.log(`Background sync replaying without background sync event`);
-          } // If the browser doesn't support background sync, retry
-          // every time the service worker starts up as a fallback.
-
-
-          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}
-       *
-       * @private
-       */
-
-
-      static get _queueNames() {
-        return queueNames;
-      }
-
-    }
-
-    /*
-      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.
-    */
-    /**
-     * A class implementing the `fetchDidFail` lifecycle callback. This makes it
-     * easier to add failed requests to a background sync Queue.
-     *
-     * @memberof module:workbox-background-sync
-     */
-
-    class BackgroundSyncPlugin {
-      /**
-       * @param {string} name See the [Queue]{@link module:workbox-background-sync.Queue}
-       *     documentation for parameter details.
-       * @param {Object} [options] See the
-       *     [Queue]{@link module: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);
-      }
-
-    }
-
-    exports.BackgroundSyncPlugin = BackgroundSyncPlugin;
-    exports.Queue = Queue;
-
-    return exports;
-
-}({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private));
-//# sourceMappingURL=workbox-background-sync.dev.js.map
+this.workbox = this.workbox || {};
+this.workbox.backgroundSync = (function (exports, WorkboxError_js, logger_js, assert_js, getFriendlyURL_js, DBWrapper_js) {
+    'use strict';
+
+    try {
+      self['workbox:background-sync:5.1.3'] && _();
+    } catch (e) {}
+
+    /*
+      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.
+    */
+    const DB_VERSION = 3;
+    const DB_NAME = 'workbox-background-sync';
+    const OBJECT_STORE_NAME = 'requests';
+    const INDEXED_PROP = 'queueName';
+    /**
+     * A class to manage storing requests from a Queue in IndexedDB,
+     * indexed by their queue name for easier access.
+     *
+     * @private
+     */
+
+    class QueueStore {
+      /**
+       * Associates this instance with a Queue instance, so entries added can be
+       * identified by their queue name.
+       *
+       * @param {string} queueName
+       * @private
+       */
+      constructor(queueName) {
+        this._queueName = queueName;
+        this._db = new DBWrapper_js.DBWrapper(DB_NAME, DB_VERSION, {
+          onupgradeneeded: this._upgradeDb
+        });
+      }
+      /**
+       * Append an entry last in the queue.
+       *
+       * @param {Object} entry
+       * @param {Object} entry.requestData
+       * @param {number} [entry.timestamp]
+       * @param {Object} [entry.metadata]
+       * @private
+       */
+
+
+      async pushEntry(entry) {
+        {
+          assert_js.assert.isType(entry, 'object', {
+            moduleName: 'workbox-background-sync',
+            className: 'QueueStore',
+            funcName: 'pushEntry',
+            paramName: 'entry'
+          });
+          assert_js.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._db.add(OBJECT_STORE_NAME, entry);
+      }
+      /**
+       * Prepend an entry first in the queue.
+       *
+       * @param {Object} entry
+       * @param {Object} entry.requestData
+       * @param {number} [entry.timestamp]
+       * @param {Object} [entry.metadata]
+       * @private
+       */
+
+
+      async unshiftEntry(entry) {
+        {
+          assert_js.assert.isType(entry, 'object', {
+            moduleName: 'workbox-background-sync',
+            className: 'QueueStore',
+            funcName: 'unshiftEntry',
+            paramName: 'entry'
+          });
+          assert_js.assert.isType(entry.requestData, 'object', {
+            moduleName: 'workbox-background-sync',
+            className: 'QueueStore',
+            funcName: 'unshiftEntry',
+            paramName: 'entry.requestData'
+          });
+        }
+
+        const [firstEntry] = await this._db.getAllMatching(OBJECT_STORE_NAME, {
+          count: 1
+        });
+
+        if (firstEntry) {
+          // Pick an ID one less than the lowest ID in the object store.
+          entry.id = firstEntry.id - 1;
+        } else {
+          // Otherwise let the auto-incrementor assign the ID.
+          delete entry.id;
+        }
+
+        entry.queueName = this._queueName;
+        await this._db.add(OBJECT_STORE_NAME, entry);
+      }
+      /**
+       * Removes and returns the last entry in the queue matching the `queueName`.
+       *
+       * @return {Promise<Object>}
+       * @private
+       */
+
+
+      async popEntry() {
+        return this._removeEntry({
+          direction: 'prev'
+        });
+      }
+      /**
+       * Removes and returns the first entry in the queue matching the `queueName`.
+       *
+       * @return {Promise<Object>}
+       * @private
+       */
+
+
+      async shiftEntry() {
+        return this._removeEntry({
+          direction: 'next'
+        });
+      }
+      /**
+       * Returns all entries in the store matching the `queueName`.
+       *
+       * @param {Object} options See {@link module:workbox-background-sync.Queue~getAll}
+       * @return {Promise<Array<Object>>}
+       * @private
+       */
+
+
+      async getAll() {
+        return await this._db.getAllMatching(OBJECT_STORE_NAME, {
+          index: INDEXED_PROP,
+          query: IDBKeyRange.only(this._queueName)
+        });
+      }
+      /**
+       * Deletes the entry for the given ID.
+       *
+       * WARNING: this method does not ensure the deleted enry 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.
+       *
+       * @private
+       * @param {number} id
+       */
+
+
+      async deleteEntry(id) {
+        await this._db.delete(OBJECT_STORE_NAME, id);
+      }
+      /**
+       * Removes and returns the first or last entry in the queue (based on the
+       * `direction` argument) matching the `queueName`.
+       *
+       * @return {Promise<Object>}
+       * @private
+       */
+
+
+      async _removeEntry({
+        direction
+      }) {
+        const [entry] = await this._db.getAllMatching(OBJECT_STORE_NAME, {
+          direction,
+          index: INDEXED_PROP,
+          query: IDBKeyRange.only(this._queueName),
+          count: 1
+        });
+
+        if (entry) {
+          await this.deleteEntry(entry.id);
+          return entry;
+        }
+      }
+      /**
+       * Upgrades the database given an `upgradeneeded` event.
+       *
+       * @param {Event} event
+       * @private
+       */
+
+
+      _upgradeDb(event) {
+        const db = event.target.result;
+
+        if (event.oldVersion > 0 && event.oldVersion < DB_VERSION) {
+          if (db.objectStoreNames.contains(OBJECT_STORE_NAME)) {
+            db.deleteObjectStore(OBJECT_STORE_NAME);
+          }
+        }
+
+        const objStore = db.createObjectStore(OBJECT_STORE_NAME, {
+          autoIncrement: true,
+          keyPath: 'id'
+        });
+        objStore.createIndex(INDEXED_PROP, INDEXED_PROP, {
+          unique: false
+        });
+      }
+
+    }
+
+    /*
+      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.
+    */
+    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.
+     *
+     * @private
+     */
+
+    class 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}.
+       * @private
+       */
+      constructor(requestData) {
+        {
+          assert_js.assert.isType(requestData, 'object', {
+            moduleName: 'workbox-background-sync',
+            className: 'StorableRequest',
+            funcName: 'constructor',
+            paramName: 'requestData'
+          });
+          assert_js.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;
+      }
+      /**
+       * Converts a Request object to a plain object that can be structured
+       * cloned or JSON-stringified.
+       *
+       * @param {Request} request
+       * @return {Promise<StorableRequest>}
+       *
+       * @private
+       */
+
+
+      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);
+      }
+      /**
+       * Returns a deep clone of the instances `_requestData` object.
+       *
+       * @return {Object}
+       *
+       * @private
+       */
+
+
+      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}
+       *
+       * @private
+       */
+
+
+      toRequest() {
+        return new Request(this._requestData.url, this._requestData);
+      }
+      /**
+       * Creates and returns a deep clone of the instance.
+       *
+       * @return {StorableRequest}
+       *
+       * @private
+       */
+
+
+      clone() {
+        return new StorableRequest(this.toObject());
+      }
+
+    }
+
+    /*
+      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.
+    */
+    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 {Object} queueStoreEntry
+     * @return {Object}
+     * @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 module: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.
+       */
+      constructor(name, {
+        onSync,
+        maxRetentionTime
+      } = {}) {
+        this._syncInProgress = false;
+        this._requestsAddedDuringSync = false; // Ensure the store name is not already being used
+
+        if (queueNames.has(name)) {
+          throw new WorkboxError_js.WorkboxError('duplicate-queue-name', {
+            name
+          });
+        } else {
+          queueNames.add(name);
+        }
+
+        this._name = name;
+        this._onSync = onSync || this.replayRequests;
+        this._maxRetentionTime = maxRetentionTime || MAX_RETENTION_TIME;
+        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 {Object} 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) {
+        {
+          assert_js.assert.isType(entry, 'object', {
+            moduleName: 'workbox-background-sync',
+            className: 'Queue',
+            funcName: 'pushRequest',
+            paramName: 'entry'
+          });
+          assert_js.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 {Object} 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) {
+        {
+          assert_js.assert.isType(entry, 'object', {
+            moduleName: 'workbox-background-sync',
+            className: 'Queue',
+            funcName: 'unshiftRequest',
+            paramName: 'entry'
+          });
+          assert_js.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<Object>}
+       */
+
+
+      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<Object>}
+       */
+
+
+      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<Object>>}
+       */
+
+
+      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;
+      }
+      /**
+       * 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;
+        }
+
+        await this._queueStore[`${operation}Entry`](entry);
+
+        {
+          logger_js.logger.log(`Request for '${getFriendlyURL_js.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();
+        const entry = await this._queueStore[`${operation}Entry`]();
+
+        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 ("dev" !== 'production') {
+              logger_js.logger.log(`Request for '${getFriendlyURL_js.getFriendlyURL(entry.request.url)}'` + `has been replayed in queue '${this._name}'`);
+            }
+          } catch (error) {
+            await this.unshiftRequest(entry);
+
+            {
+              logger_js.logger.log(`Request for '${getFriendlyURL_js.getFriendlyURL(entry.request.url)}'` + `failed to replay, putting it back in queue '${this._name}'`);
+            }
+
+            throw new WorkboxError_js.WorkboxError('queue-replay-failed', {
+              name: this._name
+            });
+          }
+        }
+
+        {
+          logger_js.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() {
+        if ('sync' in self.registration) {
+          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.
+            {
+              logger_js.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, this will retry the queue on service
+       * worker startup.
+       *
+       * @private
+       */
+
+
+      _addSyncListener() {
+        if ('sync' in self.registration) {
+          self.addEventListener('sync', event => {
+            if (event.tag === `${TAG_PREFIX}:${this._name}`) {
+              {
+                logger_js.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) {
+                  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 {
+          {
+            logger_js.logger.log(`Background sync replaying without background sync event`);
+          } // If the browser doesn't support background sync, retry
+          // every time the service worker starts up as a fallback.
+
+
+          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}
+       *
+       * @private
+       */
+
+
+      static get _queueNames() {
+        return queueNames;
+      }
+
+    }
+
+    /*
+      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.
+    */
+    /**
+     * A class implementing the `fetchDidFail` lifecycle callback. This makes it
+     * easier to add failed requests to a background sync Queue.
+     *
+     * @memberof module:workbox-background-sync
+     */
+
+    class BackgroundSyncPlugin {
+      /**
+       * @param {string} name See the [Queue]{@link module:workbox-background-sync.Queue}
+       *     documentation for parameter details.
+       * @param {Object} [options] See the
+       *     [Queue]{@link module: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);
+      }
+
+    }
+
+    exports.BackgroundSyncPlugin = BackgroundSyncPlugin;
+    exports.Queue = Queue;
+
+    return exports;
+
+}({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private));
+//# sourceMappingURL=workbox-background-sync.dev.js.map