text: 'use strict';
  const MANIFEST = 'flutter-app-manifest';
  const TEMP = 'flutter-temp-cache';
  const CACHE_NAME = 'flutter-app-cache';
  const RESOURCES = {
    "assets/AssetManifest.json": "2efbb41d7877d10aac9d091f58ccd7b9",
  "assets/FontManifest.json": "dc3d03800ccca4601324923c0b1d6d57",
  "assets/fonts/MaterialIcons-Regular.otf": "1288c9e28052e028aba623321f7826ac",
  "assets/NOTICES": "a8d1d130b9909728d724354dc06becc1",
  "assets/packages/cupertino_icons/assets/CupertinoIcons.ttf": "6d342eb68f170c97609e9da345464e5e",
  "favicon.png": "5dcef449791fa27946b3d35ad8803796",
  "icons/Icon-192.png": "ac9a721a12bbc803b44f645561ecb1e1",
  "icons/Icon-512.png": "96e752610906ba2a93c65f8abe1645f1",
  "index.html": "90e79ea9d8a7888d8e17eb5725467b0a",
  "/": "90e79ea9d8a7888d8e17eb5725467b0a",
  "main.dart.js": "6ffb92558b5a451c4cdde6f069569d95",
  "manifest.json": "6bdbd005d57b0f2922c84a7a1aeea411",
  "version.json": "281f2a7b1646c3dea6feea25f04fa556"
  };
  
  // The application shell files that are downloaded before a service worker can
  // start.
  const CORE = [
    "/",
  "main.dart.js",
  "index.html",
  "assets/NOTICES",
  "assets/AssetManifest.json",
  "assets/FontManifest.json"];
  // During install, the TEMP cache is populated with the application shell files.
  self.addEventListener("install", (event) => {
    self.skipWaiting();
    return event.waitUntil(
      caches.open(TEMP).then((cache) => {
        return cache.addAll(
          CORE.map((value) => new Request(value + '?revision=' + RESOURCES[value], {'cache': 'reload'})));
      })
    );
  });
  
  // During activate, the cache is populated with the temp files downloaded in
  // install. If this service worker is upgrading from one with a saved
  // MANIFEST, then use this to retain unchanged resource files.
  self.addEventListener("activate", function(event) {
    return event.waitUntil(async function() {
      try {
        var contentCache = await caches.open(CACHE_NAME);
        var tempCache = await caches.open(TEMP);
        var manifestCache = await caches.open(MANIFEST);
        var manifest = await manifestCache.match('manifest');
        // When there is no prior manifest, clear the entire cache.
        if (!manifest) {
          await caches.delete(CACHE_NAME);
          contentCache = await caches.open(CACHE_NAME);
          for (var request of await tempCache.keys()) {
            var response = await tempCache.match(request);
            await contentCache.put(request, response);
          }
          await caches.delete(TEMP);
          // Save the manifest to make future upgrades efficient.
          await manifestCache.put('manifest', new Response(JSON.stringify(RESOURCES)));
          return;
        }
        var oldManifest = await manifest.json();
        var origin = self.location.origin;
        for (var request of await contentCache.keys()) {
          var key = request.url.substring(origin.length + 1);
          if (key == "") {
            key = "/";
          }
          // If a resource from the old manifest is not in the new cache, or if
          // the MD5 sum has changed, delete it. Otherwise the resource is left
          // in the cache and can be reused by the new service worker.
          if (!RESOURCES[key] || RESOURCES[key] != oldManifest[key]) {
            await contentCache.delete(request);
          }
        }
        // Populate the cache with the app shell TEMP files, potentially overwriting
        // cache files preserved above.
        for (var request of await tempCache.keys()) {
          var response = await tempCache.match(request);
          await contentCache.put(request, response);
        }
        await caches.delete(TEMP);
        // Save the manifest to make future upgrades efficient.
        await manifestCache.put('manifest', new Response(JSON.stringify(RESOURCES)));
        return;
      } catch (err) {
        // On an unhandled exception the state of the cache cannot be guaranteed.
        console.error('Failed to upgrade service worker: ' + err);
        await caches.delete(CACHE_NAME);
        await caches.delete(TEMP);
        await caches.delete(MANIFEST);
      }
    }());
  });
  
  // The fetch handler redirects requests for RESOURCE files to the service
  // worker cache.
  self.addEventListener("fetch", (event) => {
    if (event.request.method !== 'GET') {
      return;
    }
    var origin = self.location.origin;
    var key = event.request.url.substring(origin.length + 1);
    // Redirect URLs to the index.html
    if (key.indexOf('?v=') != -1) {
      key = key.split('?v=')[0];
    }
    if (event.request.url == origin || event.request.url.startsWith(origin + '/#') || key == '') {
      key = '/';
    }
    // If the URL is not the RESOURCE list then return to signal that the
    // browser should take over.
    if (!RESOURCES[key]) {
      return;
    }
    // If the URL is the index.html, perform an online-first request.
    if (key == '/') {
      return onlineFirst(event);
    }
    event.respondWith(caches.open(CACHE_NAME)
      .then((cache) =>  {
        return cache.match(event.request).then((response) => {
          // Either respond with the cached resource, or perform a fetch and
          // lazily populate the cache.
          return response || fetch(event.request).then((response) => {
            cache.put(event.request, response.clone());
            return response;
          });
        })
      })
    );
  });
  
  self.addEventListener('message', (event) => {
    // SkipWaiting can be used to immediately activate a waiting service worker.
    // This will also require a page refresh triggered by the main worker.
    if (event.data === 'skipWaiting') {
      self.skipWaiting();
      return;
    }
    if (event.data === 'downloadOffline') {
      downloadOffline();
      return;
    }
  });
  
  // Download offline will check the RESOURCES for all files not in the cache
  // and populate them.
  async function downloadOffline() {
    var resources = [];
    var contentCache = await caches.open(CACHE_NAME);
    var currentContent = {};
    for (var request of await contentCache.keys()) {
      var key = request.url.substring(origin.length + 1);
      if (key == "") {
        key = "/";
      }
      currentContent[key] = true;
    }
    for (var resourceKey of Object.keys(RESOURCES)) {
      if (!currentContent[resourceKey]) {
        resources.push(resourceKey);
      }
    }
    return contentCache.addAll(resources);
  }
  
  // Attempt to download the resource online before falling back to
  // the offline cache.
  function onlineFirst(event) {
    return event.respondWith(
      fetch(event.request).then((response) => {
        return caches.open(CACHE_NAME).then((cache) => {
          cache.put(event.request, response.clone());
          return response;
        });
      }).catch((error) => {
        return caches.open(CACHE_NAME).then((cache) => {
          return cache.match(event.request).then((response) => {
            if (response != null) {
              return response;
            }
            throw error;
          });
        });
      })
    );
  }
  