viztracer 1.1.0__cp314-cp314-win32.whl

viztracer/web_dist/LICENSE

@@ -0,0 +1,189 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright (c) 2017, The Android Open Source Project
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+

viztracer/web_dist/index.html

@@ -0,0 +1,127 @@
+<!doctype html>
+<html lang="en-us">
+<head>
+  <meta charset="utf-8">
+  <title>Perfetto UI</title>
+  <meta content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0" name="viewport" />
+  <link rel="shortcut icon" id="favicon" type="image/png" href="data:image/png;base64,iVBORw0KGgo=">
+</head>
+<body data-perfetto_version='{"stable":"v52.0-6b9586def"}'>
+  <!--
+    Don't add any content here. The whole <body> is replaced by
+    frontend/index.ts when bootstrapping. This is only used for very early
+    error reporting.
+  -->
+  <style>
+  #app_load_failure {opacity:0;transition:opacity 1s ease;position:absolute;overflow:auto;background:#080082;top:0;left:0;width:100%;height:100%;bottom:0;right:0;margin:0;opacity:0;user-select:text}
+  #app_load_failure > pre {color:#fff;position:absolute;margin:auto;white-space:pre-wrap;top:10vh;max-width:90vw;width:880px;left:0;right:0;font-size:16px;line-height:30px;font-weight:700}
+  #app_load_failure > pre span {background:#fff;color:#080082;padding:2px}
+  #app_load_failure_dbg { overflow-wrap: break-word; font-size: 12px; line-height: 1; font-weight: initial;}
+  #app_load_failure a {color:#fff}
+  #app_load { position: absolute; top: 0; left: 0; right:0; bottom: 0; background-color: #2c3e50;}
+  #app_load_spinner { margin: 30vh auto; width: 150px; height: 150px; border: 3px solid rgba(255,255,255,.3); border-radius: 50%; border-top-color: #fff; animation: app_load_spin 1s ease-in-out infinite; }
+  @keyframes app_load_spin { to { transform: rotate(360deg); } }
+  </style>
+  <div id="app_load"><div id="app_load_spinner"></div></div>
+  <div id="app_load_failure">
+<pre>
+<span>Perfetto UI - An unrecoverable problem occurred</span>
+
+If you are seeing this message, something went wrong while loading the UI.
+In most cases this is due to very slow or flaky network and it goes away by
+disabling and re-enabling WiFi or trying reloading.
+
+If the problem persists try these remediation steps:
+
+* Force-reload the page with Ctrl+Shift+R (Mac: Meta+Shift+R) or
+  Shift + click on the refresh button.
+
+* <a href="javascript:clearAllCaches();">Clear all the site storage and caches</a> and reload the page.
+
+* Clear the site data and caches from devtools, following <a target="_blank" href="https://developers.google.com/web/tools/chrome-devtools/storage/cache#deletecache">these instructions</a>.
+
+If none of this works, file a bug attaching logs and screenshots from devtools.
+  Googlers:      <a href="http://go/perfetto-ui-bug" target="_blank">go/perfetto-ui-bug</a>
+  Non-googlers:  <a href="https://github.com/google/perfetto/issues/new" target="_blank">github.com/google/perfetto/issues/new</a>
+
+<div id=app_load_failure_err></div>
+Technical Information:
+<div id=app_load_failure_dbg></div>
+</pre>
+  </div>
+  <script type="text/javascript">
+    'use strict';
+    (function () {
+      const TIMEOUT_MS = 120000;
+      let errTimerId = undefined;
+
+      function errHandler(err) {
+        // Note: we deliberately don't clearTimeout(), which means that this
+        // handler is called also in the happy case when the UI loads. In that
+        // case, though, the onCssLoaded() in frontend/index.ts will empty the
+        // <body>, so |div| below will be null and this function becomes a
+        // no-op.
+        const div = document.getElementById('app_load_failure');
+        if (!div) return;
+        div.style.opacity ='1';
+        const errDom = document.getElementById('app_load_failure_err');
+        if (!errDom) return;
+        console.error(err);
+        errDom.innerText += `${err}\n`;
+        const storageJson = JSON.stringify(window.localStorage);
+        const dbg = document.getElementById('app_load_failure_dbg');
+        if (!dbg) return;
+        dbg.innerText = `LocalStorage: ${storageJson}\n`;
+        if (errTimerId !== undefined) clearTimeout(errTimerId);
+      }
+
+      // For the 'Click here to clear all caches'.
+      window.clearAllCaches = async () => {
+        if (window.localStorage) window.localStorage.clear();
+        if (window.sessionStorage) window.sessionStorage.clear();
+        const promises = [];
+        if (window.caches) {
+          try {
+            const keys = await window.caches.keys();
+            keys.forEach(k => promises.push(window.caches.delete(k)));
+          } catch (_) {
+            // TODO(288483453)
+          }
+        }
+        if (navigator.serviceWorker) {
+          const regs = await navigator.serviceWorker.getRegistrations();
+          regs.forEach(reg => promises.push(reg.unregister()));
+        }
+        try {
+          await Promise.all(promises);
+        } catch (_) {
+          // TODO(288483453)
+        }
+        window.location.reload();
+      }
+
+      // If the frontend doesn't come up, make the error page above visible.
+      errTimerId = setTimeout(() => errHandler('Timed out'), TIMEOUT_MS);
+      window.onerror = errHandler;
+      window.onunhandledrejection = errHandler;
+
+      const versionStr = document.body.dataset['perfetto_version'] || '{}';
+      const versionMap = JSON.parse(versionStr);
+      const channel = localStorage.getItem('perfettoUiChannel') || 'stable';
+
+      // The '.' below is a fallback for the case of opening a pinned version
+      // (e.g., ui.perfetto.dev/v1.2.3./). In that case, the index.html has no
+      // valid version map; we want to load the frontend from the same
+      // sub-directory directory, hence ./frontend_bundle.js.
+      const version = versionMap[channel] || versionMap['stable'] || '.';
+
+      const script = document.createElement('script');
+      script.async = true;
+      script.src = version + '/frontend_bundle.js';
+      script.onerror = () => errHandler(`Failed to load ${script.src}`);
+
+      document.head.append(script);
+    })();
+  </script>
+</body>
+</html>

viztracer/web_dist/service_worker.js

@@ -0,0 +1,279 @@
+var service_worker = (function () {
+'use strict';
+
+var service_worker = {};
+
+// Copyright (C) 2020 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(service_worker, "__esModule", { value: true });
+const LOG_TAG = `ServiceWorker: `;
+const CACHE_NAME = 'ui-perfetto-dev';
+const OPEN_TRACE_PREFIX = '/_open_trace';
+// If the fetch() for the / doesn't respond within 3s, return a cached version.
+// This is to avoid that a user waits too much if on a flaky network.
+const INDEX_TIMEOUT_MS = 3000;
+// Use more relaxed timeouts when caching the subresources for the new version
+// in the background.
+const INSTALL_TIMEOUT_MS = 30000;
+// Files passed to POST /_open_trace/NNNN.
+let postedFiles = new Map();
+// The install() event is fired:
+// 1. On the first visit, when there is no SW installed.
+// 2. Every time the user opens the site and the version has been updated (they
+//    will get the newer version regardless, unless we hit INDEX_TIMEOUT_MS).
+// The latter happens because:
+// - / (index.html) is always served from the network (% timeout) and it pulls
+//   /v1.2-sha/frontend_bundle.js.
+// - /v1.2-sha/frontend_bundle.js will register /service_worker.js?v=v1.2-sha.
+// The service_worker.js script itself never changes, but the browser
+// re-installs it because the version in the V? query-string argument changes.
+// The reinstallation will cache the new files from the v.1.2-sha/manifest.json.
+self.addEventListener('install', (event) => {
+    const doInstall = async () => {
+        // If we can not access the cache we must give up on the service
+        // worker:
+        let bypass = true;
+        try {
+            bypass = await caches.has('BYPASS_SERVICE_WORKER');
+        }
+        catch (_) {
+            // TODO(288483453)
+        }
+        if (bypass) {
+            // Throw will prevent the installation.
+            throw new Error(LOG_TAG + 'skipping installation, bypass enabled');
+        }
+        // Delete old cache entries from the pre-feb-2021 service worker.
+        try {
+            for (const key of await caches.keys()) {
+                if (key.startsWith('dist-')) {
+                    await caches.delete(key);
+                }
+            }
+        }
+        catch (_) {
+            // TODO(288483453)
+            // It's desirable to delete the old entries but it's not actually
+            // damaging to keep them around so don't give up on the
+            // installation if this fails.
+        }
+        // The UI should register this as service_worker.js?v=v1.2-sha. Extract the
+        // version number and pre-fetch all the contents for the version.
+        const match = /\bv=([\w.-]*)/.exec(location.search);
+        if (!match) {
+            throw new Error('Failed to install. Was epecting a query string like ' +
+                `?v=v1.2-sha query string, got "${location.search}" instead`);
+        }
+        await installAppVersionIntoCache(match[1]);
+        // skipWaiting() still waits for the install to be complete. Without this
+        // call, the new version would be activated only when all tabs are closed.
+        // Instead, we ask to activate it immediately. This is safe because the
+        // subresources are versioned (e.g. /v1.2-sha/frontend_bundle.js). Even if
+        // there is an old UI tab opened while we activate() a newer version, the
+        // activate() would just cause cache-misses, hence fetch from the network,
+        // for the old tab.
+        self.skipWaiting();
+    };
+    event.waitUntil(doInstall());
+});
+self.addEventListener('activate', (event) => {
+    console.info(LOG_TAG + 'activated');
+    const doActivate = async () => {
+        // This makes a difference only for the very first load, when no service
+        // worker is present. In all the other cases the skipWaiting() will hot-swap
+        // the active service worker anyways.
+        await self.clients.claim();
+    };
+    event.waitUntil(doActivate());
+});
+self.addEventListener('fetch', (event) => {
+    // The early return here will cause the browser to fall back on standard
+    // network-based fetch.
+    if (!shouldHandleHttpRequest(event.request)) {
+        console.debug(LOG_TAG + `serving ${event.request.url} from network`);
+        return;
+    }
+    event.respondWith(handleHttpRequest(event.request));
+});
+function shouldHandleHttpRequest(req) {
+    // Suppress warning: 'only-if-cached' can be set only with 'same-origin' mode.
+    // This seems to be a chromium bug. An internal code search suggests this is a
+    // socially acceptable workaround.
+    if (req.cache === 'only-if-cached' && req.mode !== 'same-origin') {
+        return false;
+    }
+    const url = new URL(req.url);
+    if (url.pathname === '/live_reload')
+        return false;
+    if (url.pathname.startsWith(OPEN_TRACE_PREFIX))
+        return true;
+    return req.method === 'GET' && url.origin === self.location.origin;
+}
+async function handleHttpRequest(req) {
+    if (!shouldHandleHttpRequest(req)) {
+        throw new Error(LOG_TAG + `${req.url} shouldn't have been handled`);
+    }
+    // We serve from the cache even if req.cache == 'no-cache'. It's a bit
+    // contra-intuitive but it's the most consistent option. If the user hits the
+    // reload button*, the browser requests the "/" index with a 'no-cache' fetch.
+    // However all the other resources (css, js, ...) are requested with a
+    // 'default' fetch (this is just how Chrome works, it's not us). If we bypass
+    // the service worker cache when we get a 'no-cache' request, we can end up in
+    // an inconsistent state where the index.html is more recent than the other
+    // resources, which is undesirable.
+    // * Only Ctrl+R. Ctrl+Shift+R will always bypass service-worker for all the
+    // requests (index.html and the rest) made in that tab.
+    const cacheOps = { cacheName: CACHE_NAME };
+    const url = new URL(req.url);
+    if (url.pathname === '/') {
+        try {
+            console.debug(LOG_TAG + `Fetching live ${req.url}`);
+            // The await bleow is needed to fall through in case of an exception.
+            return await fetchWithTimeout(req, INDEX_TIMEOUT_MS);
+        }
+        catch (err) {
+            console.warn(LOG_TAG + `Failed to fetch ${req.url}, using cache.`, err);
+            // Fall through the code below.
+        }
+    }
+    else if (url.pathname === '/offline') {
+        // Escape hatch to force serving the offline version without attempting the
+        // network fetch.
+        const cachedRes = await caches.match(new Request('/'), cacheOps);
+        if (cachedRes)
+            return cachedRes;
+    }
+    else if (url.pathname.startsWith(OPEN_TRACE_PREFIX)) {
+        return await handleOpenTraceRequest(req);
+    }
+    const cachedRes = await caches.match(req, cacheOps);
+    if (cachedRes) {
+        console.debug(LOG_TAG + `serving ${req.url} from cache`);
+        return cachedRes;
+    }
+    // In any other case, just propagate the fetch on the network, which is the
+    // safe behavior.
+    console.warn(LOG_TAG + `cache miss on ${req.url}, using live network`);
+    return fetch(req);
+}
+// Handles GET and POST requests to /_open_trace/NNNN, where NNNN is typically a
+// random token generated by the client.
+// This works as follows:
+// - The client does a POST request to /_open_trace/NNNN passing the trace blob
+//   as multipart-data, alongside other options like hideSidebar & co that we
+//   support in the usual querystring (see router.ts)
+// - The SW takes the file and puts it in the global variable `postedFiles`.
+// - The SW responds to the POST request with a redirect to
+//   ui.perfetto.dev/#!/?url=https://ui.perfetto.dev/_open_trace/NNNN&other_args
+// - When the new ui.perfetto.dev is reloaded, it will naturally try to fetch
+//   the trace from /_open_trace/NNNN, this time via a GET request.
+// - The SW intercepts the GET request and returns the file previosly stored in
+//   `postedFiles`.
+// We use postedFiles here to handle the case of progammatically POST-ing to >1
+// instances of ui.perfetto.dev simultaneously, to avoid races.
+// Note that we should not use a global variable for `postedFiles` but we should
+// use the CacheAPI because, technically speaking, the SW could be disposed
+// and respawned in between the POST and the GET request. In practice, however,
+// SWs are disposed only after 30s seconds of idleness. The POST->GET requests
+// happen back-to-back..
+async function handleOpenTraceRequest(req) {
+    const url = new URL(req.url);
+    console.assert(url.pathname.startsWith(OPEN_TRACE_PREFIX));
+    const fileKey = url.pathname.substring(OPEN_TRACE_PREFIX.length);
+    if (req.method === 'POST') {
+        const formData = await req.formData();
+        const qsParams = new URLSearchParams();
+        // Iterate over the POST fields and copy them over the querystring in
+        // the hash, with the exception of the trace file. The trace file is
+        // kept in the serviceworker and passed as a url= argument.
+        formData.forEach((value, key) => {
+            if (key === 'trace') {
+                if (value instanceof File) {
+                    postedFiles.set(fileKey, value);
+                    qsParams.set('url', req.url);
+                }
+                return;
+            }
+            qsParams.set(key, `${value}`);
+        }); // formData.forEach()
+        return Response.redirect(`${url.protocol}//${url.host}/#!/?${qsParams}`);
+    }
+    // else... method == 'GET'
+    const file = postedFiles.get(fileKey);
+    if (file !== undefined) {
+        postedFiles.delete(fileKey);
+        return new Response(file);
+    }
+    // The file /_open_trace/NNNN does not exist.
+    return Response.error();
+}
+async function installAppVersionIntoCache(version) {
+    const manifestUrl = `${version}/manifest.json`;
+    try {
+        console.log(LOG_TAG + `Starting installation of ${manifestUrl}`);
+        await caches.delete(CACHE_NAME);
+        const resp = await fetchWithTimeout(manifestUrl, INSTALL_TIMEOUT_MS);
+        const manifest = await resp.json();
+        const manifestResources = manifest['resources'];
+        if (!manifestResources || !(manifestResources instanceof Object)) {
+            throw new Error(`Invalid manifest ${manifestUrl} : ${manifest}`);
+        }
+        const cache = await caches.open(CACHE_NAME);
+        const urlsToCache = [];
+        // We use cache:reload to make sure that the index is always current and we
+        // don't end up in some cycle where we keep re-caching the index coming from
+        // the service worker itself.
+        urlsToCache.push(new Request('/', { cache: 'reload', mode: 'same-origin' }));
+        for (const [resource, integrity] of Object.entries(manifestResources)) {
+            // We use cache: no-cache rather then reload here because the versioned
+            // sub-resources are expected to be immutable and should never be
+            // ambiguous. A revalidation request is enough.
+            const reqOpts = {
+                cache: 'no-cache',
+                mode: 'same-origin',
+                integrity: `${integrity}`,
+            };
+            urlsToCache.push(new Request(`${version}/${resource}`, reqOpts));
+        }
+        await cache.addAll(urlsToCache);
+        console.log(LOG_TAG + 'installation completed for ' + version);
+    }
+    catch (err) {
+        console.error(LOG_TAG + `Installation failed for ${manifestUrl}`, err);
+        await caches.delete(CACHE_NAME);
+        throw err;
+    }
+}
+function fetchWithTimeout(req, timeoutMs) {
+    const url = req.url || `${req}`;
+    return new Promise((resolve, reject) => {
+        const timerId = setTimeout(() => {
+            reject(new Error(`Timed out while fetching ${url}`));
+        }, timeoutMs);
+        fetch(req).then((resp) => {
+            clearTimeout(timerId);
+            if (resp.ok) {
+                resolve(resp);
+            }
+            else {
+                reject(new Error(`Fetch failed for ${url}: ${resp.status} ${resp.statusText}`));
+            }
+        }, reject);
+    });
+}
+
+return service_worker;
+
+})();
+//# sourceMappingURL=service_worker.js.map