+/******/ (function(modules) { // webpackBootstrap
+/******/ // The module cache
+/******/ var installedModules = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/
+/******/ // Check if module is in cache
+/******/ if(installedModules[moduleId]) {
+/******/ return installedModules[moduleId].exports;
+/******/ }
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = installedModules[moduleId] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = true;
+/******/
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+/******/
+/******/
+/******/ // expose the modules object (__webpack_modules__)
+/******/ __webpack_require__.m = modules;
+/******/
+/******/ // expose the module cache
+/******/ __webpack_require__.c = installedModules;
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, {
+/******/ configurable: false,
+/******/ enumerable: true,
+/******/ get: getter
+/******/ });
+/******/ }
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "/packs/";
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+(function () {
+ var waitUntil = ExtendableEvent.prototype.waitUntil;
+ var respondWith = FetchEvent.prototype.respondWith;
+ var promisesMap = new WeakMap();
+
+ ExtendableEvent.prototype.waitUntil = function (promise) {
+ var extendableEvent = this;
+ var promises = promisesMap.get(extendableEvent);
+
+ if (promises) {
+ promises.push(Promise.resolve(promise));
+ return;
+ }
+
+ promises = [Promise.resolve(promise)];
+ promisesMap.set(extendableEvent, promises);
+
+ // call original method
+ return waitUntil.call(extendableEvent, Promise.resolve().then(function processPromises() {
+ var len = promises.length;
+
+ // wait for all to settle
+ return Promise.all(promises.map(function (p) {
+ return p["catch"](function () {});
+ })).then(function () {
+ // have new items been added? If so, wait again
+ if (promises.length != len) return processPromises();
+ // we're done!
+ promisesMap["delete"](extendableEvent);
+ // reject if one of the promises rejected
+ return Promise.all(promises);
+ });
+ }));
+ };
+
+ FetchEvent.prototype.respondWith = function (promise) {
+ this.waitUntil(promise);
+ return respondWith.call(this, promise);
+ };
+})();;
+ 'use strict';
+
+if (typeof DEBUG === 'undefined') {
+ var DEBUG = false;
+}
+
+function WebpackServiceWorker(params, helpers) {
+ var loaders = helpers.loaders;
+ var cacheMaps = helpers.cacheMaps;
+
+ var strategy = params.strategy;
+ var responseStrategy = params.responseStrategy;
+
+ var assets = params.assets;
+ var loadersMap = params.loaders || {};
+
+ var hashesMap = params.hashesMap;
+ var externals = params.externals;
+
+ // Not used yet
+ // const alwaysRevalidate = params.alwaysRevalidate;
+ // const ignoreSearch = params.ignoreSearch;
+ // const preferOnline = params.preferOnline;
+
+ var CACHE_PREFIX = params.name;
+ var CACHE_TAG = params.version;
+ var CACHE_NAME = CACHE_PREFIX + ':' + CACHE_TAG;
+
+ var STORED_DATA_KEY = '__offline_webpack__data';
+
+ mapAssets();
+
+ var allAssets = [].concat(assets.main, assets.additional, assets.optional);
+ var navigateFallbackURL = params.navigateFallbackURL;
+ var navigateFallbackForRedirects = params.navigateFallbackForRedirects;
+
+ self.addEventListener('install', function (event) {
+ console.log('[SW]:', 'Install event');
+
+ var installing = undefined;
+
+ if (strategy === 'changed') {
+ installing = cacheChanged('main');
+ } else {
+ installing = cacheAssets('main');
+ }
+
+ event.waitUntil(installing);
+ });
+
+ self.addEventListener('activate', function (event) {
+ console.log('[SW]:', 'Activate event');
+
+ var activation = cacheAdditional();
+
+ // Delete all assets which name starts with CACHE_PREFIX and
+ // is not current cache (CACHE_NAME)
+ activation = activation.then(storeCacheData);
+ activation = activation.then(deleteObsolete);
+ activation = activation.then(function () {
+ if (self.clients && self.clients.claim) {
+ return self.clients.claim();
+ }
+ });
+
+ event.waitUntil(activation);
+ });
+
+ function cacheAdditional() {
+ if (!assets.additional.length) {
+ return Promise.resolve();
+ }
+
+ if (DEBUG) {
+ console.log('[SW]:', 'Caching additional');
+ }
+
+ var operation = undefined;
+
+ if (strategy === 'changed') {
+ operation = cacheChanged('additional');
+ } else {
+ operation = cacheAssets('additional');
+ }
+
+ // Ignore fail of `additional` cache section
+ return operation['catch'](function (e) {
+ console.error('[SW]:', 'Cache section `additional` failed to load');
+ });
+ }
+
+ function cacheAssets(section) {
+ var batch = assets[section];
+
+ return caches.open(CACHE_NAME).then(function (cache) {
+ return addAllNormalized(cache, batch, {
+ bust: params.version,
+ request: params.prefetchRequest
+ });
+ }).then(function () {
+ logGroup('Cached assets: ' + section, batch);
+ })['catch'](function (e) {
+ console.error(e);
+ throw e;
+ });
+ }
+
+ function cacheChanged(section) {
+ return getLastCache().then(function (args) {
+ if (!args) {
+ return cacheAssets(section);
+ }
+
+ var lastCache = args[0];
+ var lastKeys = args[1];
+ var lastData = args[2];
+
+ var lastMap = lastData.hashmap;
+ var lastVersion = lastData.version;
+
+ if (!lastData.hashmap || lastVersion === params.version) {
+ return cacheAssets(section);
+ }
+
+ var lastHashedAssets = Object.keys(lastMap).map(function (hash) {
+ return lastMap[hash];
+ });
+
+ var lastUrls = lastKeys.map(function (req) {
+ var url = new URL(req.url);
+ url.search = '';
+ url.hash = '';
+
+ return url.toString();
+ });
+
+ var sectionAssets = assets[section];
+ var moved = [];
+ var changed = sectionAssets.filter(function (url) {
+ if (lastUrls.indexOf(url) === -1 || lastHashedAssets.indexOf(url) === -1) {
+ return true;
+ }
+
+ return false;
+ });
+
+ Object.keys(hashesMap).forEach(function (hash) {
+ var asset = hashesMap[hash];
+
+ // Return if not in sectionAssets or in changed or moved array
+ if (sectionAssets.indexOf(asset) === -1 || changed.indexOf(asset) !== -1 || moved.indexOf(asset) !== -1) return;
+
+ var lastAsset = lastMap[hash];
+
+ if (lastAsset && lastUrls.indexOf(lastAsset) !== -1) {
+ moved.push([lastAsset, asset]);
+ } else {
+ changed.push(asset);
+ }
+ });
+
+ logGroup('Changed assets: ' + section, changed);
+ logGroup('Moved assets: ' + section, moved);
+
+ var movedResponses = Promise.all(moved.map(function (pair) {
+ return lastCache.match(pair[0]).then(function (response) {
+ return [pair[1], response];
+ });
+ }));
+
+ return caches.open(CACHE_NAME).then(function (cache) {
+ var move = movedResponses.then(function (responses) {
+ return Promise.all(responses.map(function (pair) {
+ return cache.put(pair[0], pair[1]);
+ }));
+ });
+
+ return Promise.all([move, addAllNormalized(cache, changed, {
+ bust: params.version,
+ request: params.prefetchRequest
+ })]);
+ });
+ });
+ }
+
+ function deleteObsolete() {
+ return caches.keys().then(function (keys) {
+ var all = keys.map(function (key) {
+ if (key.indexOf(CACHE_PREFIX) !== 0 || key.indexOf(CACHE_NAME) === 0) return;
+
+ console.log('[SW]:', 'Delete cache:', key);
+ return caches['delete'](key);
+ });
+
+ return Promise.all(all);
+ });
+ }
+
+ function getLastCache() {
+ return caches.keys().then(function (keys) {
+ var index = keys.length;
+ var key = undefined;
+
+ while (index--) {
+ key = keys[index];
+
+ if (key.indexOf(CACHE_PREFIX) === 0) {
+ break;
+ }
+ }
+
+ if (!key) return;
+
+ var cache = undefined;
+
+ return caches.open(key).then(function (_cache) {
+ cache = _cache;
+ return _cache.match(new URL(STORED_DATA_KEY, location).toString());
+ }).then(function (response) {
+ if (!response) return;
+
+ return Promise.all([cache, cache.keys(), response.json()]);
+ });
+ });
+ }
+
+ function storeCacheData() {
+ return caches.open(CACHE_NAME).then(function (cache) {
+ var data = new Response(JSON.stringify({
+ version: params.version,
+ hashmap: hashesMap
+ }));
+
+ return cache.put(new URL(STORED_DATA_KEY, location).toString(), data);
+ });
+ }
+
+ self.addEventListener('fetch', function (event) {
+ var url = new URL(event.request.url);
+ url.hash = '';
+
+ var urlString = url.toString();
+
+ // Not external, so search part of the URL should be stripped,
+ // if it's external URL, the search part should be kept
+ if (externals.indexOf(urlString) === -1) {
+ url.search = '';
+ urlString = url.toString();
+ }
+
+ // Handle only GET requests
+ var isGET = event.request.method === 'GET';
+ var assetMatches = allAssets.indexOf(urlString) !== -1;
+ var cacheUrl = urlString;
+
+ if (!assetMatches) {
+ var cacheRewrite = matchCacheMap(event.request);
+
+ if (cacheRewrite) {
+ cacheUrl = cacheRewrite;
+ assetMatches = true;
+ }
+ }
+
+ if (!assetMatches && isGET) {
+ // If isn't a cached asset and is a navigation request,
+ // fallback to navigateFallbackURL if available
+ if (navigateFallbackURL && isNavigateRequest(event.request)) {
+ event.respondWith(handleNavigateFallback(fetch(event.request)));
+
+ return;
+ }
+ }
+
+ if (!assetMatches || !isGET) {
+ // Fix for https://twitter.com/wanderview/status/696819243262873600
+ if (url.origin !== location.origin && navigator.userAgent.indexOf('Firefox/44.') !== -1) {
+ event.respondWith(fetch(event.request));
+ }
+
+ return;
+ }
+
+ // Logic of caching / fetching is here
+ // * urlString -- url to match from the CACHE_NAME
+ // * event.request -- original Request to perform fetch() if necessary
+ var resource = undefined;
+
+ if (responseStrategy === 'network-first') {
+ resource = networkFirstResponse(event, urlString, cacheUrl);
+ }
+ // 'cache-first'
+ // (responseStrategy has been validated before)
+ else {
+ resource = cacheFirstResponse(event, urlString, cacheUrl);
+ }
+
+ if (navigateFallbackURL && isNavigateRequest(event.request)) {
+ resource = handleNavigateFallback(resource);
+ }
+
+ event.respondWith(resource);
+ });
+
+ self.addEventListener('message', function (e) {
+ var data = e.data;
+ if (!data) return;
+
+ switch (data.action) {
+ case 'skipWaiting':
+ {
+ if (self.skipWaiting) self.skipWaiting();
+ }break;
+ }
+ });
+
+ function cacheFirstResponse(event, urlString, cacheUrl) {
+ return cachesMatch(cacheUrl, CACHE_NAME).then(function (response) {
+ if (response) {
+ if (DEBUG) {
+ console.log('[SW]:', 'URL [' + cacheUrl + '](' + urlString + ') from cache');
+ }
+
+ return response;
+ }
+
+ // Load and cache known assets
+ var fetching = fetch(event.request).then(function (response) {
+ if (!response.ok) {
+ if (DEBUG) {
+ console.log('[SW]:', 'URL [' + urlString + '] wrong response: [' + response.status + '] ' + response.type);
+ }
+
+ return response;
+ }
+
+ if (DEBUG) {
+ console.log('[SW]:', 'URL [' + urlString + '] from network');
+ }
+
+ if (cacheUrl === urlString) {
+ (function () {
+ var responseClone = response.clone();
+ var storing = caches.open(CACHE_NAME).then(function (cache) {
+ return cache.put(urlString, responseClone);
+ }).then(function () {
+ console.log('[SW]:', 'Cache asset: ' + urlString);
+ });
+
+ event.waitUntil(storing);
+ })();
+ }
+
+ return response;
+ });
+
+ return fetching;
+ });
+ }
+
+ function networkFirstResponse(event, urlString, cacheUrl) {
+ return fetch(event.request).then(function (response) {
+ if (response.ok) {
+ if (DEBUG) {
+ console.log('[SW]:', 'URL [' + urlString + '] from network');
+ }
+
+ return response;
+ }
+
+ // Throw to reach the code in the catch below
+ throw new Error('Response is not ok');
+ })
+ // This needs to be in a catch() and not just in the then() above
+ // cause if your network is down, the fetch() will throw
+ ['catch'](function () {
+ if (DEBUG) {
+ console.log('[SW]:', 'URL [' + urlString + '] from cache if possible');
+ }
+
+ return cachesMatch(cacheUrl, CACHE_NAME);
+ });
+ }
+
+ function handleNavigateFallback(fetching) {
+ return fetching['catch'](function () {}).then(function (response) {
+ var isOk = response && response.ok;
+ var isRedirect = response && response.type === 'opaqueredirect';
+
+ if (isOk || isRedirect && !navigateFallbackForRedirects) {
+ return response;
+ }
+
+ if (DEBUG) {
+ console.log('[SW]:', 'Loading navigation fallback [' + navigateFallbackURL + '] from cache');
+ }
+
+ return cachesMatch(navigateFallbackURL, CACHE_NAME);
+ });
+ }
+
+ function mapAssets() {
+ Object.keys(assets).forEach(function (key) {
+ assets[key] = assets[key].map(function (path) {
+ var url = new URL(path, location);
+
+ url.hash = '';
+
+ if (externals.indexOf(path) === -1) {
+ url.search = '';
+ }
+
+ return url.toString();
+ });
+ });
+
+ Object.keys(loadersMap).forEach(function (key) {
+ loadersMap[key] = loadersMap[key].map(function (path) {
+ var url = new URL(path, location);
+
+ url.hash = '';
+
+ if (externals.indexOf(path) === -1) {
+ url.search = '';
+ }
+
+ return url.toString();
+ });
+ });
+
+ hashesMap = Object.keys(hashesMap).reduce(function (result, hash) {
+ var url = new URL(hashesMap[hash], location);
+ url.search = '';
+ url.hash = '';
+
+ result[hash] = url.toString();
+ return result;
+ }, {});
+
+ externals = externals.map(function (path) {
+ var url = new URL(path, location);
+ url.hash = '';
+
+ return url.toString();
+ });
+ }
+
+ function addAllNormalized(cache, requests, options) {
+ var allowLoaders = options.allowLoaders !== false;
+ var bustValue = options && options.bust;
+ var requestInit = options.request || {
+ credentials: 'omit',
+ mode: 'cors'
+ };
+
+ return Promise.all(requests.map(function (request) {
+ if (bustValue) {
+ request = applyCacheBust(request, bustValue);
+ }
+
+ return fetch(request, requestInit).then(fixRedirectedResponse);
+ })).then(function (responses) {
+ if (responses.some(function (response) {
+ return !response.ok;
+ })) {
+ return Promise.reject(new Error('Wrong response status'));
+ }
+
+ var extracted = [];
+ var addAll = responses.map(function (response, i) {
+ if (allowLoaders) {
+ extracted.push(extractAssetsWithLoaders(requests[i], response));
+ }
+
+ return cache.put(requests[i], response);
+ });
+
+ if (extracted.length) {
+ (function () {
+ var newOptions = copyObject(options);
+ newOptions.allowLoaders = false;
+
+ var waitAll = addAll;
+
+ addAll = Promise.all(extracted).then(function (all) {
+ var extractedRequests = [].concat.apply([], all);
+
+ if (requests.length) {
+ waitAll = waitAll.concat(addAllNormalized(cache, extractedRequests, newOptions));
+ }
+
+ return Promise.all(waitAll);
+ });
+ })();
+ } else {
+ addAll = Promise.all(addAll);
+ }
+
+ return addAll;
+ });
+ }
+
+ function extractAssetsWithLoaders(request, response) {
+ var all = Object.keys(loadersMap).map(function (key) {
+ var loader = loadersMap[key];
+
+ if (loader.indexOf(request) !== -1 && loaders[key]) {
+ return loaders[key](response.clone());
+ }
+ }).filter(function (a) {
+ return !!a;
+ });
+
+ return Promise.all(all).then(function (all) {
+ return [].concat.apply([], all);
+ });
+ }
+
+ function matchCacheMap(request) {
+ var urlString = request.url;
+ var url = new URL(urlString);
+
+ var requestType = undefined;
+
+ if (request.mode === 'navigate') {
+ requestType = 'navigate';
+ } else if (url.origin === location.origin) {
+ requestType = 'same-origin';
+ } else {
+ requestType = 'cross-origin';
+ }
+
+ for (var i = 0; i < cacheMaps.length; i++) {
+ var map = cacheMaps[i];
+
+ if (!map) continue;
+ if (map.requestTypes && map.requestTypes.indexOf(requestType) === -1) {
+ continue;
+ }
+
+ var newString = undefined;
+
+ if (typeof map.match === 'function') {
+ newString = map.match(url, request);
+ } else {
+ newString = urlString.replace(map.match, map.to);
+ }
+
+ if (newString && newString !== urlString) {
+ return newString;
+ }
+ }
+ }
+}
+
+function cachesMatch(request, cacheName) {
+ return caches.match(request, {
+ cacheName: cacheName
+ }).then(function (response) {
+ if (isNotRedirectedResponse()) {
+ return response;
+ }
+
+ // Fix already cached redirected responses
+ return fixRedirectedResponse(response).then(function (fixedResponse) {
+ return caches.open(cacheName).then(function (cache) {
+ return cache.put(request, fixedResponse);
+ }).then(function () {
+ return fixedResponse;
+ });
+ });
+ })
+ // Return void if error happened (cache not found)
+ ['catch'](function () {});
+}
+
+function applyCacheBust(asset, key) {
+ var hasQuery = asset.indexOf('?') !== -1;
+ return asset + (hasQuery ? '&' : '?') + '__uncache=' + encodeURIComponent(key);
+}
+
+function getClientsURLs() {
+ if (!self.clients) {
+ return Promise.resolve([]);
+ }
+
+ return self.clients.matchAll({
+ includeUncontrolled: true
+ }).then(function (clients) {
+ if (!clients.length) return [];
+
+ var result = [];
+
+ clients.forEach(function (client) {
+ var url = new URL(client.url);
+ url.search = '';
+ url.hash = '';
+ var urlString = url.toString();
+
+ if (!result.length || result.indexOf(urlString) === -1) {
+ result.push(urlString);
+ }
+ });
+
+ return result;
+ });
+}
+
+function isNavigateRequest(request) {
+ return request.mode === 'navigate' || request.headers.get('Upgrade-Insecure-Requests') || (request.headers.get('Accept') || '').indexOf('text/html') !== -1;
+}
+
+function isNotRedirectedResponse(response) {
+ return !response || !response.redirected || !response.ok || response.type === 'opaqueredirect';
+}
+
+// Based on https://github.com/GoogleChrome/sw-precache/pull/241/files#diff-3ee9060dc7a312c6a822cac63a8c630bR85
+function fixRedirectedResponse(response) {
+ if (isNotRedirectedResponse(response)) {
+ return Promise.resolve(response);
+ }
+
+ var body = 'body' in response ? Promise.resolve(response.body) : response.blob();
+
+ return body.then(function (data) {
+ return new Response(data, {
+ headers: response.headers,
+ status: response.status
+ });
+ });
+}
+
+function copyObject(original) {
+ return Object.keys(original).reduce(function (result, key) {
+ result[key] = original[key];
+ return result;
+ }, {});
+}
+
+function logGroup(title, assets) {
+ console.groupCollapsed('[SW]:', title);
+
+ assets.forEach(function (asset) {
+ console.log('Asset:', asset);
+ });
+
+ console.groupEnd();
+}
+ WebpackServiceWorker(__wpo, {
+loaders: {},
+cacheMaps: [],
+});
+ module.exports = __webpack_require__(1)
+
+
+/***/ }),
+/* 1 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__storage_modifier__ = __webpack_require__(2);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__web_push_notifications__ = __webpack_require__(4);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__web_push_notifications___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__web_push_notifications__);
+/*** IMPORTS FROM imports-loader ***/
+var process = (process || {});
+process.env = {"npm_config_cache_lock_stale":"60000","npm_config_ham_it_up":"","npm_package_dependencies_mark_loader":"^0.1.6","npm_config_legacy_bundling":"","npm_config_sign_git_tag":"","npm_package_dependencies_autoprefixer":"^7.1.6","npm_package_dependencies_mkdirp":"^0.5.1","npm_package_dependencies_node_sass":"^4.7.2","npm_package_devDependencies_jest":"^21.2.1","npm_config_user_agent":"npm/5.6.0 node/v9.11.1 linux x64","npm_config_always_auth":"","npm_package_dependencies_detect_passive_events":"^1.0.2","npm_package_dependencies_immutable":"^3.8.2","npm_package_bugs_url":"https://github.com/tootsuite/mastodon/issues","npm_config_bin_links":"true","npm_config_key":"","npm_package_dependencies_react_overlays":"^0.8.3","npm_config_allow_same_version":"","npm_config_description":"true","npm_config_fetch_retries":"2","npm_config_heading":"npm","npm_config_if_present":"","npm_config_init_version":"1.0.0","npm_config_user":"","npm_node_execpath":"/usr/bin/node","npm_package_scripts_manage_translations":"node ./config/webpack/translationRunner.js","npm_package_dependencies_babel_plugin_transform_class_properties":"^6.24.1","npm_package_dependencies_babel_plugin_transform_es2015_modules_commonjs":"^6.24.1","npm_package_dependencies_escape_html":"^1.0.3","npm_package_dependencies_imports_loader":"^0.8.0","npm_package_optionalDependencies_node_zopfli":"^2.0.2","npm_config_prefer_online":"","HOME":"/home/howl","npm_package_dependencies_postcss_loader":"^2.0.9","npm_config_force":"","npm_package_dependencies_react_redux_loading_bar":"^2.9.3","npm_package_dependencies_redis":"^2.7.1","npm_config_only":"","npm_config_read_only":"","npm_package_engines_node":">=6","npm_package_dependencies_babel_plugin_react_intl":"^2.3.1","npm_package_dependencies_npmlog":"^4.1.2","npm_package_devDependencies_enzyme_adapter_react_16":"^1.1.0","npm_config_cache_min":"10","npm_config_init_license":"ISC","npm_package_scripts_build_production":"cross-env NODE_ENV=production webpack --config config/webpack/production.js","npm_package_dependencies_glob":"^7.1.1","npm_package_dependencies_webpack_merge":"^4.1.1","npm_config_editor":"vi","npm_config_rollback":"true","npm_config_tag_version_prefix":"v","npm_package_dependencies_redux_thunk":"^2.2.0","npm_package_dependencies_webpack":"^3.9.1","npm_config_cache_max":"Infinity","npm_config_timing":"","npm_config_userconfig":"/home/howl/.npmrc","npm_package_dependencies_babel_plugin_lodash":"^3.3.2","npm_package_dependencies_dotenv":"^4.0.0","npm_package_dependencies_precss":"^2.0.0","npm_package_dependencies_react_hotkeys":"^0.10.0","npm_config_engine_strict":"","npm_config_init_author_name":"","npm_config_init_author_url":"","npm_config_tmp":"/tmp","npm_package_description":"mastodon","npm_package_dependencies_react_router_dom":"^4.1.1","npm_config_depth":"Infinity","npm_config_package_lock_only":"","npm_config_save_dev":"","npm_config_usage":"","npm_package_scripts_test_jest":"cross-env NODE_ENV=test jest --coverage","npm_package_dependencies_throng":"^4.0.0","npm_package_devDependencies_react_intl_translations_manager":"^5.0.0","npm_package_readmeFilename":"README.md","npm_package_homepage":"https://github.com/tootsuite/mastodon#readme","npm_config_metrics_registry":"https://registry.npmjs.org/","npm_config_cafile":"","npm_config_otp":"","npm_config_package_lock":"true","npm_config_progress":"true","npm_config_https_proxy":"","npm_config_save_prod":"","npm_package_scripts_dev":"cross-env NODE_ENV=development webpack-dev-server --config config/webpack/development.js --progress --color","npm_package_scripts_test_lint":"eslint -c .eslintrc.yml --ext=js app/javascript/ config/webpack/ streaming/","npm_package_dependencies_babel_plugin_transform_react_remove_prop_types":"^0.4.10","npm_package_dependencies_websocket_js":"^0.1.12","npm_config_cidr":"","npm_config_onload_script":"","npm_config_sso_type":"oauth","npm_package_dependencies_babel_plugin_syntax_dynamic_import":"^6.18.0","npm_package_dependencies_rails_ujs":"^5.1.2","npm_package_dependencies_react_immutable_pure_component":"^1.1.1","npm_package_dependencies_react_motion":"^0.5.2","npm_package_dependencies_reselect":"^3.0.1","npm_package_devDependencies_eslint_plugin_import":"^2.8.0","npm_config_rebuild_bundle":"true","npm_config_save_bundle":"","npm_config_shell":"bash","npm_package_private":"true","npm_package_dependencies_express":"^4.16.2","npm_package_dependencies_react_notification":"^6.8.2","npm_package_dependencies_sass_loader":"^6.0.6","npm_config_dry_run":"","npm_config_prefix":"/usr","npm_config_scope":"","npm_config_browser":"","npm_config_cache_lock_wait":"10000","npm_config_ignore_prepublish":"","npm_config_registry":"https://registry.npmjs.org/","npm_config_save_optional":"","npm_config_searchopts":"","npm_config_versions":"","npm_package_dependencies_font_awesome":"^4.7.0","npm_package_dependencies_postcss_object_fit_images":"^1.1.2","npm_package_dependencies_react_immutable_proptypes":"^2.1.0","npm_package_dependencies_style_loader":"^0.19.0","npm_package_dependencies_uws":"^8.14.0","npm_package_optionalDependencies_fsevents":"*","npm_config_cache":"/home/howl/.npm","npm_config_proxy":"","npm_config_send_metrics":"","npm_package_scripts_start":"node ./streaming/index.js","npm_config_global_style":"","npm_config_ignore_scripts":"","npm_config_version":"","npm_package_dependencies_axios":"~0.16.2","npm_package_dependencies_css_loader":"^0.28.4","npm_package_dependencies_marky":"^1.2.0","npm_config_local_address":"","npm_config_viewer":"man","npm_config_node_gyp":"/usr/lib/node_modules/npm/node_modules/node-gyp/bin/node-gyp.js","PATH":"/usr/lib/node_modules/npm/node_modules/npm-lifecycle/node-gyp-bin:/home/howl/oc/mastofe/node_modules/.bin:/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games","npm_package_name":"mastodon","npm_package_repository_type":"git","npm_package_dependencies_babel_preset_env":"^1.6.1","npm_package_dependencies_cross_env":"^5.1.1","npm_package_dependencies_extract_text_webpack_plugin":"^3.0.2","npm_package_dependencies_substring_trie":"^1.0.2","npm_config_prefer_offline":"","NODE":"/usr/bin/node","npm_package_dependencies_babel_plugin_transform_runtime":"^6.23.0","npm_package_dependencies_react_redux":"^5.0.4","npm_package_dependencies_tiny_queue":"^0.2.1","npm_package_devDependencies_eslint_plugin_jsx_a11y":"^5.1.1","npm_config_color":"true","npm_package_scripts_build_development":"cross-env NODE_ENV=development webpack --config config/webpack/development.js","npm_package_dependencies_npm_run_all":"^4.1.2","npm_package_dependencies_stringz":"^0.3.0","npm_config_fetch_retry_mintimeout":"10000","npm_config_maxsockets":"50","npm_config_offline":"","npm_config_sso_poll_frequency":"500","npm_package_dependencies_babel_plugin_transform_react_inline_elements":"^6.22.0","npm_package_dependencies_babel_preset_react":"^6.24.1","npm_package_dependencies_object_assign":"^4.1.1","npm_package_dependencies_react_dom":"^16.2.0","npm_package_dependencies_react_textarea_autosize":"^5.2.1","npm_package_dependencies_redux":"^3.7.1","npm_package_devDependencies_eslint":"^4.15.0","npm_package_devDependencies_react_test_renderer":"^16.2.0","npm_config_umask":"0022","npm_package_dependencies_babel_plugin_transform_object_rest_spread":"^6.23.0","npm_package_dependencies_offline_plugin":"^4.8.3","npm_package_dependencies_path_complete_extname":"^0.1.0","npm_package_dependencies_postcss_smart_import":"^0.7.5","npm_package_dependencies_node_zopfli":"^2.0.2","npm_package_gitHead":"bbbb8e40f52cd05e8bbeec1901990144b87fea55","npm_config_fetch_retry_maxtimeout":"60000","npm_config_loglevel":"notice","npm_config_logs_max":"10","npm_config_message":"%s","npm_lifecycle_script":"cross-env NODE_ENV=production webpack --config config/webpack/production.js","npm_package_scripts_postversion":"git push --tags","npm_package_scripts_test":"npm-run-all test:lint test:jest","npm_package_dependencies_babel_core":"^6.25.0","npm_package_dependencies_babel_plugin_preval":"^1.6.1","npm_package_dependencies_http_link_header":"^0.8.0","npm_package_dependencies_intersection_observer":"^0.5.0","npm_package_dependencies_is_nan":"^1.2.1","npm_package_dependencies_react_intl":"^2.4.0","npm_package_dependencies_react_router_scroll_4":"^1.0.0-beta.1","npm_package_dependencies_react_swipeable_views":"^0.12.3","npm_package_dependencies_redux_immutable":"^4.0.0","npm_package_devDependencies_webpack_dev_server":"^2.9.5","npm_config_ca":"","npm_config_cert":"","npm_config_global":"","npm_config_link":"","npm_package_repository_url":"git+https://github.com/tootsuite/mastodon.git","npm_package_dependencies_webpack_bundle_analyzer":"^2.9.1","npm_package_version":"","npm_config_access":"","npm_config_also":"","npm_config_save":"true","npm_config_unicode":"","npm_lifecycle_event":"build","npm_package_scripts_build":"cross-env NODE_ENV=production webpack --config config/webpack/production.js","npm_package_dependencies_emoji_mart":"github:Gargron/emoji-mart#build","npm_package_dependencies_intl":"^1.2.5","npm_package_dependencies_js_yaml":"^3.9.0","npm_package_dependencies_uuid":"^3.1.0","npm_config_argv":"{\"remain\":[],\"cooked\":[\"run\",\"build\"],\"original\":[\"run\",\"build\"]}","npm_config_long":"","npm_config_production":"","npm_config_searchlimit":"20","npm_config_unsafe_perm":"true","npm_package_dependencies_array_includes":"^3.0.3","npm_package_dependencies_babel_plugin_transform_react_jsx_source":"^6.22.0","npm_package_dependencies_compression_webpack_plugin":"^1.0.1","npm_package_dependencies_file_loader":"^0.11.2","npm_package_dependencies_lodash":"^4.17.4","npm_config_auth_type":"legacy","npm_config_node_version":"9.11.1","npm_config_tag":"latest","npm_config_git_tag_version":"true","npm_config_commit_hooks":"true","npm_config_script_shell":"","npm_config_shrinkwrap":"true","npm_package_license":"AGPL-3.0-or-later","npm_package_dependencies_classnames":"^2.2.5","npm_package_dependencies_es6_symbol":"^3.1.1","npm_package_dependencies_intl_messageformat":"^2.2.0","npm_package_dependencies_punycode":"^2.1.0","npm_package_devDependencies_eslint_plugin_react":"^7.5.1","npm_config_fetch_retry_factor":"10","npm_config_save_exact":"","npm_config_strict_ssl":"true","npm_package_dependencies_babel_plugin_transform_react_jsx_self":"^6.22.0","npm_config_dev":"","npm_config_globalconfig":"/usr/etc/npmrc","npm_config_init_module":"/home/howl/.npm-init.js","npm_config_parseable":"","npm_package_dependencies_intl_relativeformat":"^2.1.0","npm_package_dependencies_requestidlecallback":"^0.3.0","npm_package_dependencies_webpack_manifest_plugin":"^1.2.1","npm_package_devDependencies_enzyme":"^3.2.0","npm_package_devDependencies_raf":"^3.4.0","npm_config_globalignorefile":"/usr/etc/npmignore","npm_execpath":"/usr/lib/node_modules/npm/bin/npm-cli.js","PWD":"/home/howl/oc/mastofe","npm_package_dependencies_react_toggle":"^4.0.1","npm_config_cache_lock_retries":"10","npm_config_searchstaleness":"900","npm_package_dependencies_object_values":"^1.0.4","npm_package_dependencies_prop_types":"^15.5.10","npm_package_dependencies_resolve_url_loader":"^2.2.0","npm_package_dependencies_rimraf":"^2.6.1","npm_config_node_options":"","npm_config_save_prefix":"^","npm_config_scripts_prepend_node_path":"warn-only","npm_package_devDependencies_babel_eslint":"^8.2.1","npm_package_devDependencies_yargs":"^8.0.2","npm_config_group":"1000","npm_config_init_author_email":"","npm_config_searchexclude":"","npm_package_dependencies_babel_loader":"^7.1.1","npm_package_dependencies_object_fit_images":"^3.2.3","npm_package_devDependencies_eslint_plugin_promise":"^3.7.0","npm_config_git":"git","npm_config_optional":"true","npm_package_dependencies_babel_plugin_transform_decorators_legacy":"^1.3.4","npm_package_dependencies_pg":"^6.4.0","npm_package_dependencies_react":"^16.2.0","npm_package_dependencies_fsevents":"*","npm_config_json":"","INIT_CWD":"/home/howl/oc/mastofe","NODE_ENV":"production"};
+
+
+
+
+function openSystemCache() {
+ return caches.open('mastodon-system');
+}
+
+function openWebCache() {
+ return caches.open('mastodon-web');
+}
+
+function fetchRoot() {
+ return fetch('/web', { credentials: 'include' });
+}
+
+// Cause a new version of a registered Service Worker to replace an existing one
+// that is already installed, and replace the currently active worker on open pages.
+self.addEventListener('install', function (event) {
+ event.waitUntil(Promise.all([openWebCache(), fetchRoot()]).then(function (_ref) {
+ var cache = _ref[0],
+ root = _ref[1];
+ return cache.put('/web', root);
+ }));
+});
+self.addEventListener('activate', function (event) {
+ event.waitUntil(self.clients.claim());
+});
+self.addEventListener('fetch', function (event) {
+ var url = new URL(event.request.url);
+
+ if (url.pathname.startsWith('/web')) {
+ // we always make /web/login go through
+ if (url.pathname.startsWith('/web/login')) {
+ return;
+ }
+ var asyncResponse = fetchRoot();
+ var asyncCache = openWebCache();
+
+ event.respondWith(asyncResponse.then(async function (response) {
+ // response was redirected - let's actually do the request from the event
+ // and return its response
+ if (response.redirected || response.type === 'opaqueredirect') {
+ return await fetch(event.request);
+ }
+ if (response.ok) {
+ var cache = await asyncCache;
+ await cache.put('/web', response);
+ return response.clone();
+ }
+
+ throw null;
+ }).catch(function () {
+ return asyncCache.then(function (cache) {
+ return cache.match('/web');
+ });
+ }));
+ } else if (url.pathname === '/auth/sign_out') {
+ var _asyncResponse = fetch(event.request);
+ var _asyncCache = openWebCache();
+
+ event.respondWith(_asyncResponse.then(async function (response) {
+ if (response.ok || response.type === 'opaqueredirect') {
+ await Promise.all([_asyncCache.then(function (cache) {
+ return cache.delete('/web');
+ }), indexedDB.deleteDatabase('mastodon')]);
+ }
+
+ return response;
+ }));
+ } else if (process.env.CDN_HOST ? url.host === process.env.CDN_HOST : url.pathname.startsWith('/system/')) {
+ event.respondWith(openSystemCache().then(async function (cache) {
+ var cached = await cache.match(event.request.url);
+
+ if (cached === undefined) {
+ var fetched = await fetch(event.request);
+
+ if (fetched.ok) {
+ try {
+ await cache.put(event.request.url, fetched.clone());
+ } finally {
+ Object(__WEBPACK_IMPORTED_MODULE_0__storage_modifier__["a" /* freeStorage */])();
+ }
+ }
+
+ return fetched;
+ }
+
+ return cached;
+ }));
+ }
+});
+
+
+/***/ }),
+/* 2 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* unused harmony export evictStatus */
+/* unused harmony export evictStatuses */
+/* unused harmony export putAccounts */
+/* unused harmony export putStatuses */
+/* harmony export (immutable) */ __webpack_exports__["a"] = freeStorage;
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__db__ = __webpack_require__(3);
+
+
+var accountAssetKeys = ['avatar', 'avatar_static', 'header', 'header_static'];
+var storageMargin = 8388608;
+var storeLimit = 1024;
+
+function openCache() {
+ // ServiceWorker and Cache API is not available on iOS 11
+ // https://webkit.org/status/#specification-service-workers
+ return self.caches ? caches.open('mastodon-system') : Promise.reject();
+}
+
+function printErrorIfAvailable(error) {
+ if (error) {
+ console.warn(error);
+ }
+}
+
+function put(name, objects, onupdate, oncreate) {
+ return Object(__WEBPACK_IMPORTED_MODULE_0__db__["a" /* default */])().then(function (db) {
+ return new Promise(function (resolve, reject) {
+ var putTransaction = db.transaction(name, 'readwrite');
+ var putStore = putTransaction.objectStore(name);
+ var putIndex = putStore.index('id');
+
+ objects.forEach(function (object) {
+ putIndex.getKey(object.id).onsuccess = function (retrieval) {
+ function addObject() {
+ putStore.add(object);
+ }
+
+ function deleteObject() {
+ putStore.delete(retrieval.target.result).onsuccess = addObject;
+ }
+
+ if (retrieval.target.result) {
+ if (onupdate) {
+ onupdate(object, retrieval.target.result, putStore, deleteObject);
+ } else {
+ deleteObject();
+ }
+ } else {
+ if (oncreate) {
+ oncreate(object, addObject);
+ } else {
+ addObject();
+ }
+ }
+ };
+ });
+
+ putTransaction.oncomplete = function () {
+ var readTransaction = db.transaction(name, 'readonly');
+ var readStore = readTransaction.objectStore(name);
+ var count = readStore.count();
+
+ count.onsuccess = function () {
+ var excess = count.result - storeLimit;
+
+ if (excess > 0) {
+ var retrieval = readStore.getAll(null, excess);
+
+ retrieval.onsuccess = function () {
+ return resolve(retrieval.result);
+ };
+ retrieval.onerror = reject;
+ } else {
+ resolve([]);
+ }
+ };
+
+ count.onerror = reject;
+ };
+
+ putTransaction.onerror = reject;
+ }).then(function (resolved) {
+ db.close();
+ return resolved;
+ }, function (error) {
+ db.close();
+ throw error;
+ });
+ });
+}
+
+function evictAccountsByRecords(records) {
+ return Object(__WEBPACK_IMPORTED_MODULE_0__db__["a" /* default */])().then(function (db) {
+ var transaction = db.transaction(['accounts', 'statuses'], 'readwrite');
+ var accounts = transaction.objectStore('accounts');
+ var accountsIdIndex = accounts.index('id');
+ var accountsMovedIndex = accounts.index('moved');
+ var statuses = transaction.objectStore('statuses');
+ var statusesIndex = statuses.index('account');
+
+ function evict(toEvict) {
+ toEvict.forEach(function (record) {
+ openCache().then(function (cache) {
+ return accountAssetKeys.forEach(function (key) {
+ return cache.delete(records[key]);
+ });
+ }).catch(printErrorIfAvailable);
+
+ accountsMovedIndex.getAll(record.id).onsuccess = function (_ref) {
+ var target = _ref.target;
+ return evict(target.result);
+ };
+
+ statusesIndex.getAll(record.id).onsuccess = function (_ref2) {
+ var target = _ref2.target;
+ return evictStatusesByRecords(target.result);
+ };
+
+ accountsIdIndex.getKey(record.id).onsuccess = function (_ref3) {
+ var target = _ref3.target;
+ return target.result && accounts.delete(target.result);
+ };
+ });
+ }
+
+ evict(records);
+
+ db.close();
+ }).catch(printErrorIfAvailable);
+}
+
+function evictStatus(id) {
+ evictStatuses([id]);
+}
+
+function evictStatuses(ids) {
+ return Object(__WEBPACK_IMPORTED_MODULE_0__db__["a" /* default */])().then(function (db) {
+ var transaction = db.transaction('statuses', 'readwrite');
+ var store = transaction.objectStore('statuses');
+ var idIndex = store.index('id');
+ var reblogIndex = store.index('reblog');
+
+ ids.forEach(function (id) {
+ reblogIndex.getAllKeys(id).onsuccess = function (_ref4) {
+ var target = _ref4.target;
+ return target.result.forEach(function (reblogKey) {
+ return store.delete(reblogKey);
+ });
+ };
+
+ idIndex.getKey(id).onsuccess = function (_ref5) {
+ var target = _ref5.target;
+ return target.result && store.delete(target.result);
+ };
+ });
+
+ db.close();
+ }).catch(printErrorIfAvailable);
+}
+
+function evictStatusesByRecords(records) {
+ return evictStatuses(records.map(function (_ref6) {
+ var id = _ref6.id;
+ return id;
+ }));
+}
+
+function putAccounts(records, avatarStatic) {
+ var avatarKey = avatarStatic ? 'avatar_static' : 'avatar';
+ var newURLs = [];
+
+ put('accounts', records, function (newRecord, oldKey, store, oncomplete) {
+ store.get(oldKey).onsuccess = function (_ref7) {
+ var target = _ref7.target;
+
+ accountAssetKeys.forEach(function (key) {
+ var newURL = newRecord[key];
+ var oldURL = target.result[key];
+
+ if (newURL !== oldURL) {
+ openCache().then(function (cache) {
+ return cache.delete(oldURL);
+ }).catch(printErrorIfAvailable);
+ }
+ });
+
+ var newURL = newRecord[avatarKey];
+ var oldURL = target.result[avatarKey];
+
+ if (newURL !== oldURL) {
+ newURLs.push(newURL);
+ }
+
+ oncomplete();
+ };
+ }, function (newRecord, oncomplete) {
+ newURLs.push(newRecord[avatarKey]);
+ oncomplete();
+ }).then(function (records) {
+ return Promise.all([evictAccountsByRecords(records), openCache().then(function (cache) {
+ return cache.addAll(newURLs);
+ })]);
+ }).then(freeStorage, function (error) {
+ freeStorage();
+ throw error;
+ }).catch(printErrorIfAvailable);
+}
+
+function putStatuses(records) {
+ put('statuses', records).then(evictStatusesByRecords).catch(printErrorIfAvailable);
+}
+
+function freeStorage() {
+ return navigator.storage.estimate().then(function (_ref8) {
+ var quota = _ref8.quota,
+ usage = _ref8.usage;
+
+ if (usage + storageMargin < quota) {
+ return null;
+ }
+
+ return Object(__WEBPACK_IMPORTED_MODULE_0__db__["a" /* default */])().then(function (db) {
+ return new Promise(function (resolve, reject) {
+ var retrieval = db.transaction('accounts', 'readonly').objectStore('accounts').getAll(null, 1);
+
+ retrieval.onsuccess = function () {
+ if (retrieval.result.length > 0) {
+ resolve(evictAccountsByRecords(retrieval.result).then(freeStorage));
+ } else {
+ resolve(caches.delete('mastodon-system'));
+ }
+ };
+
+ retrieval.onerror = reject;
+
+ db.close();
+ });
+ });
+ });
+}
+
+/***/ }),
+/* 3 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony default export */ __webpack_exports__["a"] = (function () {
+ return new Promise(function (resolve, reject) {
+ // ServiceWorker is required to synchronize the login state.
+ // Microsoft Edge 17 does not support getAll according to:
+ // Catalog of standard and vendor APIs across browsers - Microsoft Edge Development
+ // https://developer.microsoft.com/en-us/microsoft-edge/platform/catalog/?q=specName%3Aindexeddb
+ if (!('caches' in self && 'getAll' in IDBObjectStore.prototype)) {
+ reject();
+ return;
+ }
+
+ var request = indexedDB.open('mastodon');
+
+ request.onerror = reject;
+ request.onsuccess = function (_ref) {
+ var target = _ref.target;
+ return resolve(target.result);
+ };
+
+ request.onupgradeneeded = function (_ref2) {
+ var target = _ref2.target;
+
+ var accounts = target.result.createObjectStore('accounts', { autoIncrement: true });
+ var statuses = target.result.createObjectStore('statuses', { autoIncrement: true });
+
+ accounts.createIndex('id', 'id', { unique: true });
+ accounts.createIndex('moved', 'moved');
+
+ statuses.createIndex('id', 'id', { unique: true });
+ statuses.createIndex('account', 'account');
+ statuses.createIndex('reblog', 'reblog');
+ };
+ });
+});
+
+/***/ }),
+/* 4 */
+/***/ (function(module, exports) {
+
+var MAX_NOTIFICATIONS = 5;
+var GROUP_TAG = 'tag';
+
+// Avoid loading intl-messageformat and dealing with locales in the ServiceWorker
+var formatGroupTitle = function formatGroupTitle(message, count) {
+ return message.replace('%{count}', count);
+};
+
+var notify = function notify(options) {
+ return self.registration.getNotifications().then(function (notifications) {
+ if (notifications.length === MAX_NOTIFICATIONS) {
+ // Reached the maximum number of notifications, proceed with grouping
+ var group = {
+ title: formatGroupTitle(options.data.message, notifications.length + 1),
+ body: notifications.sort(function (n1, n2) {
+ return n1.timestamp < n2.timestamp;
+ }).map(function (notification) {
+ return notification.title;
+ }).join('\n'),
+ badge: '/badge.png',
+ icon: '/android-chrome-192x192.png',
+ tag: GROUP_TAG,
+ data: {
+ url: new URL('/web/notifications', self.location).href,
+ count: notifications.length + 1,
+ message: options.data.message
+ }
+ };
+
+ notifications.forEach(function (notification) {
+ return notification.close();
+ });
+
+ return self.registration.showNotification(group.title, group);
+ } else if (notifications.length === 1 && notifications[0].tag === GROUP_TAG) {
+ // Already grouped, proceed with appending the notification to the group
+ var _group = cloneNotification(notifications[0]);
+
+ _group.title = formatGroupTitle(_group.data.message, _group.data.count + 1);
+ _group.body = options.title + '\n' + _group.body;
+ _group.data = Object.assign({}, _group.data, { count: _group.data.count + 1 });
+
+ return self.registration.showNotification(_group.title, _group);
+ }
+
+ return self.registration.showNotification(options.title, options);
+ });
+};
+
+var handlePush = function handlePush(event) {
+ var options = event.data.json();
+
+ options.body = options.data.nsfw || options.data.content;
+ options.dir = options.data.dir;
+ options.image = options.image || undefined; // Null results in a network request (404)
+ options.timestamp = options.timestamp && new Date(options.timestamp);
+
+ var expandAction = options.data.actions.find(function (action) {
+ return action.todo === 'expand';
+ });
+
+ if (expandAction) {
+ options.actions = [expandAction];
+ options.hiddenActions = options.data.actions.filter(function (action) {
+ return action !== expandAction;
+ });
+ options.data.hiddenImage = options.image;
+ options.image = undefined;
+ } else {
+ options.actions = options.data.actions;
+ }
+
+ event.waitUntil(notify(options));
+};
+
+var cloneNotification = function cloneNotification(notification) {
+ var clone = {};
+
+ for (var k in notification) {
+ clone[k] = notification[k];
+ }
+
+ return clone;
+};
+
+var expandNotification = function expandNotification(notification) {
+ var nextNotification = cloneNotification(notification);
+
+ nextNotification.body = notification.data.content;
+ nextNotification.image = notification.data.hiddenImage;
+ nextNotification.actions = notification.data.actions.filter(function (action) {
+ return action.todo !== 'expand';
+ });
+
+ return self.registration.showNotification(nextNotification.title, nextNotification);
+};
+
+var makeRequest = function makeRequest(notification, action) {
+ return fetch(action.action, {
+ headers: {
+ 'Authorization': 'Bearer ' + notification.data.access_token,
+ 'Content-Type': 'application/json'
+ },
+ method: action.method,
+ credentials: 'include'
+ });
+};
+
+var findBestClient = function findBestClient(clients) {
+ var focusedClient = clients.find(function (client) {
+ return client.focused;
+ });
+ var visibleClient = clients.find(function (client) {
+ return client.visibilityState === 'visible';
+ });
+
+ return focusedClient || visibleClient || clients[0];
+};
+
+var openUrl = function openUrl(url) {
+ return self.clients.matchAll({ type: 'window' }).then(function (clientList) {
+ if (clientList.length !== 0) {
+ var webClients = clientList.filter(function (client) {
+ return (/\/web\//.test(client.url)
+ );
+ });
+
+ if (webClients.length !== 0) {
+ var client = findBestClient(webClients);
+
+ var _ref = new URL(url),
+ pathname = _ref.pathname;
+
+ if (pathname.startsWith('/web/')) {
+ return client.focus().then(function (client) {
+ return client.postMessage({
+ type: 'navigate',
+ path: pathname.slice('/web/'.length - 1)
+ });
+ });
+ }
+ } else if ('navigate' in clientList[0]) {
+ // Chrome 42-48 does not support navigate
+ var _client = findBestClient(clientList);
+
+ return _client.navigate(url).then(function (client) {
+ return client.focus();
+ });
+ }
+ }
+
+ return self.clients.openWindow(url);
+ });
+};
+
+var removeActionFromNotification = function removeActionFromNotification(notification, action) {
+ var actions = notification.actions.filter(function (act) {
+ return act.action !== action.action;
+ });
+ var nextNotification = cloneNotification(notification);
+
+ nextNotification.actions = actions;
+
+ return self.registration.showNotification(nextNotification.title, nextNotification);
+};
+
+var handleNotificationClick = function handleNotificationClick(event) {
+ var reactToNotificationClick = new Promise(function (resolve, reject) {
+ if (event.action) {
+ var action = event.notification.data.actions.find(function (_ref2) {
+ var action = _ref2.action;
+ return action === event.action;
+ });
+
+ if (action.todo === 'expand') {
+ resolve(expandNotification(event.notification));
+ } else if (action.todo === 'request') {
+ resolve(makeRequest(event.notification, action).then(function () {
+ return removeActionFromNotification(event.notification, action);
+ }));
+ } else {
+ reject('Unknown action: ' + action.todo);
+ }
+ } else {
+ event.notification.close();
+ resolve(openUrl(event.notification.data.url));
+ }
+ });
+
+ event.waitUntil(reactToNotificationClick);
+};
+
+self.addEventListener('push', handlePush);
+self.addEventListener('notificationclick', handleNotificationClick);
+
+/***/ })
+/******/ ]);
\ No newline at end of file