WIP - add extractor, generate snippet_data

node_modules/workbox-streams/README.md

@@ -0,0 +1 @@
+This module's documentation can be found at https://developers.google.com/web/tools/workbox/reference-docs/latest/workbox.streams

node_modules/workbox-streams/_public.mjs

@@ -0,0 +1,29 @@
+/*
+  Copyright 2018 Google Inc.
+
+  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
+
+      https://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.
+*/
+
+import {concatenate} from './concatenate.mjs';
+import {concatenateToResponse} from './concatenateToResponse.mjs';
+import {isSupported} from './isSupported.mjs';
+import {strategy} from './strategy.mjs';
+
+import './_version.mjs';
+
+export {
+  concatenate,
+  concatenateToResponse,
+  isSupported,
+  strategy,
+};

node_modules/workbox-streams/_types.mjs

@@ -0,0 +1,21 @@
+/*
+ Copyright 2018 Google Inc. All Rights Reserved.
+ 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.
+ */
+
+import './_version.mjs';
+
+/**
+ * @typedef {Response|ReadableStream|BodyInit} StreamSource
+ * @memberof workbox.streams
+ */

node_modules/workbox-streams/_version.mjs

@@ -0,0 +1 @@
+try{self.workbox.v['workbox:streams:3.6.3']=1;}catch(e){} // eslint-disable-line

node_modules/workbox-streams/browser.mjs

@@ -0,0 +1,19 @@
+/*
+  Copyright 2018 Google Inc.
+
+  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
+
+      https://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.
+*/
+
+import './_version.mjs';
+
+export * from './_public.mjs';

node_modules/workbox-streams/build/workbox-streams.dev.js

@@ -0,0 +1,380 @@
+this.workbox = this.workbox || {};
+this.workbox.streams = (function (exports,logger_mjs,assert_mjs) {
+  'use strict';
+
+  try {
+    self.workbox.v['workbox:streams:3.6.3'] = 1;
+  } catch (e) {} // eslint-disable-line
+
+  /*
+   Copyright 2018 Google Inc. All Rights Reserved.
+   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.
+  */
+
+  /**
+   * Takes either a Response, a ReadableStream, or a
+   * [BodyInit](https://fetch.spec.whatwg.org/#bodyinit) and returns the
+   * ReadableStreamReader object associated with it.
+   *
+   * @param {workbox.streams.StreamSource} source
+   * @return {ReadableStreamReader}
+   * @private
+   */
+  function _getReaderFromSource(source) {
+    if (source.body && source.body.getReader) {
+      return source.body.getReader();
+    }
+
+    if (source.getReader) {
+      return source.getReader();
+    }
+
+    // TODO: This should be possible to do by constructing a ReadableStream, but
+    // I can't get it to work. As a hack, construct a new Response, and use the
+    // reader associated with its body.
+    return new Response(source).body.getReader();
+  }
+
+  /**
+   * Takes multiple source Promises, each of which could resolve to a Response, a
+   * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit).
+   *
+   * Returns an object exposing a ReadableStream with each individual stream's
+   * data returned in sequence, along with a Promise which signals when the
+   * stream is finished (useful for passing to a FetchEvent's waitUntil()).
+   *
+   * @param {Array<Promise<workbox.streams.StreamSource>>} sourcePromises
+   * @return {Object<{done: Promise, stream: ReadableStream}>}
+   *
+   * @memberof workbox.streams
+   */
+  function concatenate(sourcePromises) {
+    {
+      assert_mjs.assert.isArray(sourcePromises, {
+        moduleName: 'workbox-streams',
+        funcName: 'concatenate',
+        paramName: 'sourcePromises'
+      });
+    }
+
+    const readerPromises = sourcePromises.map(sourcePromise => {
+      return Promise.resolve(sourcePromise).then(source => {
+        return _getReaderFromSource(source);
+      });
+    });
+
+    let fullyStreamedResolve;
+    let fullyStreamedReject;
+    const done = new Promise((resolve, reject) => {
+      fullyStreamedResolve = resolve;
+      fullyStreamedReject = reject;
+    });
+
+    let i = 0;
+    const logMessages = [];
+    const stream = new ReadableStream({
+      pull(controller) {
+        return readerPromises[i].then(reader => reader.read()).then(result => {
+          if (result.done) {
+            {
+              logMessages.push(['Reached the end of source:', sourcePromises[i]]);
+            }
+
+            i++;
+            if (i >= readerPromises.length) {
+              // Log all the messages in the group at once in a single group.
+              {
+                logger_mjs.logger.groupCollapsed(`Concatenating ${readerPromises.length} sources.`);
+                for (const message of logMessages) {
+                  if (Array.isArray(message)) {
+                    logger_mjs.logger.log(...message);
+                  } else {
+                    logger_mjs.logger.log(message);
+                  }
+                }
+                logger_mjs.logger.log('Finished reading all sources.');
+                logger_mjs.logger.groupEnd();
+              }
+
+              controller.close();
+              fullyStreamedResolve();
+              return;
+            }
+
+            return this.pull(controller);
+          } else {
+            controller.enqueue(result.value);
+          }
+        }).catch(error => {
+          {
+            logger_mjs.logger.error('An error occurred:', error);
+          }
+          fullyStreamedReject(error);
+          throw error;
+        });
+      },
+
+      cancel() {
+        {
+          logger_mjs.logger.warn('The ReadableStream was cancelled.');
+        }
+
+        fullyStreamedResolve();
+      }
+    });
+
+    return { done, stream };
+  }
+
+  /*
+   Copyright 2018 Google Inc. All Rights Reserved.
+   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.
+  */
+
+  /**
+   * This is a utility method that determines whether the current browser supports
+   * the features required to create streamed responses. Currently, it checks if
+   * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)
+   * is available.
+   *
+   * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,
+   * `'text/html'` will be used by default.
+   * @return {boolean} `true`, if the current browser meets the requirements for
+   * streaming responses, and `false` otherwise.
+   *
+   * @memberof workbox.streams
+   */
+  function createHeaders(headersInit = {}) {
+    // See https://github.com/GoogleChrome/workbox/issues/1461
+    const headers = new Headers(headersInit);
+    if (!headers.has('content-type')) {
+      headers.set('content-type', 'text/html');
+    }
+    return headers;
+  }
+
+  /*
+   Copyright 2018 Google Inc. All Rights Reserved.
+   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.
+  */
+
+  /**
+   * Takes multiple source Promises, each of which could resolve to a Response, a
+   * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit),
+   * along with a
+   * [HeadersInit](https://fetch.spec.whatwg.org/#typedefdef-headersinit).
+   *
+   * Returns an object exposing a Response whose body consists of each individual
+   * stream's data returned in sequence, along with a Promise which signals when
+   * the stream is finished (useful for passing to a FetchEvent's waitUntil()).
+   *
+   * @param {Array<Promise<workbox.streams.StreamSource>>} sourcePromises
+   * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,
+   * `'text/html'` will be used by default.
+   * @return {Object<{done: Promise, response: Response}>}
+   *
+   * @memberof workbox.streams
+   */
+  function concatenateToResponse(sourcePromises, headersInit) {
+    const { done, stream } = concatenate(sourcePromises);
+
+    const headers = createHeaders(headersInit);
+    const response = new Response(stream, { headers });
+
+    return { done, response };
+  }
+
+  /*
+   Copyright 2018 Google Inc. All Rights Reserved.
+   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.
+  */
+
+  let cachedIsSupported = undefined;
+
+  /**
+   * This is a utility method that determines whether the current browser supports
+   * the features required to create streamed responses. Currently, it checks if
+   * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)
+   * can be created.
+   *
+   * @return {boolean} `true`, if the current browser meets the requirements for
+   * streaming responses, and `false` otherwise.
+   *
+   * @memberof workbox.streams
+   */
+  function isSupported() {
+    if (cachedIsSupported === undefined) {
+      // See https://github.com/GoogleChrome/workbox/issues/1473
+      try {
+        new ReadableStream({ start() {} });
+        cachedIsSupported = true;
+      } catch (error) {
+        cachedIsSupported = false;
+      }
+    }
+
+    return cachedIsSupported;
+  }
+
+  /*
+   Copyright 2018 Google Inc. All Rights Reserved.
+   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.
+  */
+
+  /**
+   * A shortcut to create a strategy that could be dropped-in to Workbox's router.
+   *
+   * On browsers that do not support constructing new `ReadableStream`s, this
+   * strategy will automatically wait for all the `sourceFunctions` to complete,
+   * and create a final response that concatenates their values together.
+   *
+   * @param {
+   *   Array<function(workbox.routing.Route~handlerCallback)>} sourceFunctions
+   * Each function should return a {@link workbox.streams.StreamSource} (or a
+   * Promise which resolves to one).
+   * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,
+   * `'text/html'` will be used by default.
+   * @return {workbox.routing.Route~handlerCallback}
+   *
+   * @memberof workbox.streams
+   */
+  function strategy(sourceFunctions, headersInit) {
+    return (() => {
+      var _ref = babelHelpers.asyncToGenerator(function* ({ event, url, params }) {
+        if (isSupported()) {
+          const { done, response } = concatenateToResponse(sourceFunctions.map(function (sourceFunction) {
+            return sourceFunction({ event, url, params });
+          }), headersInit);
+          event.waitUntil(done);
+          return response;
+        }
+
+        {
+          logger_mjs.logger.log(`The current browser doesn't support creating response ` + `streams. Falling back to non-streaming response instead.`);
+        }
+
+        // Fallback to waiting for everything to finish, and concatenating the
+        // responses.
+        const parts = yield Promise.all(sourceFunctions.map(function (sourceFunction) {
+          return sourceFunction({ event, url, params });
+        }).map((() => {
+          var _ref2 = babelHelpers.asyncToGenerator(function* (responsePromise) {
+            const response = yield responsePromise;
+            if (response instanceof Response) {
+              return response.blob();
+            }
+
+            // Otherwise, assume it's something like a string which can be used
+            // as-is when constructing the final composite blob.
+            return response;
+          });
+
+          return function (_x2) {
+            return _ref2.apply(this, arguments);
+          };
+        })()));
+
+        const headers = createHeaders(headersInit);
+        // Constructing a new Response from a Blob source is well-supported.
+        // So is constructing a new Blob from multiple source Blobs or strings.
+        return new Response(new Blob(parts), { headers });
+      });
+
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    })();
+  }
+
+  /*
+    Copyright 2018 Google Inc.
+
+    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
+
+        https://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.
+  */
+
+  /*
+    Copyright 2018 Google Inc.
+
+    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
+
+        https://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.
+  */
+
+  exports.concatenate = concatenate;
+  exports.concatenateToResponse = concatenateToResponse;
+  exports.isSupported = isSupported;
+  exports.strategy = strategy;
+
+  return exports;
+
+}({},workbox.core._private,workbox.core._private));
+
+//# sourceMappingURL=workbox-streams.dev.js.map

node_modules/workbox-streams/build/workbox-streams.prod.js

@@ -0,0 +1,3 @@
+this.workbox=this.workbox||{},this.workbox.streams=function(e){"use strict";try{self.workbox.v["workbox:streams:3.6.3"]=1}catch(e){}function n(e){const n=e.map(e=>Promise.resolve(e).then(e=>(e=e).body&&e.body.getReader?e.body.getReader():e.getReader?e.getReader():new Response(e).body.getReader()));var t;let r,s;let o=0;return{done:new Promise((e,n)=>{r=e,s=n}),stream:new ReadableStream({pull(e){return n[o].then(e=>e.read()).then(t=>{if(t.done)return++o>=n.length?(e.close(),void r()):this.pull(e);e.enqueue(t.value)}).catch(e=>{throw s(e),e})},cancel(){r()}})}}function t(e={}){const n=new Headers(e);return n.has("content-type")||n.set("content-type","text/html"),n}function r(e,r){const{done:s,stream:o}=n(e),u=t(r);return{done:s,response:new Response(o,{headers:u})}}let s=void 0;function o(){if(void 0===s)try{new ReadableStream({start(){}}),s=!0}catch(e){s=!1}return s}return e.concatenate=n,e.concatenateToResponse=r,e.isSupported=o,e.strategy=function(e,n){return s=babelHelpers.asyncToGenerator(function*({event:s,url:u,params:i}){if(o()){const{done:t,response:o}=r(e.map(function(e){return e({event:s,url:u,params:i})}),n);return s.waitUntil(t),o}const c=yield Promise.all(e.map(function(e){return e({event:s,url:u,params:i})}).map((a=babelHelpers.asyncToGenerator(function*(e){const n=yield e;return n instanceof Response?n.blob():n}),function(e){return a.apply(this,arguments)})));var a;const l=t(n);return new Response(new Blob(c),{headers:l})}),function(e){return s.apply(this,arguments)};var s},e}({});
+
+//# sourceMappingURL=workbox-streams.prod.js.map

node_modules/workbox-streams/build/workbox-streams.prod.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"mappings":"","sources":["packages/workbox-streams/browser.mjs"],"sourcesContent":["this.workbox=this.workbox||{},this.workbox.streams=function(e){\"use strict\";try{self.workbox.v[\"workbox:streams:3.6.3\"]=1}catch(e){}function n(e){const n=e.map(e=>Promise.resolve(e).then(e=>(e=e).body&&e.body.getReader?e.body.getReader():e.getReader?e.getReader():new Response(e).body.getReader()));var t;let r,s;let o=0;return{done:new Promise((e,n)=>{r=e,s=n}),stream:new ReadableStream({pull(e){return n[o].then(e=>e.read()).then(t=>{if(t.done)return++o>=n.length?(e.close(),void r()):this.pull(e);e.enqueue(t.value)}).catch(e=>{throw s(e),e})},cancel(){r()}})}}function t(e={}){const n=new Headers(e);return n.has(\"content-type\")||n.set(\"content-type\",\"text/html\"),n}function r(e,r){const{done:s,stream:o}=n(e),u=t(r);return{done:s,response:new Response(o,{headers:u})}}let s=void 0;function o(){if(void 0===s)try{new ReadableStream({start(){}}),s=!0}catch(e){s=!1}return s}return e.concatenate=n,e.concatenateToResponse=r,e.isSupported=o,e.strategy=function(e,n){return s=babelHelpers.asyncToGenerator(function*({event:s,url:u,params:i}){if(o()){const{done:t,response:o}=r(e.map(function(e){return e({event:s,url:u,params:i})}),n);return s.waitUntil(t),o}const c=yield Promise.all(e.map(function(e){return e({event:s,url:u,params:i})}).map((a=babelHelpers.asyncToGenerator(function*(e){const n=yield e;return n instanceof Response?n.blob():n}),function(e){return a.apply(this,arguments)})));var a;const l=t(n);return new Response(new Blob(c),{headers:l})}),function(e){return s.apply(this,arguments)};var s},e}({});\n"],"file":"workbox-streams.prod.js"}

node_modules/workbox-streams/concatenate.mjs

@@ -0,0 +1,140 @@
+/*
+ Copyright 2018 Google Inc. All Rights Reserved.
+ 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.
+*/
+
+import {logger} from 'workbox-core/_private/logger.mjs';
+import {assert} from 'workbox-core/_private/assert.mjs';
+
+import './_version.mjs';
+
+/**
+ * Takes either a Response, a ReadableStream, or a
+ * [BodyInit](https://fetch.spec.whatwg.org/#bodyinit) and returns the
+ * ReadableStreamReader object associated with it.
+ *
+ * @param {workbox.streams.StreamSource} source
+ * @return {ReadableStreamReader}
+ * @private
+ */
+function _getReaderFromSource(source) {
+  if (source.body && source.body.getReader) {
+    return source.body.getReader();
+  }
+
+  if (source.getReader) {
+    return source.getReader();
+  }
+
+  // TODO: This should be possible to do by constructing a ReadableStream, but
+  // I can't get it to work. As a hack, construct a new Response, and use the
+  // reader associated with its body.
+  return new Response(source).body.getReader();
+}
+
+/**
+ * Takes multiple source Promises, each of which could resolve to a Response, a
+ * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit).
+ *
+ * Returns an object exposing a ReadableStream with each individual stream's
+ * data returned in sequence, along with a Promise which signals when the
+ * stream is finished (useful for passing to a FetchEvent's waitUntil()).
+ *
+ * @param {Array<Promise<workbox.streams.StreamSource>>} sourcePromises
+ * @return {Object<{done: Promise, stream: ReadableStream}>}
+ *
+ * @memberof workbox.streams
+ */
+function concatenate(sourcePromises) {
+  if (process.env.NODE_ENV !== 'production') {
+    assert.isArray(sourcePromises, {
+      moduleName: 'workbox-streams',
+      funcName: 'concatenate',
+      paramName: 'sourcePromises',
+    });
+  }
+
+  const readerPromises = sourcePromises.map((sourcePromise) => {
+    return Promise.resolve(sourcePromise).then((source) => {
+      return _getReaderFromSource(source);
+    });
+  });
+
+  let fullyStreamedResolve;
+  let fullyStreamedReject;
+  const done = new Promise((resolve, reject) => {
+    fullyStreamedResolve = resolve;
+    fullyStreamedReject = reject;
+  });
+
+  let i = 0;
+  const logMessages = [];
+  const stream = new ReadableStream({
+    pull(controller) {
+      return readerPromises[i]
+        .then((reader) => reader.read())
+        .then((result) => {
+          if (result.done) {
+            if (process.env.NODE_ENV !== 'production') {
+              logMessages.push(['Reached the end of source:',
+                sourcePromises[i]]);
+            }
+
+            i++;
+            if (i >= readerPromises.length) {
+              // Log all the messages in the group at once in a single group.
+              if (process.env.NODE_ENV !== 'production') {
+                logger.groupCollapsed(
+                  `Concatenating ${readerPromises.length} sources.`);
+                for (const message of logMessages) {
+                  if (Array.isArray(message)) {
+                    logger.log(...message);
+                  } else {
+                    logger.log(message);
+                  }
+                }
+                logger.log('Finished reading all sources.');
+                logger.groupEnd();
+              }
+
+              controller.close();
+              fullyStreamedResolve();
+              return;
+            }
+
+            return this.pull(controller);
+          } else {
+            controller.enqueue(result.value);
+          }
+        }).catch((error) => {
+          if (process.env.NODE_ENV !== 'production') {
+            logger.error('An error occurred:', error);
+          }
+          fullyStreamedReject(error);
+          throw error;
+        });
+    },
+
+    cancel() {
+      if (process.env.NODE_ENV !== 'production') {
+        logger.warn('The ReadableStream was cancelled.');
+      }
+
+      fullyStreamedResolve();
+    },
+  });
+
+  return {done, stream};
+}
+
+export {concatenate};

node_modules/workbox-streams/concatenateToResponse.mjs

@@ -0,0 +1,47 @@
+/*
+ Copyright 2018 Google Inc. All Rights Reserved.
+ 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.
+*/
+
+import {createHeaders} from './utils/createHeaders.mjs';
+import {concatenate} from './concatenate.mjs';
+
+import './_version.mjs';
+
+/**
+ * Takes multiple source Promises, each of which could resolve to a Response, a
+ * ReadableStream, or a [BodyInit](https://fetch.spec.whatwg.org/#bodyinit),
+ * along with a
+ * [HeadersInit](https://fetch.spec.whatwg.org/#typedefdef-headersinit).
+ *
+ * Returns an object exposing a Response whose body consists of each individual
+ * stream's data returned in sequence, along with a Promise which signals when
+ * the stream is finished (useful for passing to a FetchEvent's waitUntil()).
+ *
+ * @param {Array<Promise<workbox.streams.StreamSource>>} sourcePromises
+ * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,
+ * `'text/html'` will be used by default.
+ * @return {Object<{done: Promise, response: Response}>}
+ *
+ * @memberof workbox.streams
+ */
+function concatenateToResponse(sourcePromises, headersInit) {
+  const {done, stream} = concatenate(sourcePromises);
+
+  const headers = createHeaders(headersInit);
+  const response = new Response(stream, {headers});
+
+  return {done, response};
+}
+
+export {concatenateToResponse};

node_modules/workbox-streams/index.mjs

@@ -0,0 +1,23 @@
+/*
+  Copyright 2018 Google Inc.
+
+  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
+
+      https://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.
+*/
+
+import './_version.mjs';
+
+/**
+ * @namespace workbox.streams
+ */
+
+export * from './_public.mjs';

node_modules/workbox-streams/isSupported.mjs

@@ -0,0 +1,45 @@
+/*
+ Copyright 2018 Google Inc. All Rights Reserved.
+ 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.
+*/
+
+import './_version.mjs';
+
+let cachedIsSupported = undefined;
+
+/**
+ * This is a utility method that determines whether the current browser supports
+ * the features required to create streamed responses. Currently, it checks if
+ * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)
+ * can be created.
+ *
+ * @return {boolean} `true`, if the current browser meets the requirements for
+ * streaming responses, and `false` otherwise.
+ *
+ * @memberof workbox.streams
+ */
+function isSupported() {
+  if (cachedIsSupported === undefined) {
+    // See https://github.com/GoogleChrome/workbox/issues/1473
+    try {
+      new ReadableStream({start() {}});
+      cachedIsSupported = true;
+    } catch (error) {
+      cachedIsSupported = false;
+    }
+  }
+
+  return cachedIsSupported;
+}
+
+export {isSupported};

node_modules/workbox-streams/package.json

@@ -0,0 +1,64 @@
+{
+  "_from": "workbox-streams@^3.6.3",
+  "_id": "workbox-streams@3.6.3",
+  "_inBundle": false,
+  "_integrity": "sha512-rqDuS4duj+3aZUYI1LsrD2t9hHOjwPqnUIfrXSOxSVjVn83W2MisDF2Bj+dFUZv4GalL9xqErcFW++9gH+Z27w==",
+  "_location": "/workbox-streams",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "workbox-streams@^3.6.3",
+    "name": "workbox-streams",
+    "escapedName": "workbox-streams",
+    "rawSpec": "^3.6.3",
+    "saveSpec": null,
+    "fetchSpec": "^3.6.3"
+  },
+  "_requiredBy": [
+    "/workbox-build"
+  ],
+  "_resolved": "https://registry.npmjs.org/workbox-streams/-/workbox-streams-3.6.3.tgz",
+  "_shasum": "beaea5d5b230239836cc327b07d471aa6101955a",
+  "_spec": "workbox-streams@^3.6.3",
+  "_where": "/Users/stefanfejes/Projects/30-seconds-of-python-code/node_modules/workbox-build",
+  "author": {
+    "name": "Google's Web DevRel Team"
+  },
+  "bugs": {
+    "url": "https://github.com/googlechrome/workbox/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "workbox-core": "^3.6.3"
+  },
+  "deprecated": false,
+  "description": "A library that makes it easier to work with Streams in the browser.",
+  "homepage": "https://github.com/GoogleChrome/workbox",
+  "keywords": [
+    "workbox",
+    "workboxjs",
+    "service worker",
+    "sw",
+    "streams",
+    "readablestream"
+  ],
+  "license": "Apache-2.0",
+  "main": "build/workbox-streams.prod.js",
+  "module": "index.mjs",
+  "name": "workbox-streams",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/googlechrome/workbox.git"
+  },
+  "scripts": {
+    "build": "gulp build-packages --package workbox-streams",
+    "prepare": "npm run build",
+    "version": "npm run build"
+  },
+  "version": "3.6.3",
+  "workbox": {
+    "browserNamespace": "workbox.streams",
+    "packageType": "browser"
+  }
+}

node_modules/workbox-streams/strategy.mjs

@@ -0,0 +1,77 @@
+/*
+ Copyright 2018 Google Inc. All Rights Reserved.
+ 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.
+*/
+
+import {logger} from 'workbox-core/_private/logger.mjs';
+
+import {createHeaders} from './utils/createHeaders.mjs';
+import {concatenateToResponse} from './concatenateToResponse.mjs';
+import {isSupported} from './isSupported.mjs';
+
+import './_version.mjs';
+
+/**
+ * A shortcut to create a strategy that could be dropped-in to Workbox's router.
+ *
+ * On browsers that do not support constructing new `ReadableStream`s, this
+ * strategy will automatically wait for all the `sourceFunctions` to complete,
+ * and create a final response that concatenates their values together.
+ *
+ * @param {
+ *   Array<function(workbox.routing.Route~handlerCallback)>} sourceFunctions
+ * Each function should return a {@link workbox.streams.StreamSource} (or a
+ * Promise which resolves to one).
+ * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,
+ * `'text/html'` will be used by default.
+ * @return {workbox.routing.Route~handlerCallback}
+ *
+ * @memberof workbox.streams
+ */
+export function strategy(sourceFunctions, headersInit) {
+  return async ({event, url, params}) => {
+    if (isSupported()) {
+      const {done, response} = concatenateToResponse(sourceFunctions.map(
+        (sourceFunction) => sourceFunction({event, url, params})), headersInit);
+      event.waitUntil(done);
+      return response;
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      logger.log(`The current browser doesn't support creating response ` +
+        `streams. Falling back to non-streaming response instead.`);
+    }
+
+    // Fallback to waiting for everything to finish, and concatenating the
+    // responses.
+    const parts = await Promise.all(
+      sourceFunctions.map(
+        (sourceFunction) => sourceFunction({event, url, params})
+      ).map(async (responsePromise) => {
+        const response = await responsePromise;
+        if (response instanceof Response) {
+          return response.blob();
+        }
+
+        // Otherwise, assume it's something like a string which can be used
+        // as-is when constructing the final composite blob.
+        return response;
+      })
+    );
+
+    const headers = createHeaders(headersInit);
+    // Constructing a new Response from a Blob source is well-supported.
+    // So is constructing a new Blob from multiple source Blobs or strings.
+    return new Response(new Blob(parts), {headers});
+  };
+}

node_modules/workbox-streams/utils/createHeaders.mjs

@@ -0,0 +1,40 @@
+/*
+ Copyright 2018 Google Inc. All Rights Reserved.
+ 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.
+*/
+
+import '../_version.mjs';
+
+/**
+ * This is a utility method that determines whether the current browser supports
+ * the features required to create streamed responses. Currently, it checks if
+ * [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream)
+ * is available.
+ *
+ * @param {HeadersInit} [headersInit] If there's no `Content-Type` specified,
+ * `'text/html'` will be used by default.
+ * @return {boolean} `true`, if the current browser meets the requirements for
+ * streaming responses, and `false` otherwise.
+ *
+ * @memberof workbox.streams
+ */
+function createHeaders(headersInit = {}) {
+  // See https://github.com/GoogleChrome/workbox/issues/1461
+  const headers = new Headers(headersInit);
+  if (!headers.has('content-type')) {
+    headers.set('content-type', 'text/html');
+  }
+  return headers;
+}
+
+export {createHeaders};