		(function (global, factory) {
		typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
		typeof define === 'function' && define.amd ? define(['exports'], factory) :
		(global = global \|\| self, factory(global.workbox = {}));
		typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
		typeof define === 'function' && define.amd ? define(['exports'], factory) :
		(global = global \|\| self, factory(global.workbox = {}));
		}(this, function (exports) { 'use strict';

		try {
		self['workbox:window:5.0.0-alpha.0'] && _();
		} catch (e) {} // eslint-disable-line
		// @ts-ignore
		try {
		self['workbox:window:5.0.0-alpha.1'] && _();
		} catch (e) {}

		/*
		Copyright 2019 Google LLC
		/*
		Copyright 2019 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.
		*/
		/**
		* Sends a data object to a service worker via `postMessage` and resolves with
		* a response (if any).
		*
		* A response can be set in a message handler in the service worker by
		* calling `event.ports[0].postMessage(...)`, which will resolve the promise
		* returned by `messageSW()`. If no response is set, the promise will not
		* resolve.
		*
		* @param {ServiceWorker} sw The service worker to send the message to.
		* @param {Object} data An object to send to the service worker.
		* @return {Promise<Object\|undefined>}
		*
		* @memberof module:workbox-window
		*/
		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.
		*/
		/**
		* Sends a data object to a service worker via `postMessage` and resolves with
		* a response (if any).
		*
		* A response can be set in a message handler in the service worker by
		* calling `event.ports[0].postMessage(...)`, which will resolve the promise
		* returned by `messageSW()`. If no response is set, the promise will not
		* resolve.
		*
		* @param {ServiceWorker} sw The service worker to send the message to.
		* @param {Object} data An object to send to the service worker.
		* @return {Promise<Object\|undefined>}
		*
		* @memberof module:workbox-window
		*/

		var messageSW = function messageSW(sw, data) {
		return new Promise(function (resolve) {
		var messageChannel = new MessageChannel();
		function messageSW(sw, data) {
		return new Promise(function (resolve) {
		var messageChannel = new MessageChannel();

		messageChannel.port1.onmessage = function (evt) {
		return resolve(evt.data);
		};
		messageChannel.port1.onmessage = function (event) {
		resolve(event.data);
		};

		sw.postMessage(data, [messageChannel.port2]);
		});
		};
		sw.postMessage(data, [messageChannel.port2]);
		});
		}

		function _defineProperties(target, props) {
		for (var i = 0; i < props.length; i++) {
		var descriptor = props[i];
		descriptor.enumerable = descriptor.enumerable \|\| false;
		descriptor.configurable = true;
		if ("value" in descriptor) descriptor.writable = true;
		Object.defineProperty(target, descriptor.key, descriptor);
		function _defineProperties(target, props) {
		for (var i = 0; i < props.length; i++) {
		var descriptor = props[i];
		descriptor.enumerable = descriptor.enumerable \|\| false;
		descriptor.configurable = true;
		if ("value" in descriptor) descriptor.writable = true;
		Object.defineProperty(target, descriptor.key, descriptor);
		}
		}
		}

		function _createClass(Constructor, protoProps, staticProps) {
		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
		if (staticProps) _defineProperties(Constructor, staticProps);
		return Constructor;
		}
		function _createClass(Constructor, protoProps, staticProps) {
		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
		if (staticProps) _defineProperties(Constructor, staticProps);
		return Constructor;
		}

		function _inheritsLoose(subClass, superClass) {
		subClass.prototype = Object.create(superClass.prototype);
		subClass.prototype.constructor = subClass;
		subClass.__proto__ = superClass;
		}

		function _assertThisInitialized(self) {
		if (self === void 0) {
		throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
		function _inheritsLoose(subClass, superClass) {
		subClass.prototype = Object.create(superClass.prototype);
		subClass.prototype.constructor = subClass;
		subClass.__proto__ = superClass;
		}

		return self;
		}
		// @ts-ignore
		try {
		self['workbox:core:5.0.0-alpha.1'] && _();
		} catch (e) {}

		try {
		self['workbox:core:5.0.0-alpha.0'] && _();
		} catch (e) {} // eslint-disable-line
		/*
		Copyright 2018 Google LLC

		/*
		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.
		*/
		/**
		* The Deferred class composes Promises in a way that allows for them to be
		* resolved or rejected from outside the constructor. In most cases promises
		* should be used directly, but Deferreds can be necessary when the logic to
		* resolve a promise must be separate.
		*
		* @private
		*/

		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.
		*/
		/**
		* The Deferred class composes Promises in a way that allows for them to be
		* resolved or rejected from outside the constructor. In most cases promises
		* should be used directly, but Deferreds can be necessary when the logic to
		* resolve a promise must be separate.
		*
		* @private
		*/
		var Deferred =
		/**
		* Creates a promise and exposes its resolve and reject functions as methods.
		*/
		function Deferred() {
		var _this = this;

		var Deferred =
		/**
		* Creates a promise and exposes its resolve and reject functions as methods.
		*/
		function Deferred() {
		var _this = this;
		this.promise = new Promise(function (resolve, reject) {
		_this.resolve = resolve;
		_this.reject = reject;
		});
		};

		this.promise = new Promise(function (resolve, reject) {
		_this.resolve = resolve;
		_this.reject = reject;
		});
		};
		/*
		Copyright 2019 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.
		*/
		var logger = function () {
		var inGroup = false;
		var methodToColorMap = {
		debug: "#7f8c8d",
		log: "#2ecc71",
		warn: "#f39c12",
		error: "#c0392b",
		groupCollapsed: "#3498db",
		groupEnd: null
		};

		/*
		Copyright 2019 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.
		*/
		var logger = function () {
		var inGroup = false;
		var methodToColorMap = {
		debug: "#7f8c8d",
		// Gray
		log: "#2ecc71",
		// Green
		warn: "#f39c12",
		// Yellow
		error: "#c0392b",
		// Red
		groupCollapsed: "#3498db",
		// Blue
		groupEnd: null // No colored prefix on groupEnd
		var print = function print(method, args) {
		var _console2;

		};
		if (method === 'groupCollapsed') {
		// Safari doesn't print all console.groupCollapsed() arguments:
		// https://bugs.webkit.org/show_bug.cgi?id=182754
		if (/^((?!chrome\|android).)*safari/i.test(navigator.userAgent)) {
		var _console;

		var print = function print(method, args) {
		var _console2;
		(_console = console)[method].apply(_console, args);

		if (method === 'groupCollapsed') {
		// Safari doesn't print all console.groupCollapsed() arguments:
		// https://bugs.webkit.org/show_bug.cgi?id=182754
		if (/^((?!chrome\|android).)*safari/i.test(navigator.userAgent)) {
		var _console;

		(_console = console)[method].apply(_console, args);

		return;
		return;
		}
		}
		}

		var styles = ["background: " + methodToColorMap[method], "border-radius: 0.5em", "color: white", "font-weight: bold", "padding: 2px 0.5em"]; // When in a group, the workbox prefix is not displayed.
		var styles = ["background: " + methodToColorMap[method], "border-radius: 0.5em", "color: white", "font-weight: bold", "padding: 2px 0.5em"]; // When in a group, the workbox prefix is not displayed.

		var logPrefix = inGroup ? [] : ['%cworkbox', styles.join(';')];
		var logPrefix = inGroup ? [] : ['%cworkbox', styles.join(';')];

		(_console2 = console)[method].apply(_console2, logPrefix.concat(args));
		(_console2 = console)[method].apply(_console2, logPrefix.concat(args));

		if (method === 'groupCollapsed') {
		inGroup = true;
		}
		if (method === 'groupCollapsed') {
		inGroup = true;
		}

		if (method === 'groupEnd') {
		inGroup = false;
		}
		};
		if (method === 'groupEnd') {
		inGroup = false;
		}
		};

		var api = {};
		var api = {};
		var loggerMethods = Object.keys(methodToColorMap);

		var _arr = Object.keys(methodToColorMap);
		var _loop = function _loop() {
		var key = loggerMethods[_i];
		var method = key;

		var _loop = function _loop() {
		var method = _arr[_i];
		api[method] = function () {
		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		api[method] = function () {
		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
		args[_key] = arguments[_key];
		}

		print(method, args);
		print(method, args);
		};
		};
		};

		for (var _i = 0; _i < _arr.length; _i++) {
		_loop();
		}
		for (var _i = 0; _i < loggerMethods.length; _i++) {
		_loop();
		}

		return api;
		}();
		return api;
		}();

		/*
		Copyright 2019 Google LLC
		/*
		Copyright 2019 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 minimal `EventTarget` shim.
		* This is necessary because not all browsers support constructable
		* `EventTarget`, so using a real `EventTarget` will error.
		* @private
		*/

		var EventTargetShim =
		/#__PURE__/
		function () {
		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.
		*/
		/**
		* Creates an event listener registry
		*
		* A minimal `EventTarget` shim.
		* This is necessary because not all browsers support constructable
		* `EventTarget`, so using a real `EventTarget` will error.
		* @private
		*/
		function EventTargetShim() {
		// A registry of event types to listeners.
		this._eventListenerRegistry = {};
		}
		/**
		* @param {string} type
		* @param {Function} listener
		* @private
		*/

		var WorkboxEventTarget =
		/#__PURE__/
		function () {
		function WorkboxEventTarget() {
		this._eventListenerRegistry = {};
		}
		/**
		* @param {string} type
		* @param {Function} listener
		* @private
		*/

		var _proto = EventTargetShim.prototype;

		_proto.addEventListener = function addEventListener(type, listener) {
		this._getEventListenersByType(type).add(listener);
		};
		/**
		* @param {string} type
		* @param {Function} listener
		* @private
		*/
		var _proto = WorkboxEventTarget.prototype;

		_proto.addEventListener = function addEventListener(type, listener) {
		this._getEventListenersByType(type).add(listener);
		};
		/**
		* @param {string} type
		* @param {Function} listener
		* @private
		*/

		_proto.removeEventListener = function removeEventListener(type, listener) {
		this._getEventListenersByType(type).delete(listener);
		};
		/**
		* @param {Event} event
		* @private
		*/

		_proto.removeEventListener = function removeEventListener(type, listener) {
		this._getEventListenersByType(type).delete(listener);
		};
		/**
		* @param {Object} event
		* @private
		*/

		_proto.dispatchEvent = function dispatchEvent(event) {
		event.target = this;

		this._getEventListenersByType(event.type).forEach(function (listener) {
		return listener(event);
		});
		};
		/**
		* Returns a Set of listeners associated with the passed event type.
		* If no handlers have been registered, an empty Set is returned.
		*
		* @param {string} type The event type.
		* @return {Set} An array of handler functions.
		* @private
		*/
		_proto.dispatchEvent = function dispatchEvent(event) {
		event.target = this;

		var listeners = this._getEventListenersByType(event.type);

		_proto._getEventListenersByType = function _getEventListenersByType(type) {
		return this._eventListenerRegistry[type] = this._eventListenerRegistry[type] \|\| new Set();
		};
		for (var _iterator = listeners, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
		var _ref;

		return EventTargetShim;
		}();
		if (_isArray) {
		if (_i >= _iterator.length) break;
		_ref = _iterator[_i++];
		} else {
		_i = _iterator.next();
		if (_i.done) break;
		_ref = _i.value;
		}

		/*
		Copyright 2019 Google LLC
		var listener = _ref;
		listener(event);
		}
		};
		/**
		* Returns a Set of listeners associated with the passed event type.
		* If no handlers have been registered, an empty Set is returned.
		*
		* @param {string} type The event type.
		* @return {Set<ListenerCallback>} An array of handler functions.
		* @private
		*/

		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.
		*/
		/**
		* Returns true if two URLs have the same `.href` property. The URLS can be
		* relative, and if they are the current location href is used to resolve URLs.
		*
		* @private
		* @param {string} url1
		* @param {string} url2
		* @return {boolean}
		*/

		var urlsMatch = function urlsMatch(url1, url2) {
		return new URL(url1, location).href === new URL(url2, location).href;
		};
		_proto._getEventListenersByType = function _getEventListenersByType(type) {
		return this._eventListenerRegistry[type] = this._eventListenerRegistry[type] \|\| new Set();
		};

		/*
		Copyright 2019 Google LLC
		return WorkboxEventTarget;
		}();

		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 minimal `Event` subclass shim.
		* This doesn't actually subclass `Event` because not all browsers support
		* constructable `EventTarget`, and using a real `Event` will error.
		* @private
		*/
		/*
		Copyright 2019 Google LLC

		var WorkboxEvent =
		/**
		* @param {string} type
		* @param {Object} props
		*/
		function WorkboxEvent(type, props) {
		Object.assign(this, props, {
		type: type
		});
		};
		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.
		*/
		/**
		* Returns true if two URLs have the same `.href` property. The URLS can be
		* relative, and if they are the current location href is used to resolve URLs.
		*
		* @private
		* @param {string} url1
		* @param {string} url2
		* @return {boolean}
		*/

		function _catch(body, recover) {
		try {
		var result = body();
		} catch (e) {
		return recover(e);
		function urlsMatch(url1, url2) {
		var _location = location,
		href = _location.href;
		return new URL(url1, href).href === new URL(url2, href).href;
		}

		if (result && result.then) {
		return result.then(void 0, recover);
		}
		/*
		Copyright 2019 Google LLC

		return result;
		}
		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 minimal `Event` subclass shim.
		* This doesn't actually subclass `Event` because not all browsers support
		* constructable `EventTarget`, and using a real `Event` will error.
		* @private
		*/

		function _async(f) {
		return function () {
		for (var args = [], i = 0; i < arguments.length; i++) {
		args[i] = arguments[i];
		}
		var WorkboxEvent = function WorkboxEvent(type, props) {
		this.type = type;
		Object.assign(this, props);
		};

		function _catch(body, recover) {
		try {
		return Promise.resolve(f.apply(this, args));
		var result = body();
		} catch (e) {
		return Promise.reject(e);
		return recover(e);
		}
		};
		}

		function _invoke(body, then) {
		var result = body();
		if (result && result.then) {
		return result.then(void 0, recover);
		}

		if (result && result.then) {
		return result.then(then);
		return result;
		}

		return then(result);
		}
		function _async(f) {
		return function () {
		for (var args = [], i = 0; i < arguments.length; i++) {
		args[i] = arguments[i];
		}

		function _await(value, then, direct) {
		if (direct) {
		return then ? then(value) : value;
		try {
		return Promise.resolve(f.apply(this, args));
		} catch (e) {
		return Promise.reject(e);
		}
		};
		}

		if (!value \|\| !value.then) {
		value = Promise.resolve(value);
		}
		function _invoke(body, then) {
		var result = body();

		return then ? value.then(then) : value;
		}
		if (result && result.then) {
		return result.then(then);
		}

		function _awaitIgnored(value, direct) {
		if (!direct) {
		return value && value.then ? value.then(_empty) : Promise.resolve();
		return then(result);
		}
		}

		function _empty() {}
		// `skipWaiting()` wasn't called. This 200 amount wasn't scientifically
		// chosen, but it seems to avoid false positives in my testing.
		function _await(value, then, direct) {
		if (direct) {
		return then ? then(value) : value;
		}

		var WAITING_TIMEOUT_DURATION = 200; // The amount of time after a registration that we can reasonably conclude
		// that the registration didn't trigger an update.
		if (!value \|\| !value.then) {
		value = Promise.resolve(value);
		}

		var REGISTRATION_TIMEOUT_DURATION = 60000;
		/**
		* A class to aid in handling service worker registration, updates, and
		* reacting to service worker lifecycle events.
		*
		* @fires [message]{@link module:workbox-window.Workbox#message}
		* @fires [installed]{@link module:workbox-window.Workbox#installed}
		* @fires [waiting]{@link module:workbox-window.Workbox#waiting}
		* @fires [controlling]{@link module:workbox-window.Workbox#controlling}
		* @fires [activated]{@link module:workbox-window.Workbox#activated}
		* @fires [redundant]{@link module:workbox-window.Workbox#redundant}
		* @fires [externalinstalled]{@link module:workbox-window.Workbox#externalinstalled}
		* @fires [externalwaiting]{@link module:workbox-window.Workbox#externalwaiting}
		* @fires [externalactivated]{@link module:workbox-window.Workbox#externalactivated}
		*
		* @memberof module:workbox-window
		*/
		return then ? value.then(then) : value;
		}

		var Workbox =
		/#__PURE__/
		function (_EventTargetShim) {
		_inheritsLoose(Workbox, _EventTargetShim);

		/**
		* Creates a new Workbox instance with a script URL and service worker
		* options. The script URL and options are the same as those used when
		* calling `navigator.serviceWorker.register(scriptURL, options)`. See:
		* https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register
		*
		* @param {string} scriptURL The service worker script associated with this
		* instance.
		* @param {Object} [registerOptions] The service worker options associated
		* with this instance.
		*/
		function Workbox(scriptURL, registerOptions) {
		var _this;

		if (registerOptions === void 0) {
		registerOptions = {};
		function _awaitIgnored(value, direct) {
		if (!direct) {
		return value && value.then ? value.then(_empty) : Promise.resolve();
		}
		}

		_this = _EventTargetShim.call(this) \|\| this;
		_this._scriptURL = scriptURL;
		_this._registerOptions = registerOptions;
		_this._updateFoundCount = 0; // Deferreds we can resolve later.
		function _empty() {}
		// `skipWaiting()` wasn't called. This 200 amount wasn't scientifically
		// chosen, but it seems to avoid false positives in my testing.

		_this._swDeferred = new Deferred();
		_this._activeDeferred = new Deferred();
		_this._controllingDeferred = new Deferred(); // Bind event handler callbacks.
		var WAITING_TIMEOUT_DURATION = 200; // The amount of time after a registration that we can reasonably conclude
		// that the registration didn't trigger an update.

		_this._onMessage = _this._onMessage.bind(_assertThisInitialized(_assertThisInitialized(_this)));
		_this._onStateChange = _this._onStateChange.bind(_assertThisInitialized(_assertThisInitialized(_this)));
		_this._onUpdateFound = _this._onUpdateFound.bind(_assertThisInitialized(_assertThisInitialized(_this)));
		_this._onControllerChange = _this._onControllerChange.bind(_assertThisInitialized(_assertThisInitialized(_this)));
		return _this;
		}
		var REGISTRATION_TIMEOUT_DURATION = 60000;
		/**
		* Registers a service worker for this instances script URL and service
		* worker options. By default this method delays registration until after
		* the window has loaded.
		* A class to aid in handling service worker registration, updates, and
		* reacting to service worker lifecycle events.
		*
		* @param {Object} [options]
		* @param {Function} [options.immediate=false] Setting this to true will
		* register the service worker immediately, even if the window has
		* not loaded (not recommended).
		* @fires [message]{@link module:workbox-window.Workbox#message}
		* @fires [installed]{@link module:workbox-window.Workbox#installed}
		* @fires [waiting]{@link module:workbox-window.Workbox#waiting}
		* @fires [controlling]{@link module:workbox-window.Workbox#controlling}
		* @fires [activated]{@link module:workbox-window.Workbox#activated}
		* @fires [redundant]{@link module:workbox-window.Workbox#redundant}
		* @fires [externalinstalled]{@link module:workbox-window.Workbox#externalinstalled}
		* @fires [externalwaiting]{@link module:workbox-window.Workbox#externalwaiting}
		* @fires [externalactivated]{@link module:workbox-window.Workbox#externalactivated}
		*
		* @memberof module:workbox-window
		*/

		var Workbox =
		/#__PURE__/
		function (_WorkboxEventTarget) {
		_inheritsLoose(Workbox, _WorkboxEventTarget);

		var _proto = Workbox.prototype;
		_proto.register = _async(function (_temp) {
		var _this2 = this;
		/**
		* Creates a new Workbox instance with a script URL and service worker
		* options. The script URL and options are the same as those used when
		* calling `navigator.serviceWorker.register(scriptURL, options)`. See:
		* https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register
		*
		* @param {string} scriptURL The service worker script associated with this
		* instance.
		* @param {Object} [registerOptions] The service worker options associated
		* with this instance.
		*/
		function Workbox(scriptURL, registerOptions) {
		var _this;

		var _ref = _temp === void 0 ? {} : _temp,
		_ref$immediate = _ref.immediate,
		immediate = _ref$immediate === void 0 ? false : _ref$immediate;

		{
		if (_this2._registrationTime) {
		logger.error('Cannot re-register a Workbox instance after it has ' + 'been registered. Create a new instance instead.');
		return;
		if (registerOptions === void 0) {
		registerOptions = {};
		}
		}

		return _invoke(function () {
		if (!immediate && document.readyState !== 'complete') {
		return _awaitIgnored(new Promise(function (res) {
		return addEventListener('load', res);
		}));
		}
		}, function () {
		// Set this flag to true if any service worker was controlling the page
		// at registration time.
		_this2._isUpdate = Boolean(navigator.serviceWorker.controller); // Before registering, attempt to determine if a SW is already controlling
		// the page, and if that SW script (and version, if specified) matches this
		// instance's script.
		_this = _WorkboxEventTarget.call(this) \|\| this;
		_this._registerOptions = {};
		_this._updateFoundCount = 0; // Deferreds we can resolve later.

		_this2._compatibleControllingSW = _this2._getControllingSWIfCompatible();
		return _await(_this2._registerScript(), function (_this2$_registerScrip) {
		_this2._registration = _this2$_registerScrip;
		_this._swDeferred = new Deferred();
		_this._activeDeferred = new Deferred();
		_this._controllingDeferred = new Deferred();
		_this._registrationTime = 0;
		/**
		* @private
		*/

		// If we have a compatible controller, store the controller as the "own"
		// SW, resolve active/controlling deferreds and add necessary listeners.
		if (_this2._compatibleControllingSW) {
		_this2._sw = _this2._compatibleControllingSW;
		_this._onUpdateFound = function () {
		// `this._registration` will never be `undefined` after an update is found.
		var registration = _this._registration;
		var installingSW = registration.installing; // If the script URL passed to `navigator.serviceWorker.register()` is
		// different from the current controlling SW's script URL, we know any
		// successful registration calls will trigger an `updatefound` event.
		// But if the registered script URL is the same as the current controlling
		// SW's script URL, we'll only get an `updatefound` event if the file
		// changed since it was last registered. This can be a problem if the user
		// opens up the same page in a different tab, and that page registers
		// a SW that triggers an update. It's a problem because this page has no
		// good way of knowing whether the `updatefound` event came from the SW
		// script it registered or from a registration attempt made by a newer
		// version of the page running in another tab.
		// To minimize the possibility of a false positive, we use the logic here:

		_this2._activeDeferred.resolve(_this2._compatibleControllingSW);
		var updateLikelyTriggeredExternally = // Since we enforce only calling `register()` once, and since we don't
		// add the `updatefound` event listener until the `register()` call, if
		// `_updateFoundCount` is > 0 then it means this method has already
		// been called, thus this SW must be external
		_this._updateFoundCount > 0 \|\| // If the script URL of the installing SW is different from this
		// instance's script URL, we know it's definitely not from our
		// registration.
		!urlsMatch(installingSW.scriptURL, _this._scriptURL) \|\| // If all of the above are false, then we use a time-based heuristic:
		// Any `updatefound` event that occurs long after our registration is
		// assumed to be external.
		performance.now() > _this._registrationTime + REGISTRATION_TIMEOUT_DURATION ? // If any of the above are not true, we assume the update was
		// triggered by this instance.
		true : false;

		_this2._controllingDeferred.resolve(_this2._compatibleControllingSW);
		if (updateLikelyTriggeredExternally) {
		_this._externalSW = installingSW;
		registration.removeEventListener('updatefound', _this._onUpdateFound);
		} else {
		// If the update was not triggered externally we know the installing
		// SW is the one we registered, so we set it.
		_this._sw = installingSW;

		_this2._reportWindowReady(_this2._compatibleControllingSW);
		_this._swDeferred.resolve(installingSW); // The `installing` state isn't something we have a dedicated
		// callback for, but we do log messages for it in development.

		_this2._compatibleControllingSW.addEventListener('statechange', _this2._onStateChange, {
		once: true
		});
		} // If there's a waiting service worker with a matching URL before the
		// `updatefound` event fires, it likely means that this site is open
		// in another tab, or the user refreshed the page (and thus the prevoius
		// page wasn't fully unloaded before this page started loading).
		// https://developers.google.com/web/fundamentals/primers/service-workers/lifecycle#waiting

		{
		if (navigator.serviceWorker.controller) {
		logger.log('Updated service worker found. Installing now...');
		} else {
		logger.log('Service worker is installing...');
		}
		}
		} // Increment the `updatefound` count, so future invocations of this
		// method can be sure they were triggered externally.

		var waitingSW = _this2._registration.waiting;

		if (waitingSW && urlsMatch(waitingSW.scriptURL, _this2._scriptURL)) {
		// Store the waiting SW as the "own" Sw, even if it means overwriting
		// a compatible controller.
		_this2._sw = waitingSW; // Run this in the next microtask, so any code that adds an event
		// listener after awaiting `register()` will get this event.
		++_this._updateFoundCount; // Add a `statechange` listener regardless of whether this update was
		// triggered externally, since we have callbacks for both.

		Promise.resolve().then(function () {
		_this2.dispatchEvent(new WorkboxEvent('waiting', {
		sw: waitingSW,
		wasWaitingBeforeRegister: true
		}));
		installingSW.addEventListener('statechange', _this._onStateChange);
		};
		/**
		* @private
		* @param {Event} originalEvent
		*/

		{
		logger.warn('A service worker was already waiting to activate ' + 'before this script was registered...');
		}
		});
		} // If an "own" SW is already set, resolve the deferred.

		_this._onStateChange = function (originalEvent) {
		// `this._registration` will never be `undefined` after an update is found.
		var registration = _this._registration;
		var sw = originalEvent.target;
		var state = sw.state;
		var isExternal = sw === _this._externalSW;
		var eventPrefix = isExternal ? 'external' : '';
		var eventProps = {
		sw: sw,
		originalEvent: originalEvent
		};

		if (_this2._sw) {
		_this2._swDeferred.resolve(_this2._sw);
		if (!isExternal && _this._isUpdate) {
		eventProps.isUpdate = true;
		}

		{
		logger.log('Successfully registered service worker.', _this2._scriptURL);
		_this.dispatchEvent(new WorkboxEvent(eventPrefix + state, eventProps));

		if (navigator.serviceWorker.controller) {
		if (_this2._compatibleControllingSW) {
		logger.debug('A service worker with the same script URL ' + 'is already controlling this page.');
		} else {
		logger.debug('A service worker with a different script URL is ' + 'currently controlling the page. The browser is now fetching ' + 'the new script now...');
		if (state === 'installed') {
		// This timeout is used to ignore cases where the service worker calls
		// `skipWaiting()` in the install event, thus moving it directly in the
		// activating state. (Since all service workers must go through the
		// waiting phase, the only way to detect `skipWaiting()` called in the
		// install event is to observe that the time spent in the waiting phase
		// is very short.)
		// NOTE: we don't need separate timeouts for the own and external SWs
		// since they can't go through these phases at the same time.
		_this._waitingTimeout = self.setTimeout(function () {
		// Ensure the SW is still waiting (it may now be redundant).
		if (state === 'installed' && registration.waiting === sw) {
		_this.dispatchEvent(new WorkboxEvent(eventPrefix + 'waiting', eventProps));

		{
		if (isExternal) {
		logger.warn('An external service worker has installed but is ' + 'waiting for this client to close before activating...');
		} else {
		logger.warn('The service worker has installed but is waiting ' + 'for existing clients to close before activating...');
		}
		}
		}
		}
		}, WAITING_TIMEOUT_DURATION);
		} else if (state === 'activating') {
		clearTimeout(_this._waitingTimeout);

		var currentPageIsOutOfScope = function currentPageIsOutOfScope() {
		var scopeURL = new URL(_this2._registerOptions.scope \|\| _this2._scriptURL, document.baseURI);
		var scopeURLBasePath = new URL('./', scopeURL.href).pathname;
		return !location.pathname.startsWith(scopeURLBasePath);
		};

		if (currentPageIsOutOfScope()) {
		logger.warn('The current page is not in scope for the registered ' + 'service worker. Was this a mistake?');
		if (!isExternal) {
		_this._activeDeferred.resolve(sw);
		}
		}

		_this2._registration.addEventListener('updatefound', _this2._onUpdateFound);
		{
		switch (state) {
		case 'installed':
		if (isExternal) {
		logger.warn('An external service worker has installed. ' + 'You may want to suggest users reload this page.');
		} else {
		logger.log('Registered service worker installed.');
		}

		navigator.serviceWorker.addEventListener('controllerchange', _this2._onControllerChange, {
		once: true
		}); // Add message listeners.
		break;

		if ('BroadcastChannel' in self) {
		_this2._broadcastChannel = new BroadcastChannel('workbox');
		case 'activated':
		if (isExternal) {
		logger.warn('An external service worker has activated.');
		} else {
		logger.log('Registered service worker activated.');

		_this2._broadcastChannel.addEventListener('message', _this2._onMessage);
		}
		if (sw !== navigator.serviceWorker.controller) {
		logger.warn('The registered service worker is active but ' + 'not yet controlling the page. Reload or run ' + '`clients.claim()` in the service worker.');
		}
		}

		navigator.serviceWorker.addEventListener('message', _this2._onMessage);
		return _this2._registration;
		});
		});
		});
		/**
		* Resolves to the service worker registered by this instance as soon as it
		* is active. If a service worker was already controlling at registration
		* time then it will resolve to that if the script URLs (and optionally
		* script versions) match, otherwise it will wait until an update is found
		* and activates.
		*
		* @return {Promise<ServiceWorker>}
		*/
		break;

		/**
		* Resolves with a reference to a service worker that matches the script URL
		* of this instance, as soon as it's available.
		*
		* If, at registration time, there's already an active or waiting service
		* worker with a matching script URL, it will be used (with the waiting
		* service worker taking precedence over the active service worker if both
		* match, since the waiting service worker would have been registered more
		* recently).
		* If there's no matching active or waiting service worker at registration
		* time then the promise will not resolve until an update is found and starts
		* installing, at which point the installing service worker is used.
		*
		* @return {Promise<ServiceWorker>}
		*/
		_proto.getSW = _async(function () {
		var _this3 = this;
		case 'redundant':
		if (sw === _this._compatibleControllingSW) {
		logger.log('Previously controlling service worker now redundant!');
		} else if (!isExternal) {
		logger.log('Registered service worker now redundant!');
		}

		// If `this._sw` is set, resolve with that as we want `getSW()` to
		// return the correct (new) service worker if an update is found.
		return _this3._sw \|\| _this3._swDeferred.promise;
		});
		/**
		* Sends the passed data object to the service worker registered by this
		* instance (via [`getSW()`]{@link module:workbox-window.Workbox#getSW}) and resolves
		* with a response (if any).
		*
		* A response can be set in a message handler in the service worker by
		* calling `event.ports[0].postMessage(...)`, which will resolve the promise
		* returned by `messageSW()`. If no response is set, the promise will never
		* resolve.
		*
		* @param {Object} data An object to send to the service worker
		* @return {Promise<Object>}
		*/
		break;
		}
		}
		};
		/**
		* @private
		* @param {Event} originalEvent
		*/

		_proto.messageSW = _async(function (data) {
		var _this4 = this;

		return _await(_this4.getSW(), function (sw) {
		return messageSW(sw, data);
		});
		});
		/**
		* Checks for a service worker already controlling the page and returns
		* it if its script URL matchs.
		*
		* @private
		* @return {ServiceWorker\|undefined}
		*/
		_this._onControllerChange = function (originalEvent) {
		var sw = _this._sw;

		_proto._getControllingSWIfCompatible = function _getControllingSWIfCompatible() {
		var controller = navigator.serviceWorker.controller;
		if (sw === navigator.serviceWorker.controller) {
		_this.dispatchEvent(new WorkboxEvent('controlling', {
		sw: sw,
		originalEvent: originalEvent,
		isUpdate: _this._isUpdate
		}));

		if (controller && urlsMatch(controller.scriptURL, this._scriptURL)) {
		return controller;
		}
		};
		/**
		* Registers a service worker for this instances script URL and register
		* options and tracks the time registration was complete.
		*
		* @private
		*/
		{
		logger.log('Registered service worker now controlling this page.');
		}

		_this._controllingDeferred.resolve(sw);
		}
		};
		/**
		* @private
		* @param {Event} originalEvent
		*/

		_proto._registerScript = _async(function () {
		var _this5 = this;

		return _catch(function () {
		return _await(navigator.serviceWorker.register(_this5._scriptURL, _this5._registerOptions), function (reg) {
		// Keep track of when registration happened, so it can be used in the
		// `this._onUpdateFound` heuristic. Also use the presence of this
		// property as a way to see if `.register()` has been called.
		_this5._registrationTime = performance.now();
		return reg;
		});
		}, function (error) {
		{
		logger.error(error);
		} // Re-throw the error.
		_this._onMessage = function (originalEvent) {
		var data = originalEvent.data;

		_this.dispatchEvent(new WorkboxEvent('message', {
		data: data,
		originalEvent: originalEvent
		}));
		};

		throw error;
		});
		});
		/**
		* Sends a message to the passed service worker that the window is ready.
		*
		* @param {ServiceWorker} sw
		* @private
		*/
		_this._scriptURL = scriptURL;
		_this._registerOptions = registerOptions;
		return _this;
		}
		/**
		* Registers a service worker for this instances script URL and service
		* worker options. By default this method delays registration until after
		* the window has loaded.
		*
		* @param {Object} [options]
		* @param {Function} [options.immediate=false] Setting this to true will
		* register the service worker immediately, even if the window has
		* not loaded (not recommended).
		*/

		_proto._reportWindowReady = function _reportWindowReady(sw) {
		messageSW(sw, {
		type: 'WINDOW_READY',
		meta: 'workbox-window'
		});
		};
		/**
		* @private
		*/

		var _proto = Workbox.prototype;
		_proto.register = _async(function (_temp) {
		var _this2 = this;

		_proto._onUpdateFound = function _onUpdateFound() {
		var installingSW = this._registration.installing; // If the script URL passed to `navigator.serviceWorker.register()` is
		// different from the current controlling SW's script URL, we know any
		// successful registration calls will trigger an `updatefound` event.
		// But if the registered script URL is the same as the current controlling
		// SW's script URL, we'll only get an `updatefound` event if the file
		// changed since it was last registered. This can be a problem if the user
		// opens up the same page in a different tab, and that page registers
		// a SW that triggers an update. It's a problem because this page has no
		// good way of knowing whether the `updatefound` event came from the SW
		// script it registered or from a registration attempt made by a newer
		// version of the page running in another tab.
		// To minimize the possibility of a false positive, we use the logic here:
		var _ref = _temp === void 0 ? {} : _temp,
		_ref$immediate = _ref.immediate,
		immediate = _ref$immediate === void 0 ? false : _ref$immediate;

		var updateLikelyTriggeredExternally = // Since we enforce only calling `register()` once, and since we don't
		// add the `updatefound` event listener until the `register()` call, if
		// `_updateFoundCount` is > 0 then it means this method has already
		// been called, thus this SW must be external
		this._updateFoundCount > 0 \|\| // If the script URL of the installing SW is different from this
		// instance's script URL, we know it's definitely not from our
		// registration.
		!urlsMatch(installingSW.scriptURL, this._scriptURL) \|\| // If all of the above are false, then we use a time-based heuristic:
		// Any `updatefound` event that occurs long after our registration is
		// assumed to be external.
		performance.now() > this._registrationTime + REGISTRATION_TIMEOUT_DURATION ? // If any of the above are not true, we assume the update was
		// triggered by this instance.
		true : false;
		{
		if (_this2._registrationTime) {
		logger.error('Cannot re-register a Workbox instance after it has ' + 'been registered. Create a new instance instead.');
		return;
		}
		}

		if (updateLikelyTriggeredExternally) {
		this._externalSW = installingSW;
		return _invoke(function () {
		if (!immediate && document.readyState !== 'complete') {
		return _awaitIgnored(new Promise(function (res) {
		return addEventListener('load', res);
		}));
		}
		}, function () {
		// Set this flag to true if any service worker was controlling the page
		// at registration time.
		_this2._isUpdate = Boolean(navigator.serviceWorker.controller); // Before registering, attempt to determine if a SW is already controlling
		// the page, and if that SW script (and version, if specified) matches this
		// instance's script.

		this._registration.removeEventListener('updatefound', this._onUpdateFound);
		} else {
		// If the update was not triggered externally we know the installing
		// SW is the one we registered, so we set it.
		this._sw = installingSW;
		_this2._compatibleControllingSW = _this2._getControllingSWIfCompatible();
		return _await(_this2._registerScript(), function (_this2$_registerScrip) {
		_this2._registration = _this2$_registerScrip;

		this._swDeferred.resolve(installingSW); // The `installing` state isn't something we have a dedicated
		// callback for, but we do log messages for it in development.
		// If we have a compatible controller, store the controller as the "own"
		// SW, resolve active/controlling deferreds and add necessary listeners.
		if (_this2._compatibleControllingSW) {
		_this2._sw = _this2._compatibleControllingSW;

		_this2._activeDeferred.resolve(_this2._compatibleControllingSW);

		{
		if (navigator.serviceWorker.controller) {
		logger.log('Updated service worker found. Installing now...');
		} else {
		logger.log('Service worker is installing...');
		}
		}
		} // Increment the `updatefound` count, so future invocations of this
		// method can be sure they were triggered externally.
		_this2._controllingDeferred.resolve(_this2._compatibleControllingSW);

		_this2._reportWindowReady(_this2._compatibleControllingSW);

		++this._updateFoundCount; // Add a `statechange` listener regardless of whether this update was
		// triggered externally, since we have callbacks for both.
		_this2._compatibleControllingSW.addEventListener('statechange', _this2._onStateChange, {
		once: true
		});
		} // If there's a waiting service worker with a matching URL before the
		// `updatefound` event fires, it likely means that this site is open
		// in another tab, or the user refreshed the page (and thus the prevoius
		// page wasn't fully unloaded before this page started loading).
		// https://developers.google.com/web/fundamentals/primers/service-workers/lifecycle#waiting

		installingSW.addEventListener('statechange', this._onStateChange);
		};
		/**
		* @private
		* @param {Event} originalEvent
		*/

		var waitingSW = _this2._registration.waiting;

		_proto._onStateChange = function _onStateChange(originalEvent) {
		var _this6 = this;
		if (waitingSW && urlsMatch(waitingSW.scriptURL, _this2._scriptURL)) {
		// Store the waiting SW as the "own" Sw, even if it means overwriting
		// a compatible controller.
		_this2._sw = waitingSW; // Run this in the next microtask, so any code that adds an event
		// listener after awaiting `register()` will get this event.

		var sw = originalEvent.target;
		var state = sw.state;
		var isExternal = sw === this._externalSW;
		var eventPrefix = isExternal ? 'external' : '';
		var eventProps = {
		sw: sw,
		originalEvent: originalEvent
		};
		Promise.resolve().then(function () {
		_this2.dispatchEvent(new WorkboxEvent('waiting', {
		sw: waitingSW,
		wasWaitingBeforeRegister: true
		}));

		if (!isExternal && this._isUpdate) {
		eventProps.isUpdate = true;
		}
		{
		logger.warn('A service worker was already waiting to activate ' + 'before this script was registered...');
		}
		});
		} // If an "own" SW is already set, resolve the deferred.

		this.dispatchEvent(new WorkboxEvent(eventPrefix + state, eventProps));

		if (state === 'installed') {
		// This timeout is used to ignore cases where the service worker calls
		// `skipWaiting()` in the install event, thus moving it directly in the
		// activating state. (Since all service workers must go through the
		// waiting phase, the only way to detect `skipWaiting()` called in the
		// install event is to observe that the time spent in the waiting phase
		// is very short.)
		// NOTE: we don't need separate timeouts for the own and external SWs
		// since they can't go through these phases at the same time.
		this._waitingTimeout = setTimeout(function () {
		// Ensure the SW is still waiting (it may now be redundant).
		if (state === 'installed' && _this6._registration.waiting === sw) {
		_this6.dispatchEvent(new WorkboxEvent(eventPrefix + 'waiting', eventProps));
		if (_this2._sw) {
		_this2._swDeferred.resolve(_this2._sw);
		}

		{
		if (isExternal) {
		logger.warn('An external service worker has installed but is ' + 'waiting for this client to close before activating...');
		} else {
		logger.warn('The service worker has installed but is waiting ' + 'for existing clients to close before activating...');
		logger.log('Successfully registered service worker.', _this2._scriptURL);

		if (navigator.serviceWorker.controller) {
		if (_this2._compatibleControllingSW) {
		logger.debug('A service worker with the same script URL ' + 'is already controlling this page.');
		} else {
		logger.debug('A service worker with a different script URL is ' + 'currently controlling the page. The browser is now fetching ' + 'the new script now...');
		}
		}
		}
		}
		}, WAITING_TIMEOUT_DURATION);
		} else if (state === 'activating') {
		clearTimeout(this._waitingTimeout);

		if (!isExternal) {
		this._activeDeferred.resolve(sw);
		}
		}
		var currentPageIsOutOfScope = function currentPageIsOutOfScope() {
		var scopeURL = new URL(_this2._registerOptions.scope \|\| _this2._scriptURL, document.baseURI);
		var scopeURLBasePath = new URL('./', scopeURL.href).pathname;
		return !location.pathname.startsWith(scopeURLBasePath);
		};

		{
		switch (state) {
		case 'installed':
		if (isExternal) {
		logger.warn('An external service worker has installed. ' + 'You may want to suggest users reload this page.');
		} else {
		logger.log('Registered service worker installed.');
		if (currentPageIsOutOfScope()) {
		logger.warn('The current page is not in scope for the registered ' + 'service worker. Was this a mistake?');
		}
		}

		break;
		_this2._registration.addEventListener('updatefound', _this2._onUpdateFound);

		case 'activated':
		if (isExternal) {
		logger.warn('An external service worker has activated.');
		} else {
		logger.log('Registered service worker activated.');
		navigator.serviceWorker.addEventListener('controllerchange', _this2._onControllerChange, {
		once: true
		}); // Add message listeners.

		if (sw !== navigator.serviceWorker.controller) {
		logger.warn('The registered service worker is active but ' + 'not yet controlling the page. Reload or run ' + '`clients.claim()` in the service worker.');
		}
		if ('BroadcastChannel' in self) {
		_this2._broadcastChannel = new BroadcastChannel('workbox');

		_this2._broadcastChannel.addEventListener('message', _this2._onMessage);
		}

		break;
		navigator.serviceWorker.addEventListener('message', _this2._onMessage);
		return _this2._registration;
		});
		});
		});
		/**
		* Resolves to the service worker registered by this instance as soon as it
		* is active. If a service worker was already controlling at registration
		* time then it will resolve to that if the script URLs (and optionally
		* script versions) match, otherwise it will wait until an update is found
		* and activates.
		*
		* @return {Promise<ServiceWorker>}
		*/

		case 'redundant':
		if (sw === this._compatibleControllingSW) {
		logger.log('Previously controlling service worker now redundant!');
		} else if (!isExternal) {
		logger.log('Registered service worker now redundant!');
		}
		/**
		* Resolves with a reference to a service worker that matches the script URL
		* of this instance, as soon as it's available.
		*
		* If, at registration time, there's already an active or waiting service
		* worker with a matching script URL, it will be used (with the waiting
		* service worker taking precedence over the active service worker if both
		* match, since the waiting service worker would have been registered more
		* recently).
		* If there's no matching active or waiting service worker at registration
		* time then the promise will not resolve until an update is found and starts
		* installing, at which point the installing service worker is used.
		*
		* @return {Promise<ServiceWorker>}
		*/
		_proto.getSW = _async(function () {
		var _this3 = this;

		break;
		}
		}
		};
		/**
		* @private
		* @param {Event} originalEvent
		*/
		// If `this._sw` is set, resolve with that as we want `getSW()` to
		// return the correct (new) service worker if an update is found.
		return _this3._sw !== undefined ? _this3._sw : _this3._swDeferred.promise;
		});
		/**
		* Sends the passed data object to the service worker registered by this
		* instance (via [`getSW()`]{@link module:workbox-window.Workbox#getSW}) and resolves
		* with a response (if any).
		*
		* A response can be set in a message handler in the service worker by
		* calling `event.ports[0].postMessage(...)`, which will resolve the promise
		* returned by `messageSW()`. If no response is set, the promise will never
		* resolve.
		*
		* @param {Object} data An object to send to the service worker
		* @return {Promise<Object>}
		*/

		_proto.messageSW = _async(function (data) {
		var _this4 = this;

		_proto._onControllerChange = function _onControllerChange(originalEvent) {
		var sw = this._sw;
		return _await(_this4.getSW(), function (sw) {
		return messageSW(sw, data);
		});
		});
		/**
		* Checks for a service worker already controlling the page and returns
		* it if its script URL matchs.
		*
		* @private
		* @return {ServiceWorker\|undefined}
		*/

		if (sw === navigator.serviceWorker.controller) {
		this.dispatchEvent(new WorkboxEvent('controlling', {
		sw: sw,
		originalEvent: originalEvent
		}));
		_proto._getControllingSWIfCompatible = function _getControllingSWIfCompatible() {
		var controller = navigator.serviceWorker.controller;

		{
		logger.log('Registered service worker now controlling this page.');
		if (controller && urlsMatch(controller.scriptURL, this._scriptURL)) {
		return controller;
		} else {
		return undefined;
		}
		};
		/**
		* Registers a service worker for this instances script URL and register
		* options and tracks the time registration was complete.
		*
		* @private
		*/

		this._controllingDeferred.resolve(sw);
		}
		};
		/**
		* @private
		* @param {Event} originalEvent
		*/

		_proto._registerScript = _async(function () {
		var _this5 = this;

		_proto._onMessage = function _onMessage(originalEvent) {
		var data = originalEvent.data;
		this.dispatchEvent(new WorkboxEvent('message', {
		data: data,
		originalEvent: originalEvent
		}));
		};
		return _catch(function () {
		return _await(navigator.serviceWorker.register(_this5._scriptURL, _this5._registerOptions), function (reg) {
		// Keep track of when registration happened, so it can be used in the
		// `this._onUpdateFound` heuristic. Also use the presence of this
		// property as a way to see if `.register()` has been called.
		_this5._registrationTime = performance.now();
		return reg;
		});
		}, function (error) {
		{
		logger.error(error);
		} // Re-throw the error.

		_createClass(Workbox, [{
		key: "active",
		get: function get() {
		return this._activeDeferred.promise;
		}

		throw error;
		});
		});
		/**
		* Resolves to the service worker registered by this instance as soon as it
		* is controlling the page. If a service worker was already controlling at
		* registration time then it will resolve to that if the script URLs (and
		* optionally script versions) match, otherwise it will wait until an update
		* is found and starts controlling the page.
		* Note: the first time a service worker is installed it will active but
		* not start controlling the page unless `clients.claim()` is called in the
		* service worker.
		* Sends a message to the passed service worker that the window is ready.
		*
		* @return {Promise<ServiceWorker>}
		* @param {ServiceWorker} sw
		* @private
		*/

		}, {
		key: "controlling",
		get: function get() {
		return this._controllingDeferred.promise;
		}
		}]);
		_proto._reportWindowReady = function _reportWindowReady(sw) {
		messageSW(sw, {
		type: 'WINDOW_READY',
		meta: 'workbox-window'
		});
		};

		return Workbox;
		}(EventTargetShim); // The jsdoc comments below outline the events this instance may dispatch:
		_createClass(Workbox, [{
		key: "active",
		get: function get() {
		return this._activeDeferred.promise;
		}
		/**
		* Resolves to the service worker registered by this instance as soon as it
		* is controlling the page. If a service worker was already controlling at
		* registration time then it will resolve to that if the script URLs (and
		* optionally script versions) match, otherwise it will wait until an update
		* is found and starts controlling the page.
		* Note: the first time a service worker is installed it will active but
		* not start controlling the page unless `clients.claim()` is called in the
		* service worker.
		*
		* @return {Promise<ServiceWorker>}
		*/

		/*
		Copyright 2019 Google LLC
		}, {
		key: "controlling",
		get: function get() {
		return this._controllingDeferred.promise;
		}
		}]);

		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.
		*/
		return Workbox;
		}(WorkboxEventTarget); // The jsdoc comments below outline the events this instance may dispatch:

		exports.Workbox = Workbox;
		exports.messageSW = messageSW;
		/*
		Copyright 2019 Google LLC

		Object.defineProperty(exports, '__esModule', { value: true });
		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.
		*/

		exports.Workbox = Workbox;
		exports.messageSW = messageSW;

		Object.defineProperty(exports, '__esModule', { value: true });

		}));
		//# sourceMappingURL=workbox-window.dev.umd.js.map

build/workbox-window.prod.umd.js

		@@ -1,2 +0,2 @@
		!function(n,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((n=n\|\|self).workbox={})}(this,function(n){"use strict";try{self["workbox:window:5.0.0-alpha.0"]&&_()}catch(n){}var t=function(n,t){return new Promise(function(i){var e=new MessageChannel;e.port1.onmessage=function(n){return i(n.data)},n.postMessage(t,[e.port2])})};function i(n,t){for(var i=0;i<t.length;i++){var e=t[i];e.enumerable=e.enumerable\|\|!1,e.configurable=!0,"value"in e&&(e.writable=!0),Object.defineProperty(n,e.key,e)}}function e(n){if(void 0===n)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return n}try{self["workbox:core:5.0.0-alpha.0"]&&_()}catch(n){}var r=function(){var n=this;this.promise=new Promise(function(t,i){n.resolve=t,n.reject=i})},o=function(n,t){return new URL(n,location).href===new URL(t,location).href},u=function(n,t){Object.assign(this,t,{type:n})};function s(n){return function(){for(var t=[],i=0;i<arguments.length;i++)t[i]=arguments[i];try{return Promise.resolve(n.apply(this,t))}catch(n){return Promise.reject(n)}}}function a(n,t,i){return i?t?t(n):n:(n&&n.then\|\|(n=Promise.resolve(n)),t?n.then(t):n)}function c(){}var f=function(n){var f,h;function v(t,i){var o;return void 0===i&&(i={}),(o=n.call(this)\|\|this).t=t,o.i=i,o.o=0,o.u=new r,o.s=new r,o.h=new r,o.v=o.v.bind(e(e(o))),o.l=o.l.bind(e(e(o))),o.g=o.g.bind(e(e(o))),o.m=o.m.bind(e(e(o))),o}h=n,(f=v).prototype=Object.create(h.prototype),f.prototype.constructor=f,f.__proto__=h;var l,w,d,g=v.prototype;return g.register=s(function(n){var t,i,e=this,r=(void 0===n?{}:n).immediate,s=void 0!==r&&r;return t=function(){return e.p=Boolean(navigator.serviceWorker.controller),e.P=e.j(),a(e.O(),function(n){e.R=n,e.P&&(e._=e.P,e.s.resolve(e.P),e.h.resolve(e.P),e.k(e.P),e.P.addEventListener("statechange",e.l,{once:!0}));var t=e.R.waiting;return t&&o(t.scriptURL,e.t)&&(e._=t,Promise.resolve().then(function(){e.dispatchEvent(new u("waiting",{sw:t,wasWaitingBeforeRegister:!0}))})),e._&&e.u.resolve(e._),e.R.addEventListener("updatefound",e.g),navigator.serviceWorker.addEventListener("controllerchange",e.m,{once:!0}),"BroadcastChannel"in self&&(e.B=new BroadcastChannel("workbox"),e.B.addEventListener("message",e.v)),navigator.serviceWorker.addEventListener("message",e.v),e.R})},(i=function(){if(!s&&"complete"!==document.readyState)return function(n,t){if(!t)return n&&n.then?n.then(c):Promise.resolve()}(new Promise(function(n){return addEventListener("load",n)}))}())&&i.then?i.then(t):t(i)}),g.getSW=s(function(){return this._\|\|this.u.promise}),g.messageSW=s(function(n){return a(this.getSW(),function(i){return t(i,n)})}),g.j=function(){var n=navigator.serviceWorker.controller;if(n&&o(n.scriptURL,this.t))return n},g.O=s(function(){var n=this;return function(n,t){try{var i=n()}catch(n){return t(n)}return i&&i.then?i.then(void 0,t):i}(function(){return a(navigator.serviceWorker.register(n.t,n.i),function(t){return n.C=performance.now(),t})},function(n){throw n})}),g.k=function(n){t(n,{type:"WINDOW_READY",meta:"workbox-window"})},g.g=function(){var n=this.R.installing;this.o>0\|\|!o(n.scriptURL,this.t)\|\|performance.now()>this.C+6e4?(this.L=n,this.R.removeEventListener("updatefound",this.g)):(this._=n,this.u.resolve(n)),++this.o,n.addEventListener("statechange",this.l)},g.l=function(n){var t=this,i=n.target,e=i.state,r=i===this.L,o=r?"external":"",s={sw:i,originalEvent:n};!r&&this.p&&(s.isUpdate=!0),this.dispatchEvent(new u(o+e,s)),"installed"===e?this.W=setTimeout(function(){"installed"===e&&t.R.waiting===i&&t.dispatchEvent(new u(o+"waiting",s))},200):"activating"===e&&(clearTimeout(this.W),r\|\|this.s.resolve(i))},g.m=function(n){var t=this._;t===navigator.serviceWorker.controller&&(this.dispatchEvent(new u("controlling",{sw:t,originalEvent:n})),this.h.resolve(t))},g.v=function(n){var t=n.data;this.dispatchEvent(new u("message",{data:t,originalEvent:n}))},l=v,(w=[{key:"active",get:function(){return this.s.promise}},{key:"controlling",get:function(){return this.h.promise}}])&&i(l.prototype,w),d&&i(l,d),v}(function(){function n(){this.D={}}var t=n.prototype;return t.addEventListener=function(n,t){this.M(n).add(t)},t.removeEventListener=function(n,t){this.M(n).delete(t)},t.dispatchEvent=function(n){n.target=this,this.M(n.type).forEach(function(t){return t(n)})},t.M=function(n){return this.D[n]=this.D[n]\|\|new Set},n}());n.Workbox=f,n.messageSW=t,Object.defineProperty(n,"__esModule",{value:!0})});
		!function(n,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((n=n\|\|self).workbox={})}(this,function(n){"use strict";try{self["workbox:window:5.0.0-alpha.1"]&&_()}catch(n){}function t(n,t){return new Promise(function(e){var i=new MessageChannel;i.port1.onmessage=function(n){e(n.data)},n.postMessage(t,[i.port2])})}function e(n,t){for(var e=0;e<t.length;e++){var i=t[e];i.enumerable=i.enumerable\|\|!1,i.configurable=!0,"value"in i&&(i.writable=!0),Object.defineProperty(n,i.key,i)}}try{self["workbox:core:5.0.0-alpha.1"]&&_()}catch(n){}var i=function(){var n=this;this.promise=new Promise(function(t,e){n.resolve=t,n.reject=e})};function r(n,t){var e=location.href;return new URL(n,e).href===new URL(t,e).href}var o=function(n,t){this.type=n,Object.assign(this,t)};function a(n){return function(){for(var t=[],e=0;e<arguments.length;e++)t[e]=arguments[e];try{return Promise.resolve(n.apply(this,t))}catch(n){return Promise.reject(n)}}}function u(n,t,e){return e?t?t(n):n:(n&&n.then\|\|(n=Promise.resolve(n)),t?n.then(t):n)}function c(){}var f=200,s=6e4,v=function(n){var v,h;function l(t,e){var a;return void 0===e&&(e={}),(a=n.call(this)\|\|this).t={},a.i=0,a.o=new i,a.u=new i,a.s=new i,a.v=0,a.h=function(){var n=a.l,t=n.installing;a.i>0\|\|!r(t.scriptURL,a.g)\|\|performance.now()>a.v+s?(a.m=t,n.removeEventListener("updatefound",a.h)):(a.p=t,a.o.resolve(t)),++a.i,t.addEventListener("statechange",a.P)},a.P=function(n){var t=a.l,e=n.target,i=e.state,r=e===a.m,u=r?"external":"",c={sw:e,originalEvent:n};!r&&a.k&&(c.isUpdate=!0),a.dispatchEvent(new o(u+i,c)),"installed"===i?a.j=self.setTimeout(function(){"installed"===i&&t.waiting===e&&a.dispatchEvent(new o(u+"waiting",c))},f):"activating"===i&&(clearTimeout(a.j),r\|\|a.u.resolve(e))},a.O=function(n){var t=a.p;t===navigator.serviceWorker.controller&&(a.dispatchEvent(new o("controlling",{sw:t,originalEvent:n,isUpdate:a.k})),a.s.resolve(t))},a._=function(n){var t=n.data;a.dispatchEvent(new o("message",{data:t,originalEvent:n}))},a.g=t,a.t=e,a}h=n,(v=l).prototype=Object.create(h.prototype),v.prototype.constructor=v,v.__proto__=h;var d,w,g,m=l.prototype;return m.register=a(function(n){var t,e,i=this,a=(void 0===n?{}:n).immediate,f=void 0!==a&&a;return t=function(){return i.k=Boolean(navigator.serviceWorker.controller),i.B=i.R(),u(i.C(),function(n){i.l=n,i.B&&(i.p=i.B,i.u.resolve(i.B),i.s.resolve(i.B),i.L(i.B),i.B.addEventListener("statechange",i.P,{once:!0}));var t=i.l.waiting;return t&&r(t.scriptURL,i.g)&&(i.p=t,Promise.resolve().then(function(){i.dispatchEvent(new o("waiting",{sw:t,wasWaitingBeforeRegister:!0}))})),i.p&&i.o.resolve(i.p),i.l.addEventListener("updatefound",i.h),navigator.serviceWorker.addEventListener("controllerchange",i.O,{once:!0}),"BroadcastChannel"in self&&(i.U=new BroadcastChannel("workbox"),i.U.addEventListener("message",i._)),navigator.serviceWorker.addEventListener("message",i._),i.l})},(e=function(){if(!f&&"complete"!==document.readyState)return function(n,t){if(!t)return n&&n.then?n.then(c):Promise.resolve()}(new Promise(function(n){return addEventListener("load",n)}))}())&&e.then?e.then(t):t(e)}),m.getSW=a(function(){return void 0!==this.p?this.p:this.o.promise}),m.messageSW=a(function(n){return u(this.getSW(),function(e){return t(e,n)})}),m.R=function(){var n=navigator.serviceWorker.controller;return n&&r(n.scriptURL,this.g)?n:void 0},m.C=a(function(){var n=this;return function(n,t){try{var e=n()}catch(n){return t(n)}return e&&e.then?e.then(void 0,t):e}(function(){return u(navigator.serviceWorker.register(n.g,n.t),function(t){return n.v=performance.now(),t})},function(n){throw n})}),m.L=function(n){t(n,{type:"WINDOW_READY",meta:"workbox-window"})},d=l,(w=[{key:"active",get:function(){return this.u.promise}},{key:"controlling",get:function(){return this.s.promise}}])&&e(d.prototype,w),g&&e(d,g),l}(function(){function n(){this.W={}}var t=n.prototype;return t.addEventListener=function(n,t){this.A(n).add(t)},t.removeEventListener=function(n,t){this.A(n).delete(t)},t.dispatchEvent=function(n){n.target=this;var t=this.A(n.type),e=Array.isArray(t),i=0;for(t=e?t:t[Symbol.iterator]();;){var r;if(e){if(i>=t.length)break;r=t[i++]}else{if((i=t.next()).done)break;r=i.value}r(n)}},t.A=function(n){return this.W[n]=this.W[n]\|\|new Set},n}());n.Workbox=v,n.messageSW=t,Object.defineProperty(n,"__esModule",{value:!0})});
		//# sourceMappingURL=workbox-window.prod.umd.js.map

package.json

		{
		"name": "workbox-window",
		"version": "5.0.0-alpha.0",
		"version": "5.0.0-alpha.1",
		"license": "MIT",
		@@ -30,6 +30,7 @@ "author": "Google's Web DevRel Team",
		"module": "build/workbox-window.prod.es5.mjs",
		"types": "index.d.ts",
		"dependencies": {
		"workbox-core": "^5.0.0-alpha.0"
		"workbox-core": "^5.0.0-alpha.1"
		},
		"gitHead": "7f231c04023669bc42d5a939d1359b0867e2efda"
		"gitHead": "20d2110ddace710a46af06addd4977cae08f5942"
		}

utils/EventTargetShim.mjs

_version.mjs