Brunobkr/llama.cpp_AlgMor24_github

1this.workbox = this.workbox || {};2this.workbox.recipes = (function (exports, registerRoute_js, StaleWhileRevalidate_js, CacheFirst_js, CacheableResponsePlugin_js, ExpirationPlugin_js, NetworkFirst_js, setCatchHandler_js, matchPrecache_js) {3    'use strict';4 5    // @ts-ignore6    try {7      self['workbox:recipes:7.4.0'] && _();8    } catch (e) {}9 10    /*11      Copyright 2020 Google LLC12 13      Use of this source code is governed by an MIT-style14      license that can be found in the LICENSE file or at15      https://opensource.org/licenses/MIT.16    */17    /**18     * An implementation of the [Google fonts]{@link https://developers.google.com/web/tools/workbox/guides/common-recipes#google_fonts} caching recipe19     *20     * @memberof workbox-recipes21     *22     * @param {Object} [options]23     * @param {string} [options.cachePrefix] Cache prefix for caching stylesheets and webfonts. Defaults to google-fonts24     * @param {number} [options.maxAgeSeconds] Maximum age, in seconds, that font entries will be cached for. Defaults to 1 year25     * @param {number} [options.maxEntries] Maximum number of fonts that will be cached. Defaults to 3026     */27    function googleFontsCache(options = {}) {28      const sheetCacheName = `${options.cachePrefix || 'google-fonts'}-stylesheets`;29      const fontCacheName = `${options.cachePrefix || 'google-fonts'}-webfonts`;30      const maxAgeSeconds = options.maxAgeSeconds || 60 * 60 * 24 * 365;31      const maxEntries = options.maxEntries || 30;32      // Cache the Google Fonts stylesheets with a stale-while-revalidate strategy.33      registerRoute_js.registerRoute(({34        url35      }) => url.origin === 'https://fonts.googleapis.com', new StaleWhileRevalidate_js.StaleWhileRevalidate({36        cacheName: sheetCacheName37      }));38      // Cache the underlying font files with a cache-first strategy for 1 year.39      registerRoute_js.registerRoute(({40        url41      }) => url.origin === 'https://fonts.gstatic.com', new CacheFirst_js.CacheFirst({42        cacheName: fontCacheName,43        plugins: [new CacheableResponsePlugin_js.CacheableResponsePlugin({44          statuses: [0, 200]45        }), new ExpirationPlugin_js.ExpirationPlugin({46          maxAgeSeconds,47          maxEntries48        })]49      }));50    }51 52    /**53     * @memberof workbox-recipes54     55     * @param {Object} options56     * @param {string[]} options.urls Paths to warm the strategy's cache with57     * @param {Strategy} options.strategy Strategy to use58     */59    function warmStrategyCache(options) {60      self.addEventListener('install', event => {61        const done = options.urls.map(path => options.strategy.handleAll({62          event,63          request: new Request(path)64        })[1]);65        event.waitUntil(Promise.all(done));66      });67    }68 69    /*70      Copyright 2020 Google LLC71 72      Use of this source code is governed by an MIT-style73      license that can be found in the LICENSE file or at74      https://opensource.org/licenses/MIT.75    */76    /**77     * An implementation of the [image caching recipe]{@link https://developers.google.com/web/tools/workbox/guides/common-recipes#caching_images}78     *79     * @memberof workbox-recipes80     *81     * @param {Object} [options]82     * @param {string} [options.cacheName] Name for cache. Defaults to images83     * @param {RouteMatchCallback} [options.matchCallback] Workbox callback function to call to match to. Defaults to request.destination === 'image';84     * @param {number} [options.maxAgeSeconds] Maximum age, in seconds, that font entries will be cached for. Defaults to 30 days85     * @param {number} [options.maxEntries] Maximum number of images that will be cached. Defaults to 6086     * @param {WorkboxPlugin[]} [options.plugins] Additional plugins to use for this recipe87     * @param {string[]} [options.warmCache] Paths to call to use to warm this cache88     */89    function imageCache(options = {}) {90      const defaultMatchCallback = ({91        request92      }) => request.destination === 'image';93      const cacheName = options.cacheName || 'images';94      const matchCallback = options.matchCallback || defaultMatchCallback;95      const maxAgeSeconds = options.maxAgeSeconds || 30 * 24 * 60 * 60;96      const maxEntries = options.maxEntries || 60;97      const plugins = options.plugins || [];98      plugins.push(new CacheableResponsePlugin_js.CacheableResponsePlugin({99        statuses: [0, 200]100      }));101      plugins.push(new ExpirationPlugin_js.ExpirationPlugin({102        maxEntries,103        maxAgeSeconds104      }));105      const strategy = new CacheFirst_js.CacheFirst({106        cacheName,107        plugins108      });109      registerRoute_js.registerRoute(matchCallback, strategy);110      // Warms the cache111      if (options.warmCache) {112        warmStrategyCache({113          urls: options.warmCache,114          strategy115        });116      }117    }118 119    /*120      Copyright 2020 Google LLC121 122      Use of this source code is governed by an MIT-style123      license that can be found in the LICENSE file or at124      https://opensource.org/licenses/MIT.125    */126    /**127     * An implementation of the [CSS and JavaScript files recipe]{@link https://developers.google.com/web/tools/workbox/guides/common-recipes#cache_css_and_javascript_files}128     *129     * @memberof workbox-recipes130     *131     * @param {Object} [options]132     * @param {string} [options.cacheName] Name for cache. Defaults to static-resources133     * @param {RouteMatchCallback} [options.matchCallback] Workbox callback function to call to match to. Defaults to request.destination === 'style' || request.destination === 'script' || request.destination === 'worker';134     * @param {WorkboxPlugin[]} [options.plugins] Additional plugins to use for this recipe135     * @param {string[]} [options.warmCache] Paths to call to use to warm this cache136     */137    function staticResourceCache(options = {}) {138      const defaultMatchCallback = ({139        request140      }) => request.destination === 'style' || request.destination === 'script' || request.destination === 'worker';141      const cacheName = options.cacheName || 'static-resources';142      const matchCallback = options.matchCallback || defaultMatchCallback;143      const plugins = options.plugins || [];144      plugins.push(new CacheableResponsePlugin_js.CacheableResponsePlugin({145        statuses: [0, 200]146      }));147      const strategy = new StaleWhileRevalidate_js.StaleWhileRevalidate({148        cacheName,149        plugins150      });151      registerRoute_js.registerRoute(matchCallback, strategy);152      // Warms the cache153      if (options.warmCache) {154        warmStrategyCache({155          urls: options.warmCache,156          strategy157        });158      }159    }160 161    /*162      Copyright 2020 Google LLC163 164      Use of this source code is governed by an MIT-style165      license that can be found in the LICENSE file or at166      https://opensource.org/licenses/MIT.167    */168    /**169     * An implementation of a page caching recipe with a network timeout170     *171     * @memberof workbox-recipes172     *173     * @param {Object} [options]174     * @param {string} [options.cacheName] Name for cache. Defaults to pages175     * @param {RouteMatchCallback} [options.matchCallback] Workbox callback function to call to match to. Defaults to request.mode === 'navigate';176     * @param {number} [options.networkTimoutSeconds] Maximum amount of time, in seconds, to wait on the network before falling back to cache. Defaults to 3177     * @param {WorkboxPlugin[]} [options.plugins] Additional plugins to use for this recipe178     * @param {string[]} [options.warmCache] Paths to call to use to warm this cache179     */180    function pageCache(options = {}) {181      const defaultMatchCallback = ({182        request183      }) => request.mode === 'navigate';184      const cacheName = options.cacheName || 'pages';185      const matchCallback = options.matchCallback || defaultMatchCallback;186      const networkTimeoutSeconds = options.networkTimeoutSeconds || 3;187      const plugins = options.plugins || [];188      plugins.push(new CacheableResponsePlugin_js.CacheableResponsePlugin({189        statuses: [0, 200]190      }));191      const strategy = new NetworkFirst_js.NetworkFirst({192        networkTimeoutSeconds,193        cacheName,194        plugins195      });196      // Registers the route197      registerRoute_js.registerRoute(matchCallback, strategy);198      // Warms the cache199      if (options.warmCache) {200        warmStrategyCache({201          urls: options.warmCache,202          strategy203        });204      }205    }206 207    /*208      Copyright 2020 Google LLC209 210      Use of this source code is governed by an MIT-style211      license that can be found in the LICENSE file or at212      https://opensource.org/licenses/MIT.213    */214    /**215     * An implementation of the [comprehensive fallbacks recipe]{@link https://developers.google.com/web/tools/workbox/guides/advanced-recipes#comprehensive_fallbacks}. Be sure to include the fallbacks in your precache injection216     *217     * @memberof workbox-recipes218     *219     * @param {Object} [options]220     * @param {string} [options.pageFallback] Precache name to match for pag fallbacks. Defaults to offline.html221     * @param {string} [options.imageFallback] Precache name to match for image fallbacks.222     * @param {string} [options.fontFallback] Precache name to match for font fallbacks.223     */224    function offlineFallback(options = {}) {225      const pageFallback = options.pageFallback || 'offline.html';226      const imageFallback = options.imageFallback || false;227      const fontFallback = options.fontFallback || false;228      self.addEventListener('install', event => {229        const files = [pageFallback];230        if (imageFallback) {231          files.push(imageFallback);232        }233        if (fontFallback) {234          files.push(fontFallback);235        }236        event.waitUntil(self.caches.open('workbox-offline-fallbacks').then(cache => cache.addAll(files)));237      });238      const handler = async options => {239        const dest = options.request.destination;240        const cache = await self.caches.open('workbox-offline-fallbacks');241        if (dest === 'document') {242          const match = (await matchPrecache_js.matchPrecache(pageFallback)) || (await cache.match(pageFallback));243          return match || Response.error();244        }245        if (dest === 'image' && imageFallback !== false) {246          const match = (await matchPrecache_js.matchPrecache(imageFallback)) || (await cache.match(imageFallback));247          return match || Response.error();248        }249        if (dest === 'font' && fontFallback !== false) {250          const match = (await matchPrecache_js.matchPrecache(fontFallback)) || (await cache.match(fontFallback));251          return match || Response.error();252        }253        return Response.error();254      };255      setCatchHandler_js.setCatchHandler(handler);256    }257 258    exports.googleFontsCache = googleFontsCache;259    exports.imageCache = imageCache;260    exports.offlineFallback = offlineFallback;261    exports.pageCache = pageCache;262    exports.staticResourceCache = staticResourceCache;263    exports.warmStrategyCache = warmStrategyCache;264 265    return exports;266 267})({}, workbox.routing, workbox.strategies, workbox.strategies, workbox.cacheableResponse, workbox.expiration, workbox.strategies, workbox.routing, workbox.precaching);268//# sourceMappingURL=workbox-recipes.dev.js.map269