added all files to project

modules/MMM-PublicTransportHafas/node_modules/fetch-ponyfill/HISTORY.md

@@ -0,0 +1,70 @@
+# History
+
+# 7.1.0
+
+- Updates whatwg-fetch to 3.5.0 to address an issue with IE11.
+
+## 7.0.0
+
+ - Drops support for node 8. Adds node 14 to tests.
+ - Updates whatwg-fetch to ~3.4.1.
+ - Exposes `DOMException` from whatwg-fetch.
+ - Tests against webpack 5 and browserify 17.
+
+## 6.1.0
+
+ - Adds a types field to package.json for TypeScript integration.
+ - Updates node-fetch to 2.6.0
+
+## 6.0.2
+
+ - Fixes WHATWG URL object handling when this module is used in Node.
+
+## 6.0.1
+
+ - Fixes to the TypeScript declaration file.
+
+## 6.0.0
+
+ - Adjusts the way the global object is sniffed for use with Metro.
+
+## 5.0.0
+
+ - Bumps node-fetch from ~1.7.1 to ~2.0.0. This is a potentially breaking
+   change. Refer to the node-fetch [upgrade guide](https://github.com/bitinn/node-fetch/blob/master/UPGRADE-GUIDE.md)
+   for details.
+
+## 4.1.0
+
+ - Bumps node fetch from ~1.6.0 to ~1.7.1.
+ - Bumps whatwg-fetch from ~2.0.1 to ~2.0.3.
+
+## 4.0.0
+
+This release:
+
+ - Bumps whatwg-fetch from ~1.0.0 to ~2.0.1.
+ - Better handling of self/this for browser fetch (more testing friendly).
+
+## 3.0.2
+
+Dependencies now use tilde to allow patch versions to be tracked (this was
+waiting for whatwg-fetch to reach version 1).
+
+## 3.0.1
+
+A link was added to the README to point to the ponyfill definition.
+
+## 3.0.0
+
+Fixes an issue with detection of features like `URLSearchParams`. This is a
+major version bump since apparent behaviour could change in a breaking way in
+browsers which support detected features.
+
+## 2.0.0
+
+Now exposes associated constructors along with `fetch` like:
+
+```javascript
+const {fetch, Request, Response, Headers} = require('fetch-ponyfill')(options);
+```

modules/MMM-PublicTransportHafas/node_modules/fetch-ponyfill/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Mark Stanley Everitt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

modules/MMM-PublicTransportHafas/node_modules/fetch-ponyfill/README.md

@@ -0,0 +1,34 @@
+# Fetch Ponyfill
+
+> WHATWG `fetch` [ponyfill](https://ponyfill.com)
+
+This module wraps the [github/fetch](https://github.com/github/fetch) polyfill in a CommonJS module
+for browserification, and avoids appending anything to the window, instead returning a setup
+function when `fetch-ponyfill` is required. Inspired by
+[object-assign](https://github.com/sindresorhus/object-assign).
+
+When used in Node, delegates to `node-fetch` instead.
+
+## Usage
+
+### Browserify
+
+```javascript
+const {fetch, Request, Response, Headers} = require('fetch-ponyfill')(options);
+```
+
+### Webpack
+
+```javascript
+import fetchPonyfill from 'fetch-ponyfill';
+const {fetch, Request, Response, Headers} = fetchPonyfill(options);
+```
+
+### Options
+
+Where `options` is an object with the following optional properties:
+
+| option | description |
+| ------ | ----------- |
+| `Promise` | An A+ Promise implementation. Defaults to `window.Promise` in the browser, and `global.Promise` in Node. |
+| `XMLHttpRequest` | The XMLHttpRequest constructor. This is useful to feed in when working with Firefox OS. Defaults to `window.XMLHttpRequest`. Has no effect in Node. |

modules/MMM-PublicTransportHafas/node_modules/fetch-ponyfill/build/fetch-browser.js

@@ -0,0 +1,658 @@
+(function (global) {
+  'use strict';
+
+  function fetchPonyfill(options) {
+    var Promise = options && options.Promise || global.Promise;
+    var XMLHttpRequest = options && options.XMLHttpRequest || global.XMLHttpRequest;
+
+    return (function () {
+      var globalThis = Object.create(global, {
+        fetch: {
+          value: undefined,
+          writable: true
+        }
+      });
+
+      (function (global, factory) {
+        typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+        typeof define === 'function' && define.amd ? define(['exports'], factory) :
+        (factory((global.WHATWGFetch = {})));
+      }(this, (function (exports) { 'use strict';
+
+        var global =
+          (typeof globalThis !== 'undefined' && globalThis) ||
+          (typeof self !== 'undefined' && self) ||
+          (typeof global !== 'undefined' && global);
+
+        var support = {
+          searchParams: 'URLSearchParams' in global,
+          iterable: 'Symbol' in global && 'iterator' in Symbol,
+          blob:
+            'FileReader' in global &&
+            'Blob' in global &&
+            (function() {
+              try {
+                new Blob();
+                return true
+              } catch (e) {
+                return false
+              }
+            })(),
+          formData: 'FormData' in global,
+          arrayBuffer: 'ArrayBuffer' in global
+        };
+
+        function isDataView(obj) {
+          return obj && DataView.prototype.isPrototypeOf(obj)
+        }
+
+        if (support.arrayBuffer) {
+          var viewClasses = [
+            '[object Int8Array]',
+            '[object Uint8Array]',
+            '[object Uint8ClampedArray]',
+            '[object Int16Array]',
+            '[object Uint16Array]',
+            '[object Int32Array]',
+            '[object Uint32Array]',
+            '[object Float32Array]',
+            '[object Float64Array]'
+          ];
+
+          var isArrayBufferView =
+            ArrayBuffer.isView ||
+            function(obj) {
+              return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
+            };
+        }
+
+        function normalizeName(name) {
+          if (typeof name !== 'string') {
+            name = String(name);
+          }
+          if (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === '') {
+            throw new TypeError('Invalid character in header field name')
+          }
+          return name.toLowerCase()
+        }
+
+        function normalizeValue(value) {
+          if (typeof value !== 'string') {
+            value = String(value);
+          }
+          return value
+        }
+
+        // Build a destructive iterator for the value list
+        function iteratorFor(items) {
+          var iterator = {
+            next: function() {
+              var value = items.shift();
+              return {done: value === undefined, value: value}
+            }
+          };
+
+          if (support.iterable) {
+            iterator[Symbol.iterator] = function() {
+              return iterator
+            };
+          }
+
+          return iterator
+        }
+
+        function Headers(headers) {
+          this.map = {};
+
+          if (headers instanceof Headers) {
+            headers.forEach(function(value, name) {
+              this.append(name, value);
+            }, this);
+          } else if (Array.isArray(headers)) {
+            headers.forEach(function(header) {
+              this.append(header[0], header[1]);
+            }, this);
+          } else if (headers) {
+            Object.getOwnPropertyNames(headers).forEach(function(name) {
+              this.append(name, headers[name]);
+            }, this);
+          }
+        }
+
+        Headers.prototype.append = function(name, value) {
+          name = normalizeName(name);
+          value = normalizeValue(value);
+          var oldValue = this.map[name];
+          this.map[name] = oldValue ? oldValue + ', ' + value : value;
+        };
+
+        Headers.prototype['delete'] = function(name) {
+          delete this.map[normalizeName(name)];
+        };
+
+        Headers.prototype.get = function(name) {
+          name = normalizeName(name);
+          return this.has(name) ? this.map[name] : null
+        };
+
+        Headers.prototype.has = function(name) {
+          return this.map.hasOwnProperty(normalizeName(name))
+        };
+
+        Headers.prototype.set = function(name, value) {
+          this.map[normalizeName(name)] = normalizeValue(value);
+        };
+
+        Headers.prototype.forEach = function(callback, thisArg) {
+          for (var name in this.map) {
+            if (this.map.hasOwnProperty(name)) {
+              callback.call(thisArg, this.map[name], name, this);
+            }
+          }
+        };
+
+        Headers.prototype.keys = function() {
+          var items = [];
+          this.forEach(function(value, name) {
+            items.push(name);
+          });
+          return iteratorFor(items)
+        };
+
+        Headers.prototype.values = function() {
+          var items = [];
+          this.forEach(function(value) {
+            items.push(value);
+          });
+          return iteratorFor(items)
+        };
+
+        Headers.prototype.entries = function() {
+          var items = [];
+          this.forEach(function(value, name) {
+            items.push([name, value]);
+          });
+          return iteratorFor(items)
+        };
+
+        if (support.iterable) {
+          Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+        }
+
+        function consumed(body) {
+          if (body.bodyUsed) {
+            return Promise.reject(new TypeError('Already read'))
+          }
+          body.bodyUsed = true;
+        }
+
+        function fileReaderReady(reader) {
+          return new Promise(function(resolve, reject) {
+            reader.onload = function() {
+              resolve(reader.result);
+            };
+            reader.onerror = function() {
+              reject(reader.error);
+            };
+          })
+        }
+
+        function readBlobAsArrayBuffer(blob) {
+          var reader = new FileReader();
+          var promise = fileReaderReady(reader);
+          reader.readAsArrayBuffer(blob);
+          return promise
+        }
+
+        function readBlobAsText(blob) {
+          var reader = new FileReader();
+          var promise = fileReaderReady(reader);
+          reader.readAsText(blob);
+          return promise
+        }
+
+        function readArrayBufferAsText(buf) {
+          var view = new Uint8Array(buf);
+          var chars = new Array(view.length);
+
+          for (var i = 0; i < view.length; i++) {
+            chars[i] = String.fromCharCode(view[i]);
+          }
+          return chars.join('')
+        }
+
+        function bufferClone(buf) {
+          if (buf.slice) {
+            return buf.slice(0)
+          } else {
+            var view = new Uint8Array(buf.byteLength);
+            view.set(new Uint8Array(buf));
+            return view.buffer
+          }
+        }
+
+        function Body() {
+          this.bodyUsed = false;
+
+          this._initBody = function(body) {
+            /*
+              fetch-mock wraps the Response object in an ES6 Proxy to
+              provide useful test harness features such as flush. However, on
+              ES5 browsers without fetch or Proxy support pollyfills must be used;
+              the proxy-pollyfill is unable to proxy an attribute unless it exists
+              on the object before the Proxy is created. This change ensures
+              Response.bodyUsed exists on the instance, while maintaining the
+              semantic of setting Request.bodyUsed in the constructor before
+              _initBody is called.
+            */
+            this.bodyUsed = this.bodyUsed;
+            this._bodyInit = body;
+            if (!body) {
+              this._bodyText = '';
+            } else if (typeof body === 'string') {
+              this._bodyText = body;
+            } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+              this._bodyBlob = body;
+            } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+              this._bodyFormData = body;
+            } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+              this._bodyText = body.toString();
+            } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+              this._bodyArrayBuffer = bufferClone(body.buffer);
+              // IE 10-11 can't handle a DataView body.
+              this._bodyInit = new Blob([this._bodyArrayBuffer]);
+            } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+              this._bodyArrayBuffer = bufferClone(body);
+            } else {
+              this._bodyText = body = Object.prototype.toString.call(body);
+            }
+
+            if (!this.headers.get('content-type')) {
+              if (typeof body === 'string') {
+                this.headers.set('content-type', 'text/plain;charset=UTF-8');
+              } else if (this._bodyBlob && this._bodyBlob.type) {
+                this.headers.set('content-type', this._bodyBlob.type);
+              } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+                this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
+              }
+            }
+          };
+
+          if (support.blob) {
+            this.blob = function() {
+              var rejected = consumed(this);
+              if (rejected) {
+                return rejected
+              }
+
+              if (this._bodyBlob) {
+                return Promise.resolve(this._bodyBlob)
+              } else if (this._bodyArrayBuffer) {
+                return Promise.resolve(new Blob([this._bodyArrayBuffer]))
+              } else if (this._bodyFormData) {
+                throw new Error('could not read FormData body as blob')
+              } else {
+                return Promise.resolve(new Blob([this._bodyText]))
+              }
+            };
+
+            this.arrayBuffer = function() {
+              if (this._bodyArrayBuffer) {
+                var isConsumed = consumed(this);
+                if (isConsumed) {
+                  return isConsumed
+                }
+                if (ArrayBuffer.isView(this._bodyArrayBuffer)) {
+                  return Promise.resolve(
+                    this._bodyArrayBuffer.buffer.slice(
+                      this._bodyArrayBuffer.byteOffset,
+                      this._bodyArrayBuffer.byteOffset + this._bodyArrayBuffer.byteLength
+                    )
+                  )
+                } else {
+                  return Promise.resolve(this._bodyArrayBuffer)
+                }
+              } else {
+                return this.blob().then(readBlobAsArrayBuffer)
+              }
+            };
+          }
+
+          this.text = function() {
+            var rejected = consumed(this);
+            if (rejected) {
+              return rejected
+            }
+
+            if (this._bodyBlob) {
+              return readBlobAsText(this._bodyBlob)
+            } else if (this._bodyArrayBuffer) {
+              return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
+            } else if (this._bodyFormData) {
+              throw new Error('could not read FormData body as text')
+            } else {
+              return Promise.resolve(this._bodyText)
+            }
+          };
+
+          if (support.formData) {
+            this.formData = function() {
+              return this.text().then(decode)
+            };
+          }
+
+          this.json = function() {
+            return this.text().then(JSON.parse)
+          };
+
+          return this
+        }
+
+        // HTTP methods whose capitalization should be normalized
+        var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];
+
+        function normalizeMethod(method) {
+          var upcased = method.toUpperCase();
+          return methods.indexOf(upcased) > -1 ? upcased : method
+        }
+
+        function Request(input, options) {
+          if (!(this instanceof Request)) {
+            throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
+          }
+
+          options = options || {};
+          var body = options.body;
+
+          if (input instanceof Request) {
+            if (input.bodyUsed) {
+              throw new TypeError('Already read')
+            }
+            this.url = input.url;
+            this.credentials = input.credentials;
+            if (!options.headers) {
+              this.headers = new Headers(input.headers);
+            }
+            this.method = input.method;
+            this.mode = input.mode;
+            this.signal = input.signal;
+            if (!body && input._bodyInit != null) {
+              body = input._bodyInit;
+              input.bodyUsed = true;
+            }
+          } else {
+            this.url = String(input);
+          }
+
+          this.credentials = options.credentials || this.credentials || 'same-origin';
+          if (options.headers || !this.headers) {
+            this.headers = new Headers(options.headers);
+          }
+          this.method = normalizeMethod(options.method || this.method || 'GET');
+          this.mode = options.mode || this.mode || null;
+          this.signal = options.signal || this.signal;
+          this.referrer = null;
+
+          if ((this.method === 'GET' || this.method === 'HEAD') && body) {
+            throw new TypeError('Body not allowed for GET or HEAD requests')
+          }
+          this._initBody(body);
+
+          if (this.method === 'GET' || this.method === 'HEAD') {
+            if (options.cache === 'no-store' || options.cache === 'no-cache') {
+              // Search for a '_' parameter in the query string
+              var reParamSearch = /([?&])_=[^&]*/;
+              if (reParamSearch.test(this.url)) {
+                // If it already exists then set the value with the current time
+                this.url = this.url.replace(reParamSearch, '$1_=' + new Date().getTime());
+              } else {
+                // Otherwise add a new '_' parameter to the end with the current time
+                var reQueryString = /\?/;
+                this.url += (reQueryString.test(this.url) ? '&' : '?') + '_=' + new Date().getTime();
+              }
+            }
+          }
+        }
+
+        Request.prototype.clone = function() {
+          return new Request(this, {body: this._bodyInit})
+        };
+
+        function decode(body) {
+          var form = new FormData();
+          body
+            .trim()
+            .split('&')
+            .forEach(function(bytes) {
+              if (bytes) {
+                var split = bytes.split('=');
+                var name = split.shift().replace(/\+/g, ' ');
+                var value = split.join('=').replace(/\+/g, ' ');
+                form.append(decodeURIComponent(name), decodeURIComponent(value));
+              }
+            });
+          return form
+        }
+
+        function parseHeaders(rawHeaders) {
+          var headers = new Headers();
+          // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space
+          // https://tools.ietf.org/html/rfc7230#section-3.2
+          var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
+          // Avoiding split via regex to work around a common IE11 bug with the core-js 3.6.0 regex polyfill
+          // https://github.com/github/fetch/issues/748
+          // https://github.com/zloirock/core-js/issues/751
+          preProcessedHeaders
+            .split('\r')
+            .map(function(header) {
+              return header.indexOf('\n') === 0 ? header.substr(1, header.length) : header
+            })
+            .forEach(function(line) {
+              var parts = line.split(':');
+              var key = parts.shift().trim();
+              if (key) {
+                var value = parts.join(':').trim();
+                headers.append(key, value);
+              }
+            });
+          return headers
+        }
+
+        Body.call(Request.prototype);
+
+        function Response(bodyInit, options) {
+          if (!(this instanceof Response)) {
+            throw new TypeError('Please use the "new" operator, this DOM object constructor cannot be called as a function.')
+          }
+          if (!options) {
+            options = {};
+          }
+
+          this.type = 'default';
+          this.status = options.status === undefined ? 200 : options.status;
+          this.ok = this.status >= 200 && this.status < 300;
+          this.statusText = 'statusText' in options ? options.statusText : '';
+          this.headers = new Headers(options.headers);
+          this.url = options.url || '';
+          this._initBody(bodyInit);
+        }
+
+        Body.call(Response.prototype);
+
+        Response.prototype.clone = function() {
+          return new Response(this._bodyInit, {
+            status: this.status,
+            statusText: this.statusText,
+            headers: new Headers(this.headers),
+            url: this.url
+          })
+        };
+
+        Response.error = function() {
+          var response = new Response(null, {status: 0, statusText: ''});
+          response.type = 'error';
+          return response
+        };
+
+        var redirectStatuses = [301, 302, 303, 307, 308];
+
+        Response.redirect = function(url, status) {
+          if (redirectStatuses.indexOf(status) === -1) {
+            throw new RangeError('Invalid status code')
+          }
+
+          return new Response(null, {status: status, headers: {location: url}})
+        };
+
+        exports.DOMException = global.DOMException;
+        try {
+          new exports.DOMException();
+        } catch (err) {
+          exports.DOMException = function(message, name) {
+            this.message = message;
+            this.name = name;
+            var error = Error(message);
+            this.stack = error.stack;
+          };
+          exports.DOMException.prototype = Object.create(Error.prototype);
+          exports.DOMException.prototype.constructor = exports.DOMException;
+        }
+
+        function fetch(input, init) {
+          return new Promise(function(resolve, reject) {
+            var request = new Request(input, init);
+
+            if (request.signal && request.signal.aborted) {
+              return reject(new exports.DOMException('Aborted', 'AbortError'))
+            }
+
+            var xhr = new XMLHttpRequest();
+
+            function abortXhr() {
+              xhr.abort();
+            }
+
+            xhr.onload = function() {
+              var options = {
+                status: xhr.status,
+                statusText: xhr.statusText,
+                headers: parseHeaders(xhr.getAllResponseHeaders() || '')
+              };
+              options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
+              var body = 'response' in xhr ? xhr.response : xhr.responseText;
+              setTimeout(function() {
+                resolve(new Response(body, options));
+              }, 0);
+            };
+
+            xhr.onerror = function() {
+              setTimeout(function() {
+                reject(new TypeError('Network request failed'));
+              }, 0);
+            };
+
+            xhr.ontimeout = function() {
+              setTimeout(function() {
+                reject(new TypeError('Network request failed'));
+              }, 0);
+            };
+
+            xhr.onabort = function() {
+              setTimeout(function() {
+                reject(new exports.DOMException('Aborted', 'AbortError'));
+              }, 0);
+            };
+
+            function fixUrl(url) {
+              try {
+                return url === '' && global.location.href ? global.location.href : url
+              } catch (e) {
+                return url
+              }
+            }
+
+            xhr.open(request.method, fixUrl(request.url), true);
+
+            if (request.credentials === 'include') {
+              xhr.withCredentials = true;
+            } else if (request.credentials === 'omit') {
+              xhr.withCredentials = false;
+            }
+
+            if ('responseType' in xhr) {
+              if (support.blob) {
+                xhr.responseType = 'blob';
+              } else if (
+                support.arrayBuffer &&
+                request.headers.get('Content-Type') &&
+                request.headers.get('Content-Type').indexOf('application/octet-stream') !== -1
+              ) {
+                xhr.responseType = 'arraybuffer';
+              }
+            }
+
+            if (init && typeof init.headers === 'object' && !(init.headers instanceof Headers)) {
+              Object.getOwnPropertyNames(init.headers).forEach(function(name) {
+                xhr.setRequestHeader(name, normalizeValue(init.headers[name]));
+              });
+            } else {
+              request.headers.forEach(function(value, name) {
+                xhr.setRequestHeader(name, value);
+              });
+            }
+
+            if (request.signal) {
+              request.signal.addEventListener('abort', abortXhr);
+
+              xhr.onreadystatechange = function() {
+                // DONE (success or failure)
+                if (xhr.readyState === 4) {
+                  request.signal.removeEventListener('abort', abortXhr);
+                }
+              };
+            }
+
+            xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
+          })
+        }
+
+        fetch.polyfill = true;
+
+        if (!global.fetch) {
+          global.fetch = fetch;
+          global.Headers = Headers;
+          global.Request = Request;
+          global.Response = Response;
+        }
+
+        exports.Headers = Headers;
+        exports.Request = Request;
+        exports.Response = Response;
+        exports.fetch = fetch;
+
+        Object.defineProperty(exports, '__esModule', { value: true });
+
+      })));
+
+
+      return {
+        fetch: globalThis.fetch,
+        Headers: globalThis.Headers,
+        Request: globalThis.Request,
+        Response: globalThis.Response,
+        DOMException: globalThis.DOMException
+      };
+    }());
+  }
+
+  if (typeof define === 'function' && define.amd) {
+    define(function () {
+      return fetchPonyfill;
+    });
+  } else if (typeof exports === 'object') {
+    module.exports = fetchPonyfill;
+  } else {
+    global.fetchPonyfill = fetchPonyfill;
+  }
+}(typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : typeof global !== 'undefined' ? global : this));
+

modules/MMM-PublicTransportHafas/node_modules/fetch-ponyfill/fetch-node.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var fetch = require('node-fetch');
+
+function wrapFetchForNode(fetch) {
+  // Support schemaless URIs on the server for parity with the browser.
+  // https://github.com/matthew-andrews/isomorphic-fetch/pull/10
+  return function (u, options) {
+    if (typeof u === 'string' && u.slice(0, 2) === '//') {
+      return fetch('https:' + u, options);
+    }
+
+    return fetch(u, options);
+  };
+}
+
+module.exports = function (context) {
+  // Support webpack module import weirdness.
+  var fetchFn = fetch.default ? fetch.default : fetch;
+
+  // This modifies the global `node-fetch` object, which isn't great, since
+  // different callers to `fetch-ponyfill` which pass a different Promise
+  // implementation would each expect to have their implementation used. But,
+  // given the way `node-fetch` is implemented, this is the only way to make
+  // it work at all.
+  if (context && context.Promise) {
+    fetchFn.Promise = context.Promise;
+  }
+
+  return {
+    fetch: wrapFetchForNode(fetchFn),
+    Headers: fetch.Headers,
+    Request: fetch.Request,
+    Response: fetch.Response
+  };
+};

modules/MMM-PublicTransportHafas/node_modules/fetch-ponyfill/index.d.ts

@@ -0,0 +1,18 @@
+export = fetchPonyfill;
+
+declare function fetchPonyfill(options?: fetchPonyfill.BootstrapOptions): fetchPonyfill.BootstrapRetVal;
+
+declare namespace fetchPonyfill {
+  interface BootstrapOptions {
+    Promise?: Function;
+    XMLHttpRequest?: Function;
+  }
+
+  interface BootstrapRetVal {
+    fetch: typeof fetch;
+    Headers: typeof Headers;
+    Request: typeof Request;
+    Response: typeof Response;
+    DOMException: typeof DOMException;
+  }
+}

modules/MMM-PublicTransportHafas/node_modules/fetch-ponyfill/package.json

@@ -0,0 +1,87 @@
+{
+  "_from": "fetch-ponyfill@^7.0.0",
+  "_id": "fetch-ponyfill@7.1.0",
+  "_inBundle": false,
+  "_integrity": "sha512-FhbbL55dj/qdVO3YNK7ZEkshvj3eQ7EuIGV2I6ic/2YiocvyWv+7jg2s4AyS0wdRU75s3tA8ZxI/xPigb0v5Aw==",
+  "_location": "/fetch-ponyfill",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "fetch-ponyfill@^7.0.0",
+    "name": "fetch-ponyfill",
+    "escapedName": "fetch-ponyfill",
+    "rawSpec": "^7.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^7.0.0"
+  },
+  "_requiredBy": [
+    "/hafas-client"
+  ],
+  "_resolved": "https://registry.npmjs.org/fetch-ponyfill/-/fetch-ponyfill-7.1.0.tgz",
+  "_shasum": "4266ed48b4e64663a50ab7f7fcb8e76f990526d0",
+  "_spec": "fetch-ponyfill@^7.0.0",
+  "_where": "/home/pi/MagicMirror/modules/MMM-PublicTransportHafas/node_modules/hafas-client",
+  "author": {
+    "name": "Mark Stanley Everitt"
+  },
+  "browser": "build/fetch-browser.js",
+  "bugs": {
+    "url": "https://github.com/qubyte/fetch-ponyfill/issues"
+  },
+  "bundleDependencies": false,
+  "config": {
+    "web_port": "8088"
+  },
+  "dependencies": {
+    "node-fetch": "~2.6.1"
+  },
+  "deprecated": false,
+  "description": "A ponyfill (doesn't overwrite the native fetch) for the Fetch specification https://fetch.spec.whatwg.org.",
+  "devDependencies": {
+    "browserify": "^17.0.0",
+    "eslint": "^7.12.1",
+    "eslint-config-qubyte": "^3.0.0",
+    "mkdirp": "^1.0.4",
+    "mocha": "^8.2.0",
+    "nock": "^13.0.4",
+    "promise": "^8.1.0",
+    "rimraf": "^3.0.2",
+    "sinon": "^9.2.1",
+    "testem": "^3.2.0",
+    "webpack": "^5.3.0",
+    "webpack-cli": "^4.1.0",
+    "whatwg-fetch": "^3.5.0"
+  },
+  "files": [
+    "fetch-node.js",
+    "build/fetch-browser.js",
+    "index.d.ts"
+  ],
+  "homepage": "https://github.com/qubyte/fetch-ponyfill#readme",
+  "keywords": [
+    "fetch",
+    "ponyfill"
+  ],
+  "license": "MIT",
+  "main": "fetch-node.js",
+  "name": "fetch-ponyfill",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/qubyte/fetch-ponyfill.git"
+  },
+  "scripts": {
+    "build": "rimraf build && mkdirp build && node build.js > build/fetch-browser.js",
+    "lint": "eslint .",
+    "prepublishOnly": "npm run build",
+    "pretest:browserify": "npm run build && browserify tests/fetch-browser.spec.js --outfile build/browser-test-bundle.js",
+    "pretest:webpack": "npm run build && webpack --mode development --entry ./tests/fetch-browser.spec.js -o build/browser-test",
+    "pretest:webpack:node": "webpack --mode development --target node --entry ./tests/fetch-node.spec.js -o build/node-test",
+    "test": "mocha tests/fetch-node.spec.js",
+    "test:browserify": "testem ci",
+    "test:webpack": "testem ci",
+    "test:webpack:node": "mocha build/node-test/main.js"
+  },
+  "types": "./index.d.ts",
+  "version": "7.1.0"
+}