rdflib 2.2.22 → 2.2.23-6384f9a2

package/esm/fetcher.js

@@ -1,4 +1,13 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 /* global $SolidTestEnvironment */
 /**
  *
@@ -42,7 +51,7 @@ import crossFetch, { Headers } from 'cross-fetch';
 import { TurtleContentType, RDFXMLContentType, XHTMLContentType } from './types';
 import { termValue } from './utils/termValue';
 import jsonldParser from './jsonldparser';
-const Parsable = {
+var Parsable = {
   'text/n3': true,
   'text/turtle': true,
   'application/rdf+xml': true,
@@ -52,7 +61,7 @@ const Parsable = {
 };
 
 // This is a minimal set to allow the use of damaged servers if necessary
-const CONTENT_TYPE_BY_EXT = {
+var CONTENT_TYPE_BY_EXT = {
   'rdf': RDFXMLContentType,
   'owl': RDFXMLContentType,
   'n3': 'text/n3',
@@ -68,7 +77,7 @@ const CONTENT_TYPE_BY_EXT = {
 // make its own list and not rely on the prefixes used here,
 // and not be tempted to add to them, and them clash with those of another
 // application.
-const getNS = factory => {
+var getNS = function getNS(factory) {
   return {
     link: Namespace('http://www.w3.org/2007/ont/link#', factory),
     http: Namespace('http://www.w3.org/2007/ont/http#', factory),
@@ -80,349 +89,448 @@ const getNS = factory => {
     ldp: Namespace('http://www.w3.org/ns/ldp#', factory)
   };
 };
-const ns = getNS();
-class Handler {
-  // TODO: Document, type
-
-  // TODO: Document, type
-
-  constructor(response, dom) {
-    _defineProperty(this, "response", void 0);
-    _defineProperty(this, "dom", void 0);
-    this.response = response;
-    // The type assertion operator here might need to be removed.
-    this.dom = dom;
-  }
-}
+var ns = getNS();
+var Handler = /*#__PURE__*/_createClass(
+// TODO: Document, type
+
+// TODO: Document, type
+
+function Handler(response, dom) {
+  _classCallCheck(this, Handler);
+  _defineProperty(this, "response", void 0);
+  _defineProperty(this, "dom", void 0);
+  this.response = response;
+  // The type assertion operator here might need to be removed.
+  this.dom = dom;
+});
 _defineProperty(Handler, "pattern", void 0);
-class RDFXMLHandler extends Handler {
-  static toString() {
-    return 'RDFXMLHandler';
-  }
-  static register(fetcher) {
-    fetcher.mediatypes[RDFXMLContentType] = {
-      'q': 0.9
-    };
-  }
-  parse(fetcher, /** An XML String */
-  responseText, /** Requires .original */
-  options) {
-    let kb = fetcher.store;
-    if (!this.dom) {
-      this.dom = Util.parseXML(responseText);
-    }
-    let root = this.dom.documentElement;
-    if (root.nodeName === 'parsererror') {
-      // Mozilla only See issue/issue110
-      // have to fail the request
-      return fetcher.failFetch(options, 'Badly formed XML in ' + options.resource.value, 'parse_error');
-    }
-    let parser = new RDFParser(kb);
-    try {
-      parser.parse(this.dom, options.original.value, options.original);
-    } catch (err) {
-      return fetcher.failFetch(options, 'Syntax error parsing RDF/XML! ' + err, 'parse_error');
-    }
-    if (!options.noMeta) {
-      kb.add(options.original, ns.rdf('type'), ns.link('RDFDocument'), fetcher.appNode);
-    }
-    return fetcher.doneFetch(options, this.response);
-  }
-}
-RDFXMLHandler.pattern = new RegExp('application/rdf\\+xml');
-class XHTMLHandler extends Handler {
-  static toString() {
-    return 'XHTMLHandler';
-  }
-  static register(fetcher) {
-    fetcher.mediatypes[XHTMLContentType] = {};
-  }
-  parse(fetcher, responseText, options) {
-    let relation, reverse;
-    if (!this.dom) {
-      this.dom = Util.parseXML(responseText);
+var RDFXMLHandler = /*#__PURE__*/function (_Handler) {
+  _inherits(RDFXMLHandler, _Handler);
+  var _super = _createSuper(RDFXMLHandler);
+  function RDFXMLHandler() {
+    _classCallCheck(this, RDFXMLHandler);
+    return _super.apply(this, arguments);
+  }
+  _createClass(RDFXMLHandler, [{
+    key: "parse",
+    value: function parse(fetcher, /** An XML String */
+    responseText, /** Requires .original */
+    options) {
+      var kb = fetcher.store;
+      if (!this.dom) {
+        this.dom = Util.parseXML(responseText);
+      }
+      var root = this.dom.documentElement;
+      if (root.nodeName === 'parsererror') {
+        // Mozilla only See issue/issue110
+        // have to fail the request
+        return fetcher.failFetch(options, 'Badly formed XML in ' + options.resource.value, 'parse_error');
+      }
+      var parser = new RDFParser(kb);
+      try {
+        parser.parse(this.dom, options.original.value, options.original);
+      } catch (err) {
+        return fetcher.failFetch(options, 'Syntax error parsing RDF/XML! ' + err, 'parse_error');
+      }
+      if (!options.noMeta) {
+        kb.add(options.original, ns.rdf('type'), ns.link('RDFDocument'), fetcher.appNode);
+      }
+      return fetcher.doneFetch(options, this.response);
     }
-    let kb = fetcher.store;
-
-    // dc:title
-    let title = this.dom.getElementsByTagName('title');
-    if (title.length > 0) {
-      kb.add(options.resource, ns.dc('title'), kb.rdfFactory.literal(title[0].textContent), options.resource);
-      // log.info("Inferring title of " + xhr.resource)
+  }], [{
+    key: "toString",
+    value: function toString() {
+      return 'RDFXMLHandler';
     }
+  }, {
+    key: "register",
+    value: function register(fetcher) {
+      fetcher.mediatypes[RDFXMLContentType] = {
+        'q': 0.9
+      };
+    }
+  }]);
+  return RDFXMLHandler;
+}(Handler);
+RDFXMLHandler.pattern = new RegExp('application/rdf\\+xml');
+var XHTMLHandler = /*#__PURE__*/function (_Handler2) {
+  _inherits(XHTMLHandler, _Handler2);
+  var _super2 = _createSuper(XHTMLHandler);
+  function XHTMLHandler() {
+    _classCallCheck(this, XHTMLHandler);
+    return _super2.apply(this, arguments);
+  }
+  _createClass(XHTMLHandler, [{
+    key: "parse",
+    value: function parse(fetcher, responseText, options) {
+      var relation, reverse;
+      if (!this.dom) {
+        this.dom = Util.parseXML(responseText);
+      }
+      var kb = fetcher.store;
 
-    // link rel
-    let links = this.dom.getElementsByTagName('link');
-    for (let x = links.length - 1; x >= 0; x--) {
-      // @@ rev
-      relation = links[x].getAttribute('rel');
-      reverse = false;
-      if (!relation) {
-        relation = links[x].getAttribute('rev');
-        reverse = true;
+      // dc:title
+      var title = this.dom.getElementsByTagName('title');
+      if (title.length > 0) {
+        kb.add(options.resource, ns.dc('title'), kb.rdfFactory.literal(title[0].textContent), options.resource);
+        // log.info("Inferring title of " + xhr.resource)
       }
-      if (relation) {
-        fetcher.linkData(options.original, relation, links[x].getAttribute('href'), options.resource, reverse);
+
+      // link rel
+      var links = this.dom.getElementsByTagName('link');
+      for (var x = links.length - 1; x >= 0; x--) {
+        // @@ rev
+        relation = links[x].getAttribute('rel');
+        reverse = false;
+        if (!relation) {
+          relation = links[x].getAttribute('rev');
+          reverse = true;
+        }
+        if (relation) {
+          fetcher.linkData(options.original, relation, links[x].getAttribute('href'), options.resource, reverse);
+        }
       }
-    }
 
-    // Data Islands
-    let scripts = this.dom.getElementsByTagName('script');
-    for (let i = 0; i < scripts.length; i++) {
-      let contentType = scripts[i].getAttribute('type');
-      if (Parsable[contentType]) {
-        // @ts-ignore incompatibility between Store.add and Formula.add
-        rdfParse(scripts[i].textContent, kb, options.original.value, contentType);
-        // @ts-ignore incompatibility between Store.add and Formula.add
-        rdfParse(scripts[i].textContent, kb, options.original.value, contentType);
+      // Data Islands
+      var scripts = this.dom.getElementsByTagName('script');
+      for (var i = 0; i < scripts.length; i++) {
+        var contentType = scripts[i].getAttribute('type');
+        if (Parsable[contentType]) {
+          // @ts-ignore incompatibility between Store.add and Formula.add
+          rdfParse(scripts[i].textContent, kb, options.original.value, contentType);
+          // @ts-ignore incompatibility between Store.add and Formula.add
+          rdfParse(scripts[i].textContent, kb, options.original.value, contentType);
+        }
+      }
+      if (!options.noMeta) {
+        kb.add(options.resource, ns.rdf('type'), ns.link('WebPage'), fetcher.appNode);
       }
+      if (!options.noRDFa && parseRDFaDOM) {
+        // enable by default
+        try {
+          parseRDFaDOM(this.dom, kb, options.original.value);
+        } catch (err) {
+          // @ts-ignore
+          var msg = 'Error trying to parse ' + options.resource + ' as RDFa:\n' + err + ':\n' + err.stack;
+          return fetcher.failFetch(options, msg, 'parse_error');
+        }
+      }
+      return fetcher.doneFetch(options, this.response);
     }
-    if (!options.noMeta) {
-      kb.add(options.resource, ns.rdf('type'), ns.link('WebPage'), fetcher.appNode);
+  }], [{
+    key: "toString",
+    value: function toString() {
+      return 'XHTMLHandler';
     }
-    if (!options.noRDFa && parseRDFaDOM) {
-      // enable by default
-      try {
-        parseRDFaDOM(this.dom, kb, options.original.value);
-      } catch (err) {
-        // @ts-ignore
-        let msg = 'Error trying to parse ' + options.resource + ' as RDFa:\n' + err + ':\n' + err.stack;
-        return fetcher.failFetch(options, msg, 'parse_error');
-      }
+  }, {
+    key: "register",
+    value: function register(fetcher) {
+      fetcher.mediatypes[XHTMLContentType] = {};
     }
-    return fetcher.doneFetch(options, this.response);
-  }
-}
+  }]);
+  return XHTMLHandler;
+}(Handler);
 XHTMLHandler.pattern = new RegExp('application/xhtml');
-class XMLHandler extends Handler {
-  static toString() {
-    return 'XMLHandler';
-  }
-  static register(fetcher) {
-    fetcher.mediatypes['text/xml'] = {
-      'q': 0.5
-    };
-    fetcher.mediatypes['application/xml'] = {
-      'q': 0.5
-    };
-  }
-  static isElement(node) {
-    return node.nodeType === Node.ELEMENT_NODE;
-  }
-  parse(fetcher, responseText, options) {
-    let dom = Util.parseXML(responseText);
-
-    // XML Semantics defined by root element namespace
-    // figure out the root element
-    for (let c = 0; c < dom.childNodes.length; c++) {
-      const node = dom.childNodes[c];
-      // is this node an element?
-      if (XMLHandler.isElement(node)) {
-        // We've found the first element, it's the root
-        let ns = node.namespaceURI;
-
-        // Is it RDF/XML?
-        if (ns && ns === ns['rdf']) {
-          fetcher.addStatus(options.req, 'Has XML root element in the RDF namespace, so assume RDF/XML.');
-          let rdfHandler = new RDFXMLHandler(this.response, dom);
-          return rdfHandler.parse(fetcher, responseText, options);
+var XMLHandler = /*#__PURE__*/function (_Handler3) {
+  _inherits(XMLHandler, _Handler3);
+  var _super3 = _createSuper(XMLHandler);
+  function XMLHandler() {
+    _classCallCheck(this, XMLHandler);
+    return _super3.apply(this, arguments);
+  }
+  _createClass(XMLHandler, [{
+    key: "parse",
+    value: function parse(fetcher, responseText, options) {
+      var dom = Util.parseXML(responseText);
+
+      // XML Semantics defined by root element namespace
+      // figure out the root element
+      for (var c = 0; c < dom.childNodes.length; c++) {
+        var node = dom.childNodes[c];
+        // is this node an element?
+        if (XMLHandler.isElement(node)) {
+          // We've found the first element, it's the root
+          var _ns = node.namespaceURI;
+
+          // Is it RDF/XML?
+          if (_ns && _ns === _ns['rdf']) {
+            fetcher.addStatus(options.req, 'Has XML root element in the RDF namespace, so assume RDF/XML.');
+            var rdfHandler = new RDFXMLHandler(this.response, dom);
+            return rdfHandler.parse(fetcher, responseText, options);
+          }
+          break;
         }
-        break;
       }
-    }
 
-    // Or it could be XHTML?
-    // Maybe it has an XHTML DOCTYPE?
-    if (dom.doctype) {
-      // log.info("We found a DOCTYPE in " + xhr.resource)
-      if (dom.doctype.name === 'html' && dom.doctype.publicId.match(/^-\/\/W3C\/\/DTD XHTML/) && dom.doctype.systemId.match(/http:\/\/www.w3.org\/TR\/xhtml/)) {
-        fetcher.addStatus(options.req, 'Has XHTML DOCTYPE. Switching to XHTML Handler.\n');
-        let xhtmlHandler = new XHTMLHandler(this.response, dom);
-        return xhtmlHandler.parse(fetcher, responseText, options);
+      // Or it could be XHTML?
+      // Maybe it has an XHTML DOCTYPE?
+      if (dom.doctype) {
+        // log.info("We found a DOCTYPE in " + xhr.resource)
+        if (dom.doctype.name === 'html' && dom.doctype.publicId.match(/^-\/\/W3C\/\/DTD XHTML/) && dom.doctype.systemId.match(/http:\/\/www.w3.org\/TR\/xhtml/)) {
+          fetcher.addStatus(options.req, 'Has XHTML DOCTYPE. Switching to XHTML Handler.\n');
+          var xhtmlHandler = new XHTMLHandler(this.response, dom);
+          return xhtmlHandler.parse(fetcher, responseText, options);
+        }
       }
-    }
 
-    // Or what about an XHTML namespace?
-    let html = dom.getElementsByTagName('html')[0];
-    if (html) {
-      let xmlns = html.getAttribute('xmlns');
-      if (xmlns && xmlns.match(/^http:\/\/www.w3.org\/1999\/xhtml/)) {
-        fetcher.addStatus(options.req, 'Has a default namespace for ' + 'XHTML. Switching to XHTMLHandler.\n');
-        let xhtmlHandler = new XHTMLHandler(this.response, dom);
-        return xhtmlHandler.parse(fetcher, responseText, options);
+      // Or what about an XHTML namespace?
+      var html = dom.getElementsByTagName('html')[0];
+      if (html) {
+        var xmlns = html.getAttribute('xmlns');
+        if (xmlns && xmlns.match(/^http:\/\/www.w3.org\/1999\/xhtml/)) {
+          fetcher.addStatus(options.req, 'Has a default namespace for ' + 'XHTML. Switching to XHTMLHandler.\n');
+          var _xhtmlHandler = new XHTMLHandler(this.response, dom);
+          return _xhtmlHandler.parse(fetcher, responseText, options);
+        }
       }
-    }
 
-    // At this point we should check the namespace document (cache it!) and
-    // look for a GRDDL transform
-    // @@  Get namespace document <n>, parse it, look for  <n> grddl:namespaceTransform ?y
-    // Apply ?y to   dom
-    // We give up. What dialect is this?
-    return fetcher.failFetch(options, 'Unsupported dialect of XML: not RDF or XHTML namespace, etc.\n' + responseText.slice(0, 80), 901);
-  }
-}
+      // At this point we should check the namespace document (cache it!) and
+      // look for a GRDDL transform
+      // @@  Get namespace document <n>, parse it, look for  <n> grddl:namespaceTransform ?y
+      // Apply ?y to   dom
+      // We give up. What dialect is this?
+      return fetcher.failFetch(options, 'Unsupported dialect of XML: not RDF or XHTML namespace, etc.\n' + responseText.slice(0, 80), 901);
+    }
+  }], [{
+    key: "toString",
+    value: function toString() {
+      return 'XMLHandler';
+    }
+  }, {
+    key: "register",
+    value: function register(fetcher) {
+      fetcher.mediatypes['text/xml'] = {
+        'q': 0.5
+      };
+      fetcher.mediatypes['application/xml'] = {
+        'q': 0.5
+      };
+    }
+  }, {
+    key: "isElement",
+    value: function isElement(node) {
+      return node.nodeType === Node.ELEMENT_NODE;
+    }
+  }]);
+  return XMLHandler;
+}(Handler);
 XMLHandler.pattern = new RegExp('(text|application)/(.*)xml');
-class HTMLHandler extends Handler {
-  static toString() {
-    return 'HTMLHandler';
-  }
-  static register(fetcher) {
-    fetcher.mediatypes['text/html'] = {
-      'q': 0.9
-    };
-  }
-  parse(fetcher, responseText, options) {
-    let kb = fetcher.store;
+var HTMLHandler = /*#__PURE__*/function (_Handler4) {
+  _inherits(HTMLHandler, _Handler4);
+  var _super4 = _createSuper(HTMLHandler);
+  function HTMLHandler() {
+    _classCallCheck(this, HTMLHandler);
+    return _super4.apply(this, arguments);
+  }
+  _createClass(HTMLHandler, [{
+    key: "parse",
+    value: function parse(fetcher, responseText, options) {
+      var kb = fetcher.store;
+
+      // We only handle XHTML so we have to figure out if this is XML
+      // log.info("Sniffing HTML " + xhr.resource + " for XHTML.")
+      if (isXML(responseText)) {
+        fetcher.addStatus(options.req, "Has an XML declaration. We'll assume " + "it's XHTML as the content-type was text/html.\n");
+        var xhtmlHandler = new XHTMLHandler(this.response);
+        return xhtmlHandler.parse(fetcher, responseText, options);
+      }
 
-    // We only handle XHTML so we have to figure out if this is XML
-    // log.info("Sniffing HTML " + xhr.resource + " for XHTML.")
-    if (isXML(responseText)) {
-      fetcher.addStatus(options.req, "Has an XML declaration. We'll assume " + "it's XHTML as the content-type was text/html.\n");
-      let xhtmlHandler = new XHTMLHandler(this.response);
-      return xhtmlHandler.parse(fetcher, responseText, options);
-    }
+      // DOCTYPE html
+      if (isXHTML(responseText)) {
+        fetcher.addStatus(options.req, 'Has XHTML DOCTYPE. Switching to XHTMLHandler.\n');
+        var _xhtmlHandler2 = new XHTMLHandler(this.response);
+        return _xhtmlHandler2.parse(fetcher, responseText, options);
+      }
 
-    // DOCTYPE html
-    if (isXHTML(responseText)) {
-      fetcher.addStatus(options.req, 'Has XHTML DOCTYPE. Switching to XHTMLHandler.\n');
-      let xhtmlHandler = new XHTMLHandler(this.response);
-      return xhtmlHandler.parse(fetcher, responseText, options);
-    }
+      // xmlns
+      if (isXMLNS(responseText)) {
+        fetcher.addStatus(options.req, 'Has default namespace for XHTML, so switching to XHTMLHandler.\n');
+        var _xhtmlHandler3 = new XHTMLHandler(this.response);
+        return _xhtmlHandler3.parse(fetcher, responseText, options);
+      }
 
-    // xmlns
-    if (isXMLNS(responseText)) {
-      fetcher.addStatus(options.req, 'Has default namespace for XHTML, so switching to XHTMLHandler.\n');
-      let xhtmlHandler = new XHTMLHandler(this.response);
-      return xhtmlHandler.parse(fetcher, responseText, options);
-    }
+      // dc:title
+      // no need to escape '/' here
+      var titleMatch = new RegExp('<title>([\\s\\S]+?)</title>', 'im').exec(responseText);
+      if (titleMatch) {
+        kb.add(options.resource, ns.dc('title'), kb.rdfFactory.literal(titleMatch[1]), options.resource); // think about xml:lang later
+      }
 
-    // dc:title
-    // no need to escape '/' here
-    let titleMatch = new RegExp('<title>([\\s\\S]+?)</title>', 'im').exec(responseText);
-    if (titleMatch) {
-      kb.add(options.resource, ns.dc('title'), kb.rdfFactory.literal(titleMatch[1]), options.resource); // think about xml:lang later
+      kb.add(options.resource, ns.rdf('type'), ns.link('WebPage'), fetcher.appNode);
+      fetcher.addStatus(options.req, 'non-XML HTML document, not parsed for data.');
+      return fetcher.doneFetch(options, this.response);
+    }
+  }], [{
+    key: "toString",
+    value: function toString() {
+      return 'HTMLHandler';
+    }
+  }, {
+    key: "register",
+    value: function register(fetcher) {
+      fetcher.mediatypes['text/html'] = {
+        'q': 0.9
+      };
     }
-
-    kb.add(options.resource, ns.rdf('type'), ns.link('WebPage'), fetcher.appNode);
-    fetcher.addStatus(options.req, 'non-XML HTML document, not parsed for data.');
-    return fetcher.doneFetch(options, this.response);
-  }
-}
+  }]);
+  return HTMLHandler;
+}(Handler);
 HTMLHandler.pattern = new RegExp('text/html');
-class JsonLdHandler extends Handler {
-  static toString() {
-    return 'JsonLdHandler';
-  }
-  static register(fetcher) {
-    fetcher.mediatypes['application/ld+json'] = {
-      'q': 0.9
-    };
-  }
-  parse(fetcher, responseText, options, response) {
-    const kb = fetcher.store;
-    return new Promise((resolve, reject) => {
-      try {
-        jsonldParser(responseText, kb, options.original.value, () => {
-          resolve(fetcher.doneFetch(options, response));
-        });
-      } catch (err) {
-        const msg = 'Error trying to parse ' + options.resource + ' as JSON-LD:\n' + err; // not err.stack -- irrelevant
-        resolve(fetcher.failFetch(options, msg, 'parse_error', response));
-      }
-    });
-  }
-}
+var JsonLdHandler = /*#__PURE__*/function (_Handler5) {
+  _inherits(JsonLdHandler, _Handler5);
+  var _super5 = _createSuper(JsonLdHandler);
+  function JsonLdHandler() {
+    _classCallCheck(this, JsonLdHandler);
+    return _super5.apply(this, arguments);
+  }
+  _createClass(JsonLdHandler, [{
+    key: "parse",
+    value: function parse(fetcher, responseText, options, response) {
+      var kb = fetcher.store;
+      return new Promise(function (resolve, reject) {
+        try {
+          jsonldParser(responseText, kb, options.original.value, function () {
+            resolve(fetcher.doneFetch(options, response));
+          });
+        } catch (err) {
+          var msg = 'Error trying to parse ' + options.resource + ' as JSON-LD:\n' + err; // not err.stack -- irrelevant
+          resolve(fetcher.failFetch(options, msg, 'parse_error', response));
+        }
+      });
+    }
+  }], [{
+    key: "toString",
+    value: function toString() {
+      return 'JsonLdHandler';
+    }
+  }, {
+    key: "register",
+    value: function register(fetcher) {
+      fetcher.mediatypes['application/ld+json'] = {
+        'q': 0.9
+      };
+    }
+  }]);
+  return JsonLdHandler;
+}(Handler);
 JsonLdHandler.pattern = /application\/ld\+json/;
-class TextHandler extends Handler {
-  static toString() {
-    return 'TextHandler';
-  }
-  static register(fetcher) {
-    fetcher.mediatypes['text/plain'] = {
-      'q': 0.5
-    };
-  }
-  parse(fetcher, responseText, options) {
-    // We only speak dialects of XML right now. Is this XML?
+var TextHandler = /*#__PURE__*/function (_Handler6) {
+  _inherits(TextHandler, _Handler6);
+  var _super6 = _createSuper(TextHandler);
+  function TextHandler() {
+    _classCallCheck(this, TextHandler);
+    return _super6.apply(this, arguments);
+  }
+  _createClass(TextHandler, [{
+    key: "parse",
+    value: function parse(fetcher, responseText, options) {
+      // We only speak dialects of XML right now. Is this XML?
+
+      // Look for an XML declaration
+      if (isXML(responseText)) {
+        fetcher.addStatus(options.req, 'Warning: ' + options.resource + " has an XML declaration. We'll assume " + "it's XML but its content-type wasn't XML.\n");
+        var xmlHandler = new XMLHandler(this.response);
+        return xmlHandler.parse(fetcher, responseText, options);
+      }
 
-    // Look for an XML declaration
-    if (isXML(responseText)) {
-      fetcher.addStatus(options.req, 'Warning: ' + options.resource + " has an XML declaration. We'll assume " + "it's XML but its content-type wasn't XML.\n");
-      let xmlHandler = new XMLHandler(this.response);
-      return xmlHandler.parse(fetcher, responseText, options);
-    }
+      // Look for an XML declaration
+      if (responseText.slice(0, 500).match(/xmlns:/)) {
+        fetcher.addStatus(options.req, "May have an XML namespace. We'll assume " + "it's XML but its content-type wasn't XML.\n");
+        var _xmlHandler = new XMLHandler(this.response);
+        return _xmlHandler.parse(fetcher, responseText, options);
+      }
 
-    // Look for an XML declaration
-    if (responseText.slice(0, 500).match(/xmlns:/)) {
-      fetcher.addStatus(options.req, "May have an XML namespace. We'll assume " + "it's XML but its content-type wasn't XML.\n");
-      let xmlHandler = new XMLHandler(this.response);
-      return xmlHandler.parse(fetcher, responseText, options);
+      // We give up finding semantics - this is not an error, just no data
+      fetcher.addStatus(options.req, 'Plain text document, no known RDF semantics.');
+      return fetcher.doneFetch(options, this.response);
     }
-
-    // We give up finding semantics - this is not an error, just no data
-    fetcher.addStatus(options.req, 'Plain text document, no known RDF semantics.');
-    return fetcher.doneFetch(options, this.response);
-  }
-}
+  }], [{
+    key: "toString",
+    value: function toString() {
+      return 'TextHandler';
+    }
+  }, {
+    key: "register",
+    value: function register(fetcher) {
+      fetcher.mediatypes['text/plain'] = {
+        'q': 0.5
+      };
+    }
+  }]);
+  return TextHandler;
+}(Handler);
 TextHandler.pattern = new RegExp('text/plain');
-class N3Handler extends Handler {
-  static toString() {
-    return 'N3Handler';
-  }
-  static register(fetcher) {
-    fetcher.mediatypes['text/n3'] = {
-      'q': '1.0'
-    }; // as per 2008 spec
-    /*
-     fetcher.mediatypes['application/x-turtle'] = {
-     'q': 1.0
-     } // pre 2008
-     */
-    fetcher.mediatypes['text/turtle'] = {
-      'q': 1.0
-    }; // post 2008
-  }
-
-  parse(fetcher, responseText, options, response) {
-    // Parse the text of this N3 file
-    let kb = fetcher.store;
-    let p = N3Parser(kb, kb, options.original.value, options.original.value, null, null, '', null);
-    //                p.loadBuf(xhr.responseText)
-    try {
-      p.loadBuf(responseText);
-    } catch (err) {
-      let msg = 'Error trying to parse ' + options.resource + ' as Notation3:\n' + err; // not err.stack -- irrelevant
-      return fetcher.failFetch(options, msg, 'parse_error', response);
-    }
-    fetcher.addStatus(options.req, 'N3 parsed: ' + p.statementCount + ' triples in ' + p.lines + ' lines.');
-    fetcher.store.add(options.original, ns.rdf('type'), ns.link('RDFDocument'), fetcher.appNode);
-    return fetcher.doneFetch(options, this.response);
-  }
-}
+var N3Handler = /*#__PURE__*/function (_Handler7) {
+  _inherits(N3Handler, _Handler7);
+  var _super7 = _createSuper(N3Handler);
+  function N3Handler() {
+    _classCallCheck(this, N3Handler);
+    return _super7.apply(this, arguments);
+  }
+  _createClass(N3Handler, [{
+    key: "parse",
+    value: function parse(fetcher, responseText, options, response) {
+      // Parse the text of this N3 file
+      var kb = fetcher.store;
+      var p = N3Parser(kb, kb, options.original.value, options.original.value, null, null, '', null);
+      //                p.loadBuf(xhr.responseText)
+      try {
+        p.loadBuf(responseText);
+      } catch (err) {
+        var msg = 'Error trying to parse ' + options.resource + ' as Notation3:\n' + err; // not err.stack -- irrelevant
+        return fetcher.failFetch(options, msg, 'parse_error', response);
+      }
+      fetcher.addStatus(options.req, 'N3 parsed: ' + p.statementCount + ' triples in ' + p.lines + ' lines.');
+      fetcher.store.add(options.original, ns.rdf('type'), ns.link('RDFDocument'), fetcher.appNode);
+      return fetcher.doneFetch(options, this.response);
+    }
+  }], [{
+    key: "toString",
+    value: function toString() {
+      return 'N3Handler';
+    }
+  }, {
+    key: "register",
+    value: function register(fetcher) {
+      fetcher.mediatypes['text/n3'] = {
+        'q': '1.0'
+      }; // as per 2008 spec
+      /*
+       fetcher.mediatypes['application/x-turtle'] = {
+       'q': 1.0
+       } // pre 2008
+       */
+      fetcher.mediatypes['text/turtle'] = {
+        'q': 1.0
+      }; // post 2008
+    }
+  }]);
+  return N3Handler;
+}(Handler);
 N3Handler.pattern = new RegExp('(application|text)/(x-)?(rdf\\+)?(n3|turtle)');
-const defaultHandlers = {
-  RDFXMLHandler,
-  XHTMLHandler,
-  XMLHandler,
-  HTMLHandler,
-  TextHandler,
-  N3Handler,
-  JsonLdHandler
+var defaultHandlers = {
+  RDFXMLHandler: RDFXMLHandler,
+  XHTMLHandler: XHTMLHandler,
+  XMLHandler: XMLHandler,
+  HTMLHandler: HTMLHandler,
+  TextHandler: TextHandler,
+  N3Handler: N3Handler,
+  JsonLdHandler: JsonLdHandler
 };
 function isXHTML(responseText) {
-  const docTypeStart = responseText.indexOf('<!DOCTYPE html');
-  const docTypeEnd = responseText.indexOf('>');
+  var docTypeStart = responseText.indexOf('<!DOCTYPE html');
+  var docTypeEnd = responseText.indexOf('>');
   if (docTypeStart === -1 || docTypeEnd === -1 || docTypeStart > docTypeEnd) {
     return false;
   }
   return responseText.substr(docTypeStart, docTypeEnd - docTypeStart).indexOf('XHTML') !== -1;
 }
 function isXML(responseText) {
-  const match = responseText.match(/\s*<\?xml\s+version\s*=[^<>]+\?>/);
+  var match = responseText.match(/\s*<\?xml\s+version\s*=[^<>]+\?>/);
   return !!match;
 }
 function isXMLNS(responseText) {
-  const match = responseText.match(/[^(<html)]*<html\s+[^<]*xmlns=['"]http:\/\/www.w3.org\/1999\/xhtml["'][^<]*>/);
+  var match = responseText.match(/[^(<html)]*<html\s+[^<]*xmlns=['"]http:\/\/www.w3.org\/1999\/xhtml["'][^<]*>/);
   return !!match;
 }
 /** Fetcher
@@ -433,7 +541,7 @@ function isXMLNS(responseText) {
   * figuring how to parse them.  It will also refresh, remove, the data
   * and put back the data to the web.
  */
-export default class Fetcher {
+var Fetcher = /*#__PURE__*/function () {
   /** Denoting this session */
 
   /**
@@ -462,8 +570,10 @@ export default class Fetcher {
 
   /** Methods added by calling Util.callbackify in the constructor*/
 
-  constructor(store) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  function Fetcher(store) {
+    var _this = this;
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, Fetcher);
     _defineProperty(this, "store", void 0);
     _defineProperty(this, "timeout", void 0);
     _defineProperty(this, "_fetch", void 0);
@@ -511,273 +621,255 @@ export default class Fetcher {
     //   'refresh', 'retract', 'done'])
     // In switching to fetch(), 'recv', 'headers' and 'load' do not make sense
     Util.callbackify(this, ['request', 'fail', 'refresh', 'retract', 'done']);
-    Object.keys(options.handlers || defaultHandlers).map(key => this.addHandler(defaultHandlers[key]));
-  }
-  static crossSiteProxy(uri) {
-    if (Fetcher.crossSiteProxyTemplate) {
-      return Fetcher.crossSiteProxyTemplate.replace('{uri}', encodeURIComponent(uri));
-    } else {
-      return undefined;
-    }
+    Object.keys(options.handlers || defaultHandlers).map(function (key) {
+      return _this.addHandler(defaultHandlers[key]);
+    });
   }
-  static offlineOverride(uri) {
-    // Map the URI to a localhost proxy if we are running on localhost
-    // This is used for working offline, e.g. on planes.
-    // Is the script itself is running in localhost, then access all
-    //   data in a localhost mirror.
-    // Do not remove without checking with TimBL
-    let requestedURI = uri;
-    var UI;
-    if (typeof window !== 'undefined' && window.panes && (UI = window.panes.UI) && UI.preferences && UI.preferences.get('offlineModeUsingLocalhost')) {
-      if (requestedURI.slice(0, 7) === 'http://' && requestedURI.slice(7, 17) !== 'localhost/') {
-        requestedURI = 'http://localhost/' + requestedURI.slice(7);
-        log.warn('Localhost kludge for offline use: actually getting <' + requestedURI + '>');
-      } else {
-        // log.warn("Localhost kludge NOT USED <" + requestedURI + ">")
+  _createClass(Fetcher, [{
+    key: "load",
+    value:
+    /**
+     * Promise-based load function
+     *
+     * Loads a web resource or resources into the store.
+     *
+     * A resource may be given as NamedNode object, or as a plain URI.
+     * an array of resources will be given, in which they will be fetched in parallel.
+     * By default, the HTTP headers are recorded also, in the same store, in a separate graph.
+     * This allows code like editable() for example to test things about the resource.
+     *
+     * @param uri {Array<RDFlibNamedNode>|Array<string>|RDFlibNamedNode|string}
+     *
+     * @param [options={}] {Object}
+     *
+     * @param [options.fetch] {Function}
+     *
+     * @param [options.referringTerm] {RDFlibNamedNode} Referring term, the resource which
+     *   referred to this (for tracking bad links)
+     *
+     * @param [options.contentType] {string} Provided content type (for writes)
+     *
+     * @param [options.forceContentType] {string} Override the incoming header to
+     *   force the data to be treated as this content-type (for reads)
+     *
+     * @param [options.force] {boolean} Load the data even if loaded before.
+     *   Also sets the `Cache-Control:` header to `no-cache`
+     *
+     * @param [options.baseURI=docuri] {Node|string} Original uri to preserve
+     *   through proxying etc (`xhr.original`).
+     *
+     * @param [options.proxyUsed] {boolean} Whether this request is a retry via
+     *   a proxy (generally done from an error handler)
+     *
+     * @param [options.withCredentials] {boolean} flag for XHR/CORS etc
+     *
+     * @param [options.clearPreviousData] {boolean} Before we parse new data,
+     *   clear old, but only on status 200 responses
+     *
+     * @param [options.noMeta] {boolean} Prevents the addition of various metadata
+     *   triples (about the fetch request) to the store
+     *
+     * @param [options.noRDFa] {boolean}
+     *
+     * @returns {Promise<Result>}
+     */
+    function load(uri) {
+      var _this2 = this;
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      options = Object.assign({}, options); // Take a copy as we add stuff to the options!!
+      if (uri instanceof Array) {
+        return Promise.all(uri.map(function (x) {
+          return _this2.load(x, Object.assign({}, options));
+        }));
       }
-    } else {
-      // log.warn("Localhost kludge OFF offline use: actually getting <" +
-      //   requestedURI + ">")
-    }
-    return requestedURI;
-  }
-  static proxyIfNecessary(uri) {
-    var UI;
-    if (typeof window !== 'undefined' && window.panes && (UI = window.panes.UI) && UI.isExtension) {
-      return uri;
-    } // Extension does not need proxy
-
-    if (typeof $SolidTestEnvironment !== 'undefined' && $SolidTestEnvironment.localSiteMap) {
-      // nested dictionaries of URI parts from origin down
-      let hostpath = uri.split('/').slice(2); // the bit after the //
-
-      const lookup = (parts, index) => {
-        let z = index[parts.shift()];
-        if (!z) {
-          return null;
-        }
-        if (typeof z === 'string') {
-          return z + parts.join('/');
-        }
-        if (!parts) {
-          return null;
+      var uriIn = uri;
+      var docuri = termValue(uriIn);
+      docuri = docuri.split('#')[0];
+      options = this.initFetchOptions(docuri, options);
+      var initialisedOptions = this.initFetchOptions(docuri, options);
+      return this.pendingFetchPromise(docuri, initialisedOptions.baseURI, initialisedOptions);
+    }
+  }, {
+    key: "pendingFetchPromise",
+    value: function () {
+      var _pendingFetchPromise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(uri, originalUri, options) {
+        var _this3 = this;
+        var pendingPromise;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.t0 = !options.force;
+              if (!_context.t0) {
+                _context.next = 5;
+                break;
+              }
+              _context.next = 4;
+              return this.fetchQueue[originalUri];
+            case 4:
+              _context.t0 = _context.sent;
+            case 5:
+              if (!_context.t0) {
+                _context.next = 9;
+                break;
+              }
+              pendingPromise = this.fetchQueue[originalUri];
+              _context.next = 12;
+              break;
+            case 9:
+              pendingPromise = Promise.race([this.setRequestTimeout(uri, options), this.fetchUri(uri, options)]);
+              this.fetchQueue[originalUri] = pendingPromise;
+
+              // Clean up the queued promise after a time, if it's resolved
+              this.cleanupFetchRequest(originalUri, undefined, this.timeout);
+            case 12:
+              return _context.abrupt("return", pendingPromise.then(function (x) {
+                if (uri in _this3.timeouts) {
+                  _this3.timeouts[uri].forEach(clearTimeout);
+                  delete _this3.timeouts[uri];
+                }
+                return x;
+              }));
+            case 13:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function pendingFetchPromise(_x, _x2, _x3) {
+        return _pendingFetchPromise.apply(this, arguments);
+      }
+      return pendingFetchPromise;
+    }()
+    /**
+     * @param _options - DEPRECATED
+     */
+  }, {
+    key: "cleanupFetchRequest",
+    value: function cleanupFetchRequest(originalUri, _options, timeout) {
+      var _this4 = this;
+      if (_options !== undefined) {
+        console.warn("_options is deprecated");
+      }
+      this.timeouts[originalUri] = (this.timeouts[originalUri] || []).concat(setTimeout(function () {
+        if (!_this4.isPending(originalUri)) {
+          delete _this4.fetchQueue[originalUri];
         }
-        return lookup(parts, z);
-      };
-      const y = lookup(hostpath, $SolidTestEnvironment.localSiteMap);
-      if (y) {
-        return y;
+      }, timeout));
+    }
+  }, {
+    key: "initFetchOptions",
+    value: function initFetchOptions(uri, options) {
+      var kb = this.store;
+      var isGet = !options.method || options.method.toUpperCase() === 'GET';
+      if (!isGet) {
+        options.force = true;
       }
-    }
-
-    // browser does 2014 on as https browser script not trusted
-    // If the web app origin is https: then the mixed content rules
-    // prevent it loading insecure http: stuff so we need proxy.
-    if (Fetcher.crossSiteProxyTemplate && typeof document !== 'undefined' && document.location && ('' + document.location).slice(0, 6) === 'https:' &&
-    // origin is secure
-    uri.slice(0, 5) === 'http:') {
-      // requested data is not
-      return Fetcher.crossSiteProxyTemplate.replace('{uri}', encodeURIComponent(uri));
-    }
-    return uri;
-  }
-
-  /**
-   * Tests whether the uri's protocol is supported by the Fetcher.
-   * @param uri
-   */
-  static unsupportedProtocol(uri) {
-    let pcol = Uri.protocol(uri);
-    return pcol === 'tel' || pcol === 'mailto' || pcol === 'urn';
-  }
-
-  /** Decide on credentials using old XXHR api or new fetch()  one
-   * @param requestedURI
-   * @param options
-   */
-  static setCredentials(requestedURI) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    // 2014 CORS problem:
-    // XMLHttpRequest cannot load http://www.w3.org/People/Berners-Lee/card.
-    // A wildcard '*' cannot be used in the 'Access-Control-Allow-Origin'
-    //   header when the credentials flag is true.
-    // @ Many ontology files under http: and need CORS wildcard ->
-    //   can't have credentials
-    if (options.credentials === undefined) {
-      // Caller using new fetch convention
-      if (options.withCredentials !== undefined) {
-        // XHR style is what Fetcher specified before
-        options.credentials = options.withCredentials ? 'include' : 'omit';
-      } else {
-        options.credentials = 'include'; // default is to be logged on
+      options.resource = kb.rdfFactory.namedNode(uri); // This might be proxified
+      options.baseURI = options.baseURI || uri; // Preserve though proxying etc
+      options.original = kb.rdfFactory.namedNode(options.baseURI);
+      options.req = kb.bnode();
+      options.headers = options.headers || new Headers();
+      if (options.contentType) {
+        // @ts-ignore
+        options.headers['content-type'] = options.contentType;
       }
+      if (options.force) {
+        options.cache = 'no-cache';
+      }
+      var acceptString = this.acceptString();
+      // @ts-ignore
+      options.headers['accept'] = acceptString;
+      var requestedURI = Fetcher.offlineOverride(uri);
+      options.requestedURI = requestedURI;
+      Fetcher.setCredentials(requestedURI, options);
+      var actualProxyURI = Fetcher.proxyIfNecessary(requestedURI);
+      if (requestedURI !== actualProxyURI) {
+        options.proxyUsed = true;
+      }
+      options.actualProxyURI = actualProxyURI;
+      return options;
     }
-  }
-
-  /**
-   * Promise-based load function
-   *
-   * Loads a web resource or resources into the store.
-   *
-   * A resource may be given as NamedNode object, or as a plain URI.
-   * an array of resources will be given, in which they will be fetched in parallel.
-   * By default, the HTTP headers are recorded also, in the same store, in a separate graph.
-   * This allows code like editable() for example to test things about the resource.
-   *
-   * @param uri {Array<RDFlibNamedNode>|Array<string>|RDFlibNamedNode|string}
-   *
-   * @param [options={}] {Object}
-   *
-   * @param [options.fetch] {Function}
-   *
-   * @param [options.referringTerm] {RDFlibNamedNode} Referring term, the resource which
-   *   referred to this (for tracking bad links)
-   *
-   * @param [options.contentType] {string} Provided content type (for writes)
-   *
-   * @param [options.forceContentType] {string} Override the incoming header to
-   *   force the data to be treated as this content-type (for reads)
-   *
-   * @param [options.force] {boolean} Load the data even if loaded before.
-   *   Also sets the `Cache-Control:` header to `no-cache`
-   *
-   * @param [options.baseURI=docuri] {Node|string} Original uri to preserve
-   *   through proxying etc (`xhr.original`).
-   *
-   * @param [options.proxyUsed] {boolean} Whether this request is a retry via
-   *   a proxy (generally done from an error handler)
-   *
-   * @param [options.withCredentials] {boolean} flag for XHR/CORS etc
-   *
-   * @param [options.clearPreviousData] {boolean} Before we parse new data,
-   *   clear old, but only on status 200 responses
-   *
-   * @param [options.noMeta] {boolean} Prevents the addition of various metadata
-   *   triples (about the fetch request) to the store
-   *
-   * @param [options.noRDFa] {boolean}
-   *
-   * @returns {Promise<Result>}
-   */
-  load(uri) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    options = Object.assign({}, options); // Take a copy as we add stuff to the options!!
-    if (uri instanceof Array) {
-      return Promise.all(uri.map(x => {
-        return this.load(x, Object.assign({}, options));
-      }));
-    }
-    const uriIn = uri;
-    let docuri = termValue(uriIn);
-    docuri = docuri.split('#')[0];
-    options = this.initFetchOptions(docuri, options);
-    const initialisedOptions = this.initFetchOptions(docuri, options);
-    return this.pendingFetchPromise(docuri, initialisedOptions.baseURI, initialisedOptions);
-  }
-  async pendingFetchPromise(uri, originalUri, options) {
-    let pendingPromise;
-
-    // Check to see if some request is already dealing with this uri
-    if (!options.force && (await this.fetchQueue[originalUri])) {
-      pendingPromise = this.fetchQueue[originalUri];
-    } else {
-      pendingPromise = Promise.race([this.setRequestTimeout(uri, options), this.fetchUri(uri, options)]);
-      this.fetchQueue[originalUri] = pendingPromise;
 
-      // Clean up the queued promise after a time, if it's resolved
-      this.cleanupFetchRequest(originalUri, undefined, this.timeout);
-    }
-    return pendingPromise.then(x => {
-      if (uri in this.timeouts) {
-        this.timeouts[uri].forEach(clearTimeout);
-        delete this.timeouts[uri];
+    /**
+     * (The promise chain ends in either a `failFetch()` or a `doneFetch()`)
+     *
+     * @param docuri {string}
+     * @param options {Object}
+     *
+     * @returns {Promise<Object>} fetch() result or an { error, status } object
+     */
+  }, {
+    key: "fetchUri",
+    value: function fetchUri(docuri, options) {
+      var _this5 = this;
+      if (!docuri) {
+        return Promise.reject(new Error('Cannot fetch an empty uri'));
       }
-      return x;
-    });
-  }
-
-  /**
-   * @param _options - DEPRECATED
-   */
-  cleanupFetchRequest(originalUri, _options, timeout) {
-    if (_options !== undefined) {
-      console.warn("_options is deprecated");
-    }
-    this.timeouts[originalUri] = (this.timeouts[originalUri] || []).concat(setTimeout(() => {
-      if (!this.isPending(originalUri)) {
-        delete this.fetchQueue[originalUri];
+      if (Fetcher.unsupportedProtocol(docuri)) {
+        return this.failFetch(options, 'fetcher: Unsupported protocol', 'unsupported_protocol');
       }
-    }, timeout));
-  }
-  initFetchOptions(uri, options) {
-    let kb = this.store;
-    let isGet = !options.method || options.method.toUpperCase() === 'GET';
-    if (!isGet) {
-      options.force = true;
-    }
-    options.resource = kb.rdfFactory.namedNode(uri); // This might be proxified
-    options.baseURI = options.baseURI || uri; // Preserve though proxying etc
-    options.original = kb.rdfFactory.namedNode(options.baseURI);
-    options.req = kb.bnode();
-    options.headers = options.headers || new Headers();
-    if (options.contentType) {
-      // @ts-ignore
-      options.headers['content-type'] = options.contentType;
-    }
-    if (options.force) {
-      options.cache = 'no-cache';
-    }
-    let acceptString = this.acceptString();
-    // @ts-ignore
-    options.headers['accept'] = acceptString;
-    let requestedURI = Fetcher.offlineOverride(uri);
-    options.requestedURI = requestedURI;
-    Fetcher.setCredentials(requestedURI, options);
-    let actualProxyURI = Fetcher.proxyIfNecessary(requestedURI);
-    if (requestedURI !== actualProxyURI) {
-      options.proxyUsed = true;
-    }
-    options.actualProxyURI = actualProxyURI;
-    return options;
-  }
+      var state = this.getState(docuri);
+      if (!options.force) {
+        if (state === 'fetched') {
+          // URI already fetched and added to store
+          return Promise.resolve(
+          // @ts-ignore This is not a valid response object
+          this.doneFetch(options, {
+            status: 200,
+            ok: true,
+            statusText: 'Already loaded into quadstore.'
+          }));
+        }
+        if (state === 'failed' && this.requested[docuri] === 404) {
+          // Remember nonexistence
+          var _message = 'Previously failed: ' + this.requested[docuri];
+          // @ts-ignore This is not a valid response object
+          var dummyResponse = {
+            url: docuri,
+            // This does not comply to Fetch spec, it can be a string value in rdflib
+            status: this.requested[docuri],
+            statusText: _message,
+            responseText: _message,
+            headers: new Headers(),
+            // Headers() ???
+            ok: false,
+            body: null,
+            bodyUsed: false,
+            size: 0,
+            timeout: 0
+          };
+          return this.failFetch(options, _message, this.requested[docuri], dummyResponse);
+        }
+      } else {
+        // options.force == true
+        delete this.nonexistent[docuri];
+      }
+      this.fireCallbacks('request', [docuri]);
+      this.requested[docuri] = true; // mark this uri as 'requested'
 
-  /**
-   * (The promise chain ends in either a `failFetch()` or a `doneFetch()`)
-   *
-   * @param docuri {string}
-   * @param options {Object}
-   *
-   * @returns {Promise<Object>} fetch() result or an { error, status } object
-   */
-  fetchUri(docuri, options) {
-    if (!docuri) {
-      return Promise.reject(new Error('Cannot fetch an empty uri'));
-    }
-    if (Fetcher.unsupportedProtocol(docuri)) {
-      return this.failFetch(options, 'fetcher: Unsupported protocol', 'unsupported_protocol');
-    }
-    let state = this.getState(docuri);
-    if (!options.force) {
-      if (state === 'fetched') {
-        // URI already fetched and added to store
-        return Promise.resolve(
-        // @ts-ignore This is not a valid response object
-        this.doneFetch(options, {
-          status: 200,
-          ok: true,
-          statusText: 'Already loaded into quadstore.'
-        }));
+      if (!options.noMeta) {
+        this.saveRequestMetadata(docuri, options);
       }
-      if (state === 'failed' && this.requested[docuri] === 404) {
-        // Remember nonexistence
-        let message = 'Previously failed: ' + this.requested[docuri];
-        // @ts-ignore This is not a valid response object
-        let dummyResponse = {
-          url: docuri,
-          // This does not comply to Fetch spec, it can be a string value in rdflib
-          status: this.requested[docuri],
-          statusText: message,
-          responseText: message,
+      var actualProxyURI = options.actualProxyURI;
+
+      // Map might get mistakenly added into headers
+      // error TS2339: Property 'map' does not exist on type 'Headers'.
+      /* let map
+      if (options.headers && map in options.headers) {
+        delete options.headers.map
+      } */
+
+      return this._fetch(actualProxyURI, options).then(function (response) {
+        return _this5.handleResponse(response, docuri, options);
+      }, function (error) {
+        // @@ handleError?
+        // @ts-ignore Invalid response object
+        var dummyResponse = {
+          url: actualProxyURI,
+          status: 999,
+          // @@ what number/string should fetch failures report?
+          statusText: (error.name || 'network failure') + ': ' + (error.errno || error.code || error.type),
+          responseText: error.message,
           headers: new Headers(),
           // Headers() ???
           ok: false,
@@ -786,888 +878,1085 @@ export default class Fetcher {
           size: 0,
           timeout: 0
         };
-        return this.failFetch(options, message, this.requested[docuri], dummyResponse);
-      }
-    } else {
-      // options.force == true
-      delete this.nonexistent[docuri];
-    }
-    this.fireCallbacks('request', [docuri]);
-    this.requested[docuri] = true; // mark this uri as 'requested'
-
-    if (!options.noMeta) {
-      this.saveRequestMetadata(docuri, options);
-    }
-    let {
-      actualProxyURI
-    } = options;
-
-    // Map might get mistakenly added into headers
-    // error TS2339: Property 'map' does not exist on type 'Headers'.
-    /* let map
-    if (options.headers && map in options.headers) {
-      delete options.headers.map
-    } */
-
-    return this._fetch(actualProxyURI, options).then(response => this.handleResponse(response, docuri, options), error => {
-      // @@ handleError?
-      // @ts-ignore Invalid response object
-      let dummyResponse = {
-        url: actualProxyURI,
-        status: 999,
-        // @@ what number/string should fetch failures report?
-        statusText: (error.name || 'network failure') + ': ' + (error.errno || error.code || error.type),
-        responseText: error.message,
-        headers: new Headers(),
-        // Headers() ???
-        ok: false,
-        body: null,
-        bodyUsed: false,
-        size: 0,
-        timeout: 0
-      };
-      console.log('Fetcher: <' + actualProxyURI + '> Non-HTTP fetch exception: ' + error);
-      return this.handleError(dummyResponse, docuri, options); // possible credentials retry
-      // return this.failFetch(options, 'fetch failed: ' + error, 999, dummyResponse) // Fake status code: fetch exception
-
-      // handleError expects a response so we fake some important bits.
-      /*
-      this.handleError(, docuri, options)
-      */
-    });
-  }
+        console.log('Fetcher: <' + actualProxyURI + '> Non-HTTP fetch exception: ' + error);
+        return _this5.handleError(dummyResponse, docuri, options); // possible credentials retry
+        // return this.failFetch(options, 'fetch failed: ' + error, 999, dummyResponse) // Fake status code: fetch exception
+
+        // handleError expects a response so we fake some important bits.
+        /*
+        this.handleError(, docuri, options)
+        */
+      });
+    }
 
-  /**
-   * Asks for a doc to be loaded if necessary then calls back
-   *
-   * Calling methods:
-   *   nowOrWhenFetched (uri, userCallback)
-   *   nowOrWhenFetched (uri, options, userCallback)
-   *   nowOrWhenFetched (uri, referringTerm, userCallback, options)  <-- old
-   *   nowOrWhenFetched (uri, referringTerm, userCallback) <-- old
-   *
-   *  Options include:
-   *   referringTerm    The document in which this link was found.
-   *                    this is valuable when finding the source of bad URIs
-   *   force            boolean.  Never mind whether you have tried before,
-   *                    load this from scratch.
-   *   forceContentType Override the incoming header to force the data to be
-   *                    treated as this content-type.
-   *
-   *  Callback function takes:
-   *
-   *    ok               True if the fetch worked, and got a 200 response.
-   *                     False if any error happened
-   *
-   *    errmessage       Text error message if not OK.
-   *
-   *    response         The fetch Response object (was: XHR) if there was was one
-   *                     includes response.status as the HTTP status if any.
-   */
-  nowOrWhenFetched(uriIn, p2, userCallback) {
-    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-    const uri = termValue(uriIn);
-    if (typeof p2 === 'function') {
-      // nowOrWhenFetched (uri, userCallback)
-      userCallback = p2;
-    } else if (typeof p2 === 'undefined') {// original calling signature
-      // referringTerm = undefined
-    } else if (isNamedNode(p2)) {
-      // referringTerm = p2
-      options.referringTerm = p2;
-    } else {
-      // nowOrWhenFetched (uri, options, userCallback)
-      options = p2;
-    }
-    this.load(uri, options).then(fetchResponse => {
-      if (userCallback) {
-        if (fetchResponse) {
-          if (fetchResponse.ok) {
-            userCallback(true, 'OK', fetchResponse);
-          } else {
-            // console.log('@@@ fetcher.js Should not take this path !!!!!!!!!!!!')
-            let oops = 'HTTP error: Status ' + fetchResponse.status + ' (' + fetchResponse.statusText + ')';
-            if (fetchResponse.responseText) {
-              oops += ' ' + fetchResponse.responseText; // not in 404, dns error, nock failure
+    /**
+     * Asks for a doc to be loaded if necessary then calls back
+     *
+     * Calling methods:
+     *   nowOrWhenFetched (uri, userCallback)
+     *   nowOrWhenFetched (uri, options, userCallback)
+     *   nowOrWhenFetched (uri, referringTerm, userCallback, options)  <-- old
+     *   nowOrWhenFetched (uri, referringTerm, userCallback) <-- old
+     *
+     *  Options include:
+     *   referringTerm    The document in which this link was found.
+     *                    this is valuable when finding the source of bad URIs
+     *   force            boolean.  Never mind whether you have tried before,
+     *                    load this from scratch.
+     *   forceContentType Override the incoming header to force the data to be
+     *                    treated as this content-type.
+     *
+     *  Callback function takes:
+     *
+     *    ok               True if the fetch worked, and got a 200 response.
+     *                     False if any error happened
+     *
+     *    errmessage       Text error message if not OK.
+     *
+     *    response         The fetch Response object (was: XHR) if there was was one
+     *                     includes response.status as the HTTP status if any.
+     */
+  }, {
+    key: "nowOrWhenFetched",
+    value: function nowOrWhenFetched(uriIn, p2, userCallback) {
+      var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+      var uri = termValue(uriIn);
+      if (typeof p2 === 'function') {
+        // nowOrWhenFetched (uri, userCallback)
+        userCallback = p2;
+      } else if (typeof p2 === 'undefined') {// original calling signature
+        // referringTerm = undefined
+      } else if (isNamedNode(p2)) {
+        // referringTerm = p2
+        options.referringTerm = p2;
+      } else {
+        // nowOrWhenFetched (uri, options, userCallback)
+        options = p2;
+      }
+      this.load(uri, options).then(function (fetchResponse) {
+        if (userCallback) {
+          if (fetchResponse) {
+            if (fetchResponse.ok) {
+              userCallback(true, 'OK', fetchResponse);
+            } else {
+              // console.log('@@@ fetcher.js Should not take this path !!!!!!!!!!!!')
+              var oops = 'HTTP error: Status ' + fetchResponse.status + ' (' + fetchResponse.statusText + ')';
+              if (fetchResponse.responseText) {
+                oops += ' ' + fetchResponse.responseText; // not in 404, dns error, nock failure
+              }
+
+              console.log(oops + ' fetching ' + uri);
+              userCallback(false, oops, fetchResponse);
             }
-
-            console.log(oops + ' fetching ' + uri);
-            userCallback(false, oops, fetchResponse);
+          } else {
+            var _oops = '@@ nowOrWhenFetched:  no response object!';
+            console.log(_oops);
+            userCallback(false, _oops);
           }
-        } else {
-          let oops = '@@ nowOrWhenFetched:  no response object!';
-          console.log(oops);
-          userCallback(false, oops);
         }
-      }
-    }, function (err) {
-      var message = err.message || err.statusText;
-      message = 'Failed to load  <' + uri + '> ' + message;
-      console.log(message);
-      if (err.response && err.response.status) {
-        message += ' status: ' + err.response.status;
-      }
-      userCallback(false, message, err.response);
-    });
-  }
-
-  /**
-   * Records a status message (as a literal node) by appending it to the
-   * request's metadata status collection.
-   *
-   */
-  addStatus(req, statusMessage) {
-    // <Debug about="parsePerformance">
-    let now = new Date();
-    statusMessage = '[' + now.getHours() + ':' + now.getMinutes() + ':' + now.getSeconds() + '.' + now.getMilliseconds() + '] ' + statusMessage;
-    // </Debug>
-    let kb = this.store;
-    const statusNode = kb.the(req, this.ns.link('status'));
-    if (isCollection(statusNode)) {
-      statusNode.append(kb.rdfFactory.literal(statusMessage));
-    } else {
-      log.warn('web.js: No list to add to: ' + statusNode + ',' + statusMessage);
+      }, function (err) {
+        var message = err.message || err.statusText;
+        message = 'Failed to load  <' + uri + '> ' + message;
+        console.log(message);
+        if (err.response && err.response.status) {
+          message += ' status: ' + err.response.status;
+        }
+        userCallback(false, message, err.response);
+      });
     }
-  }
 
-  /**
-   * Records errors in the system on failure:
-   *
-   *  - Adds an entry to the request status collection
-   *  - Adds an error triple with the fail message to the metadata
-   *  - Fires the 'fail' callback
-   *  - Rejects with an error result object, which has a response object if any
-   */
-  failFetch(options, errorMessage, statusCode, response) {
-    this.addStatus(options.req, errorMessage);
-    if (!options.noMeta) {
-      this.store.add(options.original, this.ns.link('error'), this.store.rdfFactory.literal(errorMessage));
-    }
-    let meth = (options.method || 'GET').toUpperCase();
-    let isGet = meth === 'GET' || meth === 'HEAD';
-    if (isGet) {
-      // only cache the status code on GET or HEAD
-      if (!options.resource.equals(options.original)) {
-        // console.log('@@ Recording failure  ' + meth + '  original ' + options.original +option '( as ' + options.resource + ') : ' + statusCode)
+    /**
+     * Records a status message (as a literal node) by appending it to the
+     * request's metadata status collection.
+     *
+     */
+  }, {
+    key: "addStatus",
+    value: function addStatus(req, statusMessage) {
+      // <Debug about="parsePerformance">
+      var now = new Date();
+      statusMessage = '[' + now.getHours() + ':' + now.getMinutes() + ':' + now.getSeconds() + '.' + now.getMilliseconds() + '] ' + statusMessage;
+      // </Debug>
+      var kb = this.store;
+      var statusNode = kb.the(req, this.ns.link('status'));
+      if (isCollection(statusNode)) {
+        statusNode.append(kb.rdfFactory.literal(statusMessage));
       } else {
-        // console.log('@@ Recording ' + meth + ' failure for ' + options.original + ': ' + statusCode)
+        log.warn('web.js: No list to add to: ' + statusNode + ',' + statusMessage);
       }
-      this.requested[Uri.docpart(options.original.value)] = statusCode;
-      this.fireCallbacks('fail', [options.original.value, errorMessage]);
     }
-    var err = new Error('Fetcher: ' + errorMessage);
-
-    // err.ok = false // Is taken as a response, will work too @@ phase out?
-    err.status = statusCode;
-    err.statusText = errorMessage;
-    err.response = response;
-    return Promise.reject(err);
-  }
 
-  // in the why part of the quad distinguish between HTML and HTTP header
-  // Reverse is set iif the link was rev= as opposed to rel=
-  linkData(originalUri, rel, uri, why, reverse) {
-    if (!uri) return;
-    let kb = this.store;
-    let predicate;
-    // See http://www.w3.org/TR/powder-dr/#httplink for describedby 2008-12-10
-    let obj = kb.rdfFactory.namedNode(Uri.join(uri, originalUri.value));
-    if (rel === 'alternate' || rel === 'seeAlso' || rel === 'meta' || rel === 'describedby') {
-      if (obj.value === originalUri.value) {
-        return;
+    /**
+     * Records errors in the system on failure:
+     *
+     *  - Adds an entry to the request status collection
+     *  - Adds an error triple with the fail message to the metadata
+     *  - Fires the 'fail' callback
+     *  - Rejects with an error result object, which has a response object if any
+     */
+  }, {
+    key: "failFetch",
+    value: function failFetch(options, errorMessage, statusCode, response) {
+      this.addStatus(options.req, errorMessage);
+      if (!options.noMeta) {
+        this.store.add(options.original, this.ns.link('error'), this.store.rdfFactory.literal(errorMessage));
+      }
+      var meth = (options.method || 'GET').toUpperCase();
+      var isGet = meth === 'GET' || meth === 'HEAD';
+      if (isGet) {
+        // only cache the status code on GET or HEAD
+        if (!options.resource.equals(options.original)) {
+          // console.log('@@ Recording failure  ' + meth + '  original ' + options.original +option '( as ' + options.resource + ') : ' + statusCode)
+        } else {
+          // console.log('@@ Recording ' + meth + ' failure for ' + options.original + ': ' + statusCode)
+        }
+        this.requested[Uri.docpart(options.original.value)] = statusCode;
+        this.fireCallbacks('fail', [options.original.value, errorMessage]);
+      }
+      var err = new Error('Fetcher: ' + errorMessage);
+
+      // err.ok = false // Is taken as a response, will work too @@ phase out?
+      err.status = statusCode;
+      err.statusText = errorMessage;
+      err.response = response;
+      return Promise.reject(err);
+    }
+
+    // in the why part of the quad distinguish between HTML and HTTP header
+    // Reverse is set iif the link was rev= as opposed to rel=
+  }, {
+    key: "linkData",
+    value: function linkData(originalUri, rel, uri, why, reverse) {
+      if (!uri) return;
+      var kb = this.store;
+      var predicate;
+      // See http://www.w3.org/TR/powder-dr/#httplink for describedby 2008-12-10
+      var obj = kb.rdfFactory.namedNode(Uri.join(uri, originalUri.value));
+      if (rel === 'alternate' || rel === 'seeAlso' || rel === 'meta' || rel === 'describedby') {
+        if (obj.value === originalUri.value) {
+          return;
+        }
+        predicate = this.ns.rdfs('seeAlso');
+      } else if (rel === 'type') {
+        predicate = kb.rdfFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
+      } else {
+        // See https://www.iana.org/assignments/link-relations/link-relations.xml
+        // Alas not yet in RDF yet for each predicate
+        // encode space in e.g. rel="shortcut icon"
+        predicate = kb.rdfFactory.namedNode(Uri.join(encodeURIComponent(rel), 'http://www.iana.org/assignments/link-relations/'));
+      }
+      if (reverse) {
+        kb.add(obj, predicate, originalUri, why);
+      } else {
+        kb.add(originalUri, predicate, obj, why);
       }
-      predicate = this.ns.rdfs('seeAlso');
-    } else if (rel === 'type') {
-      predicate = kb.rdfFactory.namedNode('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
-    } else {
-      // See https://www.iana.org/assignments/link-relations/link-relations.xml
-      // Alas not yet in RDF yet for each predicate
-      // encode space in e.g. rel="shortcut icon"
-      predicate = kb.rdfFactory.namedNode(Uri.join(encodeURIComponent(rel), 'http://www.iana.org/assignments/link-relations/'));
-    }
-    if (reverse) {
-      kb.add(obj, predicate, originalUri, why);
-    } else {
-      kb.add(originalUri, predicate, obj, why);
     }
-  }
-  parseLinkHeader(linkHeader, originalUri, reqNode) {
-    if (!linkHeader) {
-      return;
-    }
-
-    // const linkexp = /<[^>]*>\s*(\s*;\s*[^()<>@,;:"/[\]?={} \t]+=(([^()<>@,;:"/[]?={} \t]+)|("[^"]*")))*(,|$)/g
-    // const paramexp = /[^()<>@,;:"/[]?={} \t]+=(([^()<>@,;:"/[]?={} \t]+)|("[^"]*"))/g
-
-    // From https://www.dcode.fr/regular-expression-simplificator:
-    // const linkexp = /<[^>]*>\s*(\s*;\s*[^()<>@,;:"/[\]?={} t]+=["]))*[,$]/g
-    // const paramexp = /[^\\<>@,;:"\/\[\]?={} \t]+=["])/g
-    // Original:
-    const linkexp = /<[^>]*>\s*(\s*;\s*[^()<>@,;:"/[\]?={} \t]+=(([^\(\)<>@,;:"\/\[\]\?={} \t]+)|("[^"]*")))*(,|$)/g;
-    const paramexp = /[^\(\)<>@,;:"\/\[\]\?={} \t]+=(([^\(\)<>@,;:"\/\[\]\?={} \t]+)|("[^"]*"))/g;
-    const matches = linkHeader.match(linkexp);
-    if (matches == null) return;
-    for (let i = 0; i < matches.length; i++) {
-      let split = matches[i].split('>');
-      let href = split[0].substring(1);
-      let ps = split[1];
-      let s = ps.match(paramexp);
-      if (s == null) return;
-      for (let j = 0; j < s.length; j++) {
-        let p = s[j];
-        let paramsplit = p.split('=');
-        // var name = paramsplit[0]
-        let rel = paramsplit[1].replace(/["']/g, ''); // '"
-        this.linkData(originalUri, rel, href, reqNode);
+  }, {
+    key: "parseLinkHeader",
+    value: function parseLinkHeader(linkHeader, originalUri, reqNode) {
+      if (!linkHeader) {
+        return;
+      }
+
+      // const linkexp = /<[^>]*>\s*(\s*;\s*[^()<>@,;:"/[\]?={} \t]+=(([^()<>@,;:"/[]?={} \t]+)|("[^"]*")))*(,|$)/g
+      // const paramexp = /[^()<>@,;:"/[]?={} \t]+=(([^()<>@,;:"/[]?={} \t]+)|("[^"]*"))/g
+
+      // From https://www.dcode.fr/regular-expression-simplificator:
+      // const linkexp = /<[^>]*>\s*(\s*;\s*[^()<>@,;:"/[\]?={} t]+=["]))*[,$]/g
+      // const paramexp = /[^\\<>@,;:"\/\[\]?={} \t]+=["])/g
+      // Original:
+      var linkexp = /<[^>]*>\s*(\s*;\s*[^()<>@,;:"/[\]?={} \t]+=(([^\(\)<>@,;:"\/\[\]\?={} \t]+)|("[^"]*")))*(,|$)/g;
+      var paramexp = /[^\(\)<>@,;:"\/\[\]\?={} \t]+=(([^\(\)<>@,;:"\/\[\]\?={} \t]+)|("[^"]*"))/g;
+      var matches = linkHeader.match(linkexp);
+      if (matches == null) return;
+      for (var i = 0; i < matches.length; i++) {
+        var split = matches[i].split('>');
+        var href = split[0].substring(1);
+        var ps = split[1];
+        var s = ps.match(paramexp);
+        if (s == null) return;
+        for (var j = 0; j < s.length; j++) {
+          var p = s[j];
+          var paramsplit = p.split('=');
+          // var name = paramsplit[0]
+          var rel = paramsplit[1].replace(/["']/g, ''); // '"
+          this.linkData(originalUri, rel, href, reqNode);
+        }
       }
     }
-  }
-  doneFetch(options, response) {
-    this.addStatus(options.req, 'Done.');
-    this.requested[options.original.value] = 'done';
-    this.fireCallbacks('done', [options.original.value]);
-    response.req = options.req; // Set the request meta blank node
+  }, {
+    key: "doneFetch",
+    value: function doneFetch(options, response) {
+      this.addStatus(options.req, 'Done.');
+      this.requested[options.original.value] = 'done';
+      this.fireCallbacks('done', [options.original.value]);
+      response.req = options.req; // Set the request meta blank node
 
-    return response;
-  }
+      return response;
+    }
 
-  /**
-   * Note two nodes are now smushed
-   * If only one was flagged as looked up, then the new node is looked up again,
-   * which will make sure all the URIs are dereferenced
-   */
-  nowKnownAs(was, now) {
-    if (this.lookedUp[was.value]) {
-      // Transfer userCallback
-      if (!this.lookedUp[now.value]) {
-        this.lookUpThing(now, was);
-      }
-    } else if (this.lookedUp[now.value]) {
-      if (!this.lookedUp[was.value]) {
-        this.lookUpThing(was, now);
+    /**
+     * Note two nodes are now smushed
+     * If only one was flagged as looked up, then the new node is looked up again,
+     * which will make sure all the URIs are dereferenced
+     */
+  }, {
+    key: "nowKnownAs",
+    value: function nowKnownAs(was, now) {
+      if (this.lookedUp[was.value]) {
+        // Transfer userCallback
+        if (!this.lookedUp[now.value]) {
+          this.lookUpThing(now, was);
+        }
+      } else if (this.lookedUp[now.value]) {
+        if (!this.lookedUp[was.value]) {
+          this.lookUpThing(was, now);
+        }
       }
     }
-  }
 
-  /**
-   * Writes back to the web what we have in the store for this uri
-   */
-  putBack(uri) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    const uriSting = termValue(uri);
-    let doc = new RDFlibNamedNode(uriSting).doc(); // strip off #
-    options.contentType = options["content-type"] || options["Content-Type"] || options.contentType || TurtleContentType;
-    if (options.contentType === 'application/ld+json') {
-      return new Promise((resolve, reject) => {
-        serialize(doc, this.store, doc.uri, options.contentType, (err, jsonString) => {
-          if (err) {
-            reject(err);
-          } else {
-            // @ts-ignore
-            options.data = jsonString;
-            this.webOperation('PUT', uri, options).then(res => resolve(res)).catch(error => reject(error));
-          }
+    /**
+     * Writes back to the web what we have in the store for this uri
+     */
+  }, {
+    key: "putBack",
+    value: function putBack(uri) {
+      var _this6 = this;
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var uriSting = termValue(uri);
+      var doc = new RDFlibNamedNode(uriSting).doc(); // strip off #
+      options.contentType = options["content-type"] || options["Content-Type"] || options.contentType || TurtleContentType;
+      if (options.contentType === 'application/ld+json') {
+        return new Promise(function (resolve, reject) {
+          serialize(doc, _this6.store, doc.uri, options.contentType, function (err, jsonString) {
+            if (err) {
+              reject(err);
+            } else {
+              // @ts-ignore
+              options.data = jsonString;
+              _this6.webOperation('PUT', uri, options).then(function (res) {
+                return resolve(res);
+              }).catch(function (error) {
+                return reject(error);
+              });
+            }
+          });
+        });
+      }
+      options.data = serialize(doc, this.store, doc.value, options.contentType);
+      return this.webOperation('PUT', uriSting, options);
+    }
+  }, {
+    key: "webCopy",
+    value: function webCopy(here, there, contentType) {
+      var _this7 = this;
+      return this.webOperation('GET', here).then(function (result) {
+        return _this7.webOperation('PUT',
+        // change to binary from text
+        there, {
+          data: result.responseText,
+          contentType: contentType
         });
       });
     }
-    options.data = serialize(doc, this.store, doc.value, options.contentType);
-    return this.webOperation('PUT', uriSting, options);
-  }
-  webCopy(here, there, contentType) {
-    return this.webOperation('GET', here).then(result => {
-      return this.webOperation('PUT',
-      // change to binary from text
-      there, {
-        data: result.responseText,
-        contentType
-      });
-    });
-  }
-  delete(uri, options) {
-    return this.webOperation('DELETE', uri, options).then(response => {
-      this.requested[uri] = 404;
-      this.nonexistent[uri] = true;
-      this.unload(this.store.rdfFactory.namedNode(uri));
-      return response;
-    });
-  }
-
-  /** Create an empty resource if it really does not exist
-   *  Be absolutely sure something does not exist before creating a new empty file
-   * as otherwise existing could  be deleted.
-   * @param doc - The resource
-  */
-  async createIfNotExists(doc) {
-    let contentType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : TurtleContentType;
-    let data = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
-    const fetcher = this;
-    try {
-      var response = await fetcher.load(doc);
-    } catch (err) {
-      // @ts-ignore
-      if (err.response.status === 404) {
-        console.log('createIfNotExists: doc does NOT exist, will create... ' + doc);
-        try {
-          response = await fetcher.webOperation('PUT', doc.value, {
-            data,
-            contentType
-          });
-        } catch (err) {
-          console.log('createIfNotExists doc FAILED: ' + doc + ': ' + err);
-          throw err;
-        }
-        delete fetcher.requested[doc.value]; // delete cached 404 error
-        // console.log('createIfNotExists doc created ok ' + doc)
+  }, {
+    key: "delete",
+    value: function _delete(uri, options) {
+      var _this8 = this;
+      return this.webOperation('DELETE', uri, options).then(function (response) {
+        _this8.requested[uri] = 404;
+        _this8.nonexistent[uri] = true;
+        _this8.unload(_this8.store.rdfFactory.namedNode(uri));
         return response;
-      } else {
-        console.log('createIfNotExists doc load error NOT 404:  ' + doc + ': ' + err);
-        throw err;
-      }
+      });
     }
-    // console.log('createIfNotExists: doc exists, all good: ' + doc)
-    return response;
-  }
 
-  /**
-   * @param parentURI URI of parent container
-   * @param folderName - Optional folder name (slug)
-   * @param data - Optional folder metadata
-   */
-  createContainer(parentURI, folderName, data) {
-    let headers = {
-      // Force the right mime type for containers
-      'content-type': TurtleContentType,
-      'link': this.ns.ldp('BasicContainer') + '; rel="type"'
-    };
-    if (folderName) {
-      headers['slug'] = folderName;
-    }
+    /** Create an empty resource if it really does not exist
+     *  Be absolutely sure something does not exist before creating a new empty file
+     * as otherwise existing could  be deleted.
+     * @param doc - The resource
+    */
+  }, {
+    key: "createIfNotExists",
+    value: function () {
+      var _createIfNotExists = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(doc) {
+        var contentType,
+          data,
+          fetcher,
+          response,
+          _args2 = arguments;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              contentType = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : TurtleContentType;
+              data = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : '';
+              fetcher = this;
+              _context2.prev = 3;
+              _context2.next = 6;
+              return fetcher.load(doc);
+            case 6:
+              response = _context2.sent;
+              _context2.next = 29;
+              break;
+            case 9:
+              _context2.prev = 9;
+              _context2.t0 = _context2["catch"](3);
+              if (!(_context2.t0.response.status === 404)) {
+                _context2.next = 27;
+                break;
+              }
+              console.log('createIfNotExists: doc does NOT exist, will create... ' + doc);
+              _context2.prev = 13;
+              _context2.next = 16;
+              return fetcher.webOperation('PUT', doc.value, {
+                data: data,
+                contentType: contentType
+              });
+            case 16:
+              response = _context2.sent;
+              _context2.next = 23;
+              break;
+            case 19:
+              _context2.prev = 19;
+              _context2.t1 = _context2["catch"](13);
+              console.log('createIfNotExists doc FAILED: ' + doc + ': ' + _context2.t1);
+              throw _context2.t1;
+            case 23:
+              delete fetcher.requested[doc.value]; // delete cached 404 error
+              // console.log('createIfNotExists doc created ok ' + doc)
+              return _context2.abrupt("return", response);
+            case 27:
+              console.log('createIfNotExists doc load error NOT 404:  ' + doc + ': ' + _context2.t0);
+              throw _context2.t0;
+            case 29:
+              return _context2.abrupt("return", response);
+            case 30:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[3, 9], [13, 19]]);
+      }));
+      function createIfNotExists(_x4) {
+        return _createIfNotExists.apply(this, arguments);
+      }
+      return createIfNotExists;
+    }()
+    /**
+     * @param parentURI URI of parent container
+     * @param folderName - Optional folder name (slug)
+     * @param data - Optional folder metadata
+     */
+  }, {
+    key: "createContainer",
+    value: function createContainer(parentURI, folderName, data) {
+      var headers = {
+        // Force the right mime type for containers
+        'content-type': TurtleContentType,
+        'link': this.ns.ldp('BasicContainer') + '; rel="type"'
+      };
+      if (folderName) {
+        headers['slug'] = folderName;
+      }
 
-    // @ts-ignore These headers lack some of the required operators.
-    let options = {
-      headers
-    };
-    if (data) {
-      options.body = data;
+      // @ts-ignore These headers lack some of the required operators.
+      var options = {
+        headers: headers
+      };
+      if (data) {
+        options.body = data;
+      }
+      return this.webOperation('POST', parentURI, options);
     }
-    return this.webOperation('POST', parentURI, options);
-  }
-  invalidateCache(iri) {
-    const uri = termValue(iri);
-    const fetcher = this;
-    // @ts-ignore
-    if (fetcher.fetchQueue && fetcher.fetchQueue[uri]) {
-      console.log('Internal error - fetchQueue exists ' + uri);
-      var promise = fetcher.fetchQueue[uri];
-      if (promise['PromiseStatus'] === 'resolved') {
-        delete fetcher.fetchQueue[uri];
+  }, {
+    key: "invalidateCache",
+    value: function invalidateCache(iri) {
+      var uri = termValue(iri);
+      var fetcher = this;
+      // @ts-ignore
+      if (fetcher.fetchQueue && fetcher.fetchQueue[uri]) {
+        console.log('Internal error - fetchQueue exists ' + uri);
+        var promise = fetcher.fetchQueue[uri];
+        if (promise['PromiseStatus'] === 'resolved') {
+          delete fetcher.fetchQueue[uri];
+        } else {
+          // pending
+          delete fetcher.fetchQueue[uri];
+          console.log('*** Fetcher: pending fetchQueue deleted ' + uri);
+        }
+      }
+      if (fetcher.requested[uri] && fetcher.requested[uri] !== 'done' && fetcher.requested[uri] !== 'failed' && fetcher.requested[uri] !== 404) {
+        var msg = "Rdflib: fetcher: Destructive operation on <".concat(fetcher.requested[uri], "> file being fetched! ") + uri;
+        console.error(msg);
+        // alert(msg)
       } else {
-        // pending
-        delete fetcher.fetchQueue[uri];
-        console.log('*** Fetcher: pending fetchQueue deleted ' + uri);
+        delete fetcher.requested[uri]; // invalidate read cache -- @@ messes up logic if request in progress ??
+        delete fetcher.nonexistent[uri];
       }
     }
-    if (fetcher.requested[uri] && fetcher.requested[uri] !== 'done' && fetcher.requested[uri] !== 'failed' && fetcher.requested[uri] !== 404) {
-      let msg = `Rdflib: fetcher: Destructive operation on <${fetcher.requested[uri]}> file being fetched! ` + uri;
-      console.error(msg);
-      // alert(msg)
-    } else {
-      delete fetcher.requested[uri]; // invalidate read cache -- @@ messes up logic if request in progress ??
-      delete fetcher.nonexistent[uri];
-    }
-  }
 
-  /**
-   * A generic web operation, at the fetch() level.
-   * does not involve the quad store.
-   *
-   *  Returns promise of Response
-   *  If data is returned, copies it to response.responseText before returning
-   */
-  webOperation(method, uriIn) {
-    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    const uri = termValue(uriIn);
-    options.method = method;
-    options.body = options.data || options.body;
-    options.force = true;
-    const fetcher = this;
-    if (options.body && !options.contentType) {
-      throw new Error('Web operation sending data must have a defined contentType.');
-    }
-    if (options.contentType) {
-      options.headers = options.headers || {};
-      options.headers['content-type'] = options.contentType;
-    }
-    Fetcher.setCredentials(uri, options);
-    return new Promise(function (resolve, reject) {
-      fetcher._fetch(uri, options).then(response => {
-        if (response.ok) {
-          if (method === 'PUT' || method === 'PATCH' || method === 'POST' || method === 'DELETE') {
-            fetcher.invalidateCache(uri);
-          } // response.body with Chrome can't be relied on
-          if (response.text) {
-            // Was: response.body https://github.com/linkeddata/rdflib.js/issues/506
-            response.text().then(data => {
-              response.responseText = data;
+    /**
+     * A generic web operation, at the fetch() level.
+     * does not involve the quad store.
+     *
+     *  Returns promise of Response
+     *  If data is returned, copies it to response.responseText before returning
+     */
+  }, {
+    key: "webOperation",
+    value: function webOperation(method, uriIn) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var uri = termValue(uriIn);
+      options.method = method;
+      options.body = options.data || options.body;
+      options.force = true;
+      var fetcher = this;
+      if (options.body && !options.contentType) {
+        throw new Error('Web operation sending data must have a defined contentType.');
+      }
+      if (options.contentType) {
+        options.headers = options.headers || {};
+        options.headers['content-type'] = options.contentType;
+      }
+      Fetcher.setCredentials(uri, options);
+      return new Promise(function (resolve, reject) {
+        fetcher._fetch(uri, options).then(function (response) {
+          if (response.ok) {
+            if (method === 'PUT' || method === 'PATCH' || method === 'POST' || method === 'DELETE') {
+              fetcher.invalidateCache(uri);
+            } // response.body with Chrome can't be relied on
+            if (response.text) {
+              // Was: response.body https://github.com/linkeddata/rdflib.js/issues/506
+              response.text().then(function (data) {
+                response.responseText = data;
+                resolve(response);
+              });
+            } else {
               resolve(response);
-            });
+            }
           } else {
-            resolve(response);
+            var msg = 'Web error: ' + response.status;
+            if (response.statusText) msg += ' (' + response.statusText + ')';
+            msg += ' on ' + method + ' of <' + uri + '>';
+            if (response.responseText) msg += ': ' + response.responseText;
+            var e2 = new Error(msg);
+            e2.response = response;
+            reject(e2);
           }
-        } else {
-          let msg = 'Web error: ' + response.status;
-          if (response.statusText) msg += ' (' + response.statusText + ')';
-          msg += ' on ' + method + ' of <' + uri + '>';
-          if (response.responseText) msg += ': ' + response.responseText;
-          let e2 = new Error(msg);
-          e2.response = response;
-          reject(e2);
-        }
-      }, err => {
-        let msg = 'Fetch error for ' + method + ' of <' + uri + '>:' + err;
-        reject(new Error(msg));
+        }, function (err) {
+          var msg = 'Fetch error for ' + method + ' of <' + uri + '>:' + err;
+          reject(new Error(msg));
+        });
       });
-    });
-  }
-
-  /**
-   * Looks up something.
-   * Looks up all the URIs a things has.
-   *
-   * @param term - canonical term for the thing whose URI is
-   *   to be dereferenced
-   * @param rterm - the resource which referred to this
-   *   (for tracking bad links)
-   */
-  lookUpThing(term, rterm) {
-    let uris = this.store.uris(term); // Get all URIs
-    uris = uris.map(u => Uri.docpart(u)); // Drop hash fragments
+    }
 
-    uris.forEach(u => {
-      this.lookedUp[u] = true;
-    });
+    /**
+     * Looks up something.
+     * Looks up all the URIs a things has.
+     *
+     * @param term - canonical term for the thing whose URI is
+     *   to be dereferenced
+     * @param rterm - the resource which referred to this
+     *   (for tracking bad links)
+     */
+  }, {
+    key: "lookUpThing",
+    value: function lookUpThing(term, rterm) {
+      var _this9 = this;
+      var uris = this.store.uris(term); // Get all URIs
+      uris = uris.map(function (u) {
+        return Uri.docpart(u);
+      }); // Drop hash fragments
+
+      uris.forEach(function (u) {
+        _this9.lookedUp[u] = true;
+      });
 
-    // @ts-ignore Recursive type
-    return this.load(uris, {
-      referringTerm: rterm
-    });
-  }
+      // @ts-ignore Recursive type
+      return this.load(uris, {
+        referringTerm: rterm
+      });
+    }
 
-  /**
-   * Looks up response header.
-   *
-   * @returns {Array|undefined} a list of header values found in a stored HTTP
-   *   response, or [] if response was found but no header found,
-   *   or undefined if no response is available.
-   * Looks for { [] link:requestedURI ?uri; link:response [ httph:header-name  ?value ] }
-   */
-  getHeader(doc, header) {
-    const kb = this.store; // look for the URI (AS A STRING NOT A NODE) for a stored request
-    const docuri = doc.value;
-    const requests = kb.each(undefined, this.ns.link('requestedURI'), kb.rdfFactory.literal(docuri));
-    for (let r = 0; r < requests.length; r++) {
-      let request = requests[r];
-      if (request !== undefined) {
-        let response = kb.any(request, this.ns.link('response'));
-        if (response !== undefined && kb.anyValue(response, this.ns.http('status')) && kb.anyValue(response, this.ns.http('status')).startsWith('2')) {
-          // Only look at success returns - not 401 error messagess etc
-          let results = kb.each(response, this.ns.httph(header.toLowerCase()));
-          if (results.length) {
-            return results.map(v => {
-              return v.value;
-            });
+    /**
+     * Looks up response header.
+     *
+     * @returns {Array|undefined} a list of header values found in a stored HTTP
+     *   response, or [] if response was found but no header found,
+     *   or undefined if no response is available.
+     * Looks for { [] link:requestedURI ?uri; link:response [ httph:header-name  ?value ] }
+     */
+  }, {
+    key: "getHeader",
+    value: function getHeader(doc, header) {
+      var kb = this.store; // look for the URI (AS A STRING NOT A NODE) for a stored request
+      var docuri = doc.value;
+      var requests = kb.each(undefined, this.ns.link('requestedURI'), kb.rdfFactory.literal(docuri));
+      for (var r = 0; r < requests.length; r++) {
+        var request = requests[r];
+        if (request !== undefined) {
+          var _response = kb.any(request, this.ns.link('response'));
+          if (_response !== undefined && kb.anyValue(_response, this.ns.http('status')) && kb.anyValue(_response, this.ns.http('status')).startsWith('2')) {
+            // Only look at success returns - not 401 error messagess etc
+            var results = kb.each(_response, this.ns.httph(header.toLowerCase()));
+            if (results.length) {
+              return results.map(function (v) {
+                return v.value;
+              });
+            }
+            return [];
           }
-          return [];
         }
       }
+      return undefined;
     }
-    return undefined;
-  }
-  saveRequestMetadata(docuri, options) {
-    let req = options.req;
-    let kb = this.store;
-    let rterm = options.referringTerm;
-    this.addStatus(options.req, 'Accept: ' + options.headers['accept']);
-    if (isNamedNode(rterm)) {
-      kb.add(kb.rdfFactory.namedNode(docuri), this.ns.link('requestedBy'), rterm, this.appNode);
-    }
-    if (options.original && options.original.value !== docuri) {
-      kb.add(req, this.ns.link('orginalURI'), kb.rdfFactory.literal(options.original.value), this.appNode);
-    }
-    const now = new Date();
-    const timeNow = '[' + now.getHours() + ':' + now.getMinutes() + ':' + now.getSeconds() + '] ';
-    kb.add(req, this.ns.rdfs('label'), kb.rdfFactory.literal(timeNow + ' Request for ' + docuri), this.appNode);
-    // We store the docuri as a string, not as a node,
-    // see https://github.com/linkeddata/rdflib.js/pull/427#pullrequestreview-447910061
-    kb.add(req, this.ns.link('requestedURI'), kb.rdfFactory.literal(docuri), this.appNode);
-    kb.add(req, this.ns.link('status'), kb.collection(), this.appNode);
-  }
-  saveResponseMetadata(response, options) {
-    const kb = this.store;
-    let responseNode = kb.bnode();
-    kb.add(options.req, this.ns.link('response'), responseNode, responseNode);
-    kb.add(responseNode, this.ns.http('status'), kb.rdfFactory.literal(response.status), responseNode);
-    kb.add(responseNode, this.ns.http('statusText'), kb.rdfFactory.literal(response.statusText), responseNode);
-
-    // Save the response headers
-    response.headers.forEach((value, header) => {
-      kb.add(responseNode, this.ns.httph(header), this.store.rdfFactory.literal(value), responseNode);
-      if (header === 'content-type') {
-        kb.add(options.resource, this.ns.rdf('type'), kb.rdfFactory.namedNode(Util.mediaTypeClass(value).value), responseNode);
+  }, {
+    key: "saveRequestMetadata",
+    value: function saveRequestMetadata(docuri, options) {
+      var req = options.req;
+      var kb = this.store;
+      var rterm = options.referringTerm;
+      this.addStatus(options.req, 'Accept: ' + options.headers['accept']);
+      if (isNamedNode(rterm)) {
+        kb.add(kb.rdfFactory.namedNode(docuri), this.ns.link('requestedBy'), rterm, this.appNode);
       }
-    });
-    return responseNode;
-  }
-  objectRefresh(term) {
-    let uris = this.store.uris(term); // Get all URIs
-    if (typeof uris !== 'undefined') {
-      for (let i = 0; i < uris.length; i++) {
-        this.refresh(this.store.rdfFactory.namedNode(Uri.docpart(uris[i])));
-        // what about rterm?
+      if (options.original && options.original.value !== docuri) {
+        kb.add(req, this.ns.link('orginalURI'), kb.rdfFactory.literal(options.original.value), this.appNode);
+      }
+      var now = new Date();
+      var timeNow = '[' + now.getHours() + ':' + now.getMinutes() + ':' + now.getSeconds() + '] ';
+      kb.add(req, this.ns.rdfs('label'), kb.rdfFactory.literal(timeNow + ' Request for ' + docuri), this.appNode);
+      // We store the docuri as a string, not as a node,
+      // see https://github.com/linkeddata/rdflib.js/pull/427#pullrequestreview-447910061
+      kb.add(req, this.ns.link('requestedURI'), kb.rdfFactory.literal(docuri), this.appNode);
+      kb.add(req, this.ns.link('status'), kb.collection(), this.appNode);
+    }
+  }, {
+    key: "saveResponseMetadata",
+    value: function saveResponseMetadata(response, options) {
+      var _this10 = this;
+      var kb = this.store;
+      var responseNode = kb.bnode();
+      kb.add(options.req, this.ns.link('response'), responseNode, responseNode);
+      kb.add(responseNode, this.ns.http('status'), kb.rdfFactory.literal(response.status), responseNode);
+      kb.add(responseNode, this.ns.http('statusText'), kb.rdfFactory.literal(response.statusText), responseNode);
+
+      // Save the response headers
+      response.headers.forEach(function (value, header) {
+        kb.add(responseNode, _this10.ns.httph(header), _this10.store.rdfFactory.literal(value), responseNode);
+        if (header === 'content-type') {
+          kb.add(options.resource, _this10.ns.rdf('type'), kb.rdfFactory.namedNode(Util.mediaTypeClass(value).value), responseNode);
+        }
+      });
+      return responseNode;
+    }
+  }, {
+    key: "objectRefresh",
+    value: function objectRefresh(term) {
+      var uris = this.store.uris(term); // Get all URIs
+      if (typeof uris !== 'undefined') {
+        for (var i = 0; i < uris.length; i++) {
+          this.refresh(this.store.rdfFactory.namedNode(Uri.docpart(uris[i])));
+          // what about rterm?
+        }
       }
     }
-  }
-
-  /* refresh  Reload data from a given document
-  **
-  ** @param term - An RDF Named Node for the eodcument in question
-  ** @param userCallback - A function userCallback(ok, message, response)
-  */
-  refresh(term, userCallback) {
-    // sources_refresh
-    this.fireCallbacks('refresh', arguments);
-    this.nowOrWhenFetched(term, {
-      force: true,
-      clearPreviousData: true
-    }, userCallback);
-  }
 
-  /* refreshIfExpired   Conditional refresh if Expired
-  **
-  ** @param term - An RDF Named Node for the eodcument in question
-  ** @param userCallback - A function userCallback(ok, message, response)
-  */
-  refreshIfExpired(term, userCallback) {
-    let exp = this.getHeader(term, 'Expires');
-    if (!exp || new Date(exp[0]).getTime() <= new Date().getTime()) {
-      this.refresh(term, userCallback);
-    } else {
-      userCallback(true, 'Not expired', {});
+    /* refresh  Reload data from a given document
+    **
+    ** @param term - An RDF Named Node for the eodcument in question
+    ** @param userCallback - A function userCallback(ok, message, response)
+    */
+  }, {
+    key: "refresh",
+    value: function refresh(term, userCallback) {
+      // sources_refresh
+      this.fireCallbacks('refresh', arguments);
+      this.nowOrWhenFetched(term, {
+        force: true,
+        clearPreviousData: true
+      }, userCallback);
+    }
+
+    /* refreshIfExpired   Conditional refresh if Expired
+    **
+    ** @param term - An RDF Named Node for the eodcument in question
+    ** @param userCallback - A function userCallback(ok, message, response)
+    */
+  }, {
+    key: "refreshIfExpired",
+    value: function refreshIfExpired(term, userCallback) {
+      var exp = this.getHeader(term, 'Expires');
+      if (!exp || new Date(exp[0]).getTime() <= new Date().getTime()) {
+        this.refresh(term, userCallback);
+      } else {
+        userCallback(true, 'Not expired', {});
+      }
     }
-  }
-  retract(term) {
-    // sources_retract
-    this.store.removeMany(undefined, undefined, undefined, term);
-    if (term.value) {
-      delete this.requested[Uri.docpart(term.value)];
+  }, {
+    key: "retract",
+    value: function retract(term) {
+      // sources_retract
+      this.store.removeMany(undefined, undefined, undefined, term);
+      if (term.value) {
+        delete this.requested[Uri.docpart(term.value)];
+      }
+      this.fireCallbacks('retract', arguments);
+    }
+  }, {
+    key: "getState",
+    value: function getState(docuri) {
+      if (typeof this.requested[docuri] === 'undefined') {
+        return 'unrequested';
+      } else if (this.requested[docuri] === true) {
+        return 'requested';
+      } else if (this.requested[docuri] === 'done') {
+        return 'fetched';
+      } else if (this.requested[docuri] === 'redirected') {
+        return this.getState(this.redirectedTo[docuri]);
+      } else {
+        // An non-200 HTTP error status
+        return 'failed';
+      }
     }
-    this.fireCallbacks('retract', arguments);
-  }
-  getState(docuri) {
-    if (typeof this.requested[docuri] === 'undefined') {
-      return 'unrequested';
-    } else if (this.requested[docuri] === true) {
-      return 'requested';
-    } else if (this.requested[docuri] === 'done') {
-      return 'fetched';
-    } else if (this.requested[docuri] === 'redirected') {
-      return this.getState(this.redirectedTo[docuri]);
-    } else {
-      // An non-200 HTTP error status
-      return 'failed';
+  }, {
+    key: "isPending",
+    value: function isPending(docuri) {
+      // sources_pending
+      // doing anyStatementMatching is wasting time
+      // if it's not pending: false -> flailed
+      //   'done' -> done 'redirected' -> redirected
+      return this.requested[docuri] === true;
+    }
+  }, {
+    key: "unload",
+    value: function unload(term) {
+      this.store.removeDocument(term);
+      delete this.requested[term.value]; // So it can be load2ed again
+    }
+  }, {
+    key: "addHandler",
+    value: function addHandler(handler) {
+      this.handlers.push(handler);
+      handler.register(this);
+    }
+  }, {
+    key: "retryNoCredentials",
+    value: function retryNoCredentials(docuri, options) {
+      console.log('Fetcher: CORS: RETRYING with NO CREDENTIALS for ' + options.resource);
+      options.retriedWithNoCredentials = true; // protect against being called twice
+
+      delete this.requested[docuri]; // forget the original request happened
+      delete this.fetchQueue[docuri];
+      // Note: XHR property was withCredentials, but fetch property is just credentials
+      var newOptions = Object.assign({}, options, {
+        credentials: 'omit'
+      });
+      this.addStatus(options.req, 'Abort: Will retry with credentials SUPPRESSED to see if that helps');
+      return this.load(docuri, newOptions);
     }
-  }
-  isPending(docuri) {
-    // sources_pending
-    // doing anyStatementMatching is wasting time
-    // if it's not pending: false -> flailed
-    //   'done' -> done 'redirected' -> redirected
-    return this.requested[docuri] === true;
-  }
-  unload(term) {
-    this.store.removeDocument(term);
-    delete this.requested[term.value]; // So it can be load2ed again
-  }
-
-  addHandler(handler) {
-    this.handlers.push(handler);
-    handler.register(this);
-  }
-  retryNoCredentials(docuri, options) {
-    console.log('Fetcher: CORS: RETRYING with NO CREDENTIALS for ' + options.resource);
-    options.retriedWithNoCredentials = true; // protect against being called twice
-
-    delete this.requested[docuri]; // forget the original request happened
-    delete this.fetchQueue[docuri];
-    // Note: XHR property was withCredentials, but fetch property is just credentials
-    let newOptions = Object.assign({}, options, {
-      credentials: 'omit'
-    });
-    this.addStatus(options.req, 'Abort: Will retry with credentials SUPPRESSED to see if that helps');
-    return this.load(docuri, newOptions);
-  }
-
-  /**
-   * Tests whether a request is being made to a cross-site URI (for purposes
-   * of retrying with a proxy)
-   */
-  isCrossSite(uri) {
-    // Mashup situation, not node etc
-    if (typeof document === 'undefined' || !document.location) {
-      return false;
-    }
-    const hostpart = Uri.hostpart;
-    const here = '' + document.location;
-    return (hostpart(here) && hostpart(uri) && hostpart(here)) !== hostpart(uri);
-  }
 
-  /**
-   * Called when there's a network error in fetch(), or a response
-   * with status of 0.
-   */
-  handleError(response, docuri, options) {
-    if (this.isCrossSite(docuri)) {
-      // Make sure we haven't retried already
-      if (options.credentials && options.credentials === 'include' && !options.retriedWithNoCredentials) {
-        return this.retryNoCredentials(docuri, options);
+    /**
+     * Tests whether a request is being made to a cross-site URI (for purposes
+     * of retrying with a proxy)
+     */
+  }, {
+    key: "isCrossSite",
+    value: function isCrossSite(uri) {
+      // Mashup situation, not node etc
+      if (typeof document === 'undefined' || !document.location) {
+        return false;
       }
+      var hostpart = Uri.hostpart;
+      var here = '' + document.location;
+      return (hostpart(here) && hostpart(uri) && hostpart(here)) !== hostpart(uri);
+    }
+
+    /**
+     * Called when there's a network error in fetch(), or a response
+     * with status of 0.
+     */
+  }, {
+    key: "handleError",
+    value: function handleError(response, docuri, options) {
+      if (this.isCrossSite(docuri)) {
+        // Make sure we haven't retried already
+        if (options.credentials && options.credentials === 'include' && !options.retriedWithNoCredentials) {
+          return this.retryNoCredentials(docuri, options);
+        }
 
-      // Now attempt retry via proxy
-      let proxyUri = Fetcher.crossSiteProxy(docuri);
-      if (proxyUri && !options.proxyUsed) {
-        console.log('web: Direct failed so trying proxy ' + proxyUri);
-        return this.redirectToProxy(proxyUri, options);
+        // Now attempt retry via proxy
+        var proxyUri = Fetcher.crossSiteProxy(docuri);
+        if (proxyUri && !options.proxyUsed) {
+          console.log('web: Direct failed so trying proxy ' + proxyUri);
+          return this.redirectToProxy(proxyUri, options);
+        }
       }
-    }
-    var message;
-    if (response instanceof Error) {
-      message = 'Fetch error: ' + response.message;
-    } else {
-      message = response.statusText;
-      if (response.responseText) {
-        message += ` ${response.responseText}`;
+      var message;
+      if (response instanceof Error) {
+        message = 'Fetch error: ' + response.message;
+      } else {
+        message = response.statusText;
+        if (response.responseText) {
+          message += " ".concat(response.responseText);
+        }
       }
-    }
 
-    // This is either not a CORS error, or retries have been made
-    return this.failFetch(options, message, response.status || 998, response);
-  }
+      // This is either not a CORS error, or retries have been made
+      return this.failFetch(options, message, response.status || 998, response);
+    }
 
-  // deduce some things from the HTTP transaction
-  addType(rdfType, req, kb, locURI) {
-    // add type to all redirected resources too
-    let prev = req;
-    if (locURI) {
-      var reqURI = kb.any(prev, this.ns.link('requestedURI'));
-      if (reqURI && reqURI.value !== locURI) {
-        kb.add(kb.rdfFactory.namedNode(locURI), this.ns.rdf('type'), rdfType, this.appNode);
+    // deduce some things from the HTTP transaction
+  }, {
+    key: "addType",
+    value: function addType(rdfType, req, kb, locURI) {
+      // add type to all redirected resources too
+      var prev = req;
+      if (locURI) {
+        var reqURI = kb.any(prev, this.ns.link('requestedURI'));
+        if (reqURI && reqURI.value !== locURI) {
+          kb.add(kb.rdfFactory.namedNode(locURI), this.ns.rdf('type'), rdfType, this.appNode);
+        }
+      }
+      for (;;) {
+        var doc = kb.any(prev, this.ns.link('requestedURI'));
+        if (doc && doc.value) {
+          kb.add(kb.rdfFactory.namedNode(doc.value), this.ns.rdf('type'), rdfType, this.appNode);
+        } // convert Literal
+        prev = kb.any(undefined, kb.rdfFactory.namedNode('http://www.w3.org/2007/ont/link#redirectedRequest'), prev);
+        if (!prev) {
+          break;
+        }
+        var response = kb.any(prev, kb.rdfFactory.namedNode('http://www.w3.org/2007/ont/link#response'));
+        if (!response) {
+          break;
+        }
+        var redirection = kb.any(response, kb.rdfFactory.namedNode('http://www.w3.org/2007/ont/http#status'));
+        if (!redirection) {
+          break;
+        }
+        // @ts-ignore always true?
+        if (redirection !== '301' && redirection !== '302') {
+          break;
+        }
       }
     }
-    for (;;) {
-      const doc = kb.any(prev, this.ns.link('requestedURI'));
-      if (doc && doc.value) {
-        kb.add(kb.rdfFactory.namedNode(doc.value), this.ns.rdf('type'), rdfType, this.appNode);
-      } // convert Literal
-      prev = kb.any(undefined, kb.rdfFactory.namedNode('http://www.w3.org/2007/ont/link#redirectedRequest'), prev);
-      if (!prev) {
-        break;
+
+    /**
+     * Handle fetch() response
+     */
+  }, {
+    key: "handleResponse",
+    value: function handleResponse(response, docuri, options) {
+      var _this11 = this;
+      var kb = this.store;
+      var headers = response.headers;
+      var reqNode = options.req;
+      var responseNode = this.saveResponseMetadata(response, options);
+      var contentType = this.normalizedContentType(options, headers) || '';
+      var contentLocation = headers.get('content-location');
+
+      // this.fireCallbacks('recv', xhr.args)
+      // this.fireCallbacks('headers', [{uri: docuri, headers: xhr.headers}])
+
+      // Check for masked errors (CORS, etc)
+      if (response.status === 0) {
+        console.log('Masked error - status 0 for ' + docuri);
+        return this.handleError(response, docuri, options);
       }
-      var response = kb.any(prev, kb.rdfFactory.namedNode('http://www.w3.org/2007/ont/link#response'));
-      if (!response) {
-        break;
+      if (response.status >= 400) {
+        if (response.status === 404) {
+          this.nonexistent[options.original.value] = true;
+          this.nonexistent[docuri] = true;
+        }
+        return this.saveErrorResponse(response, responseNode).then(function () {
+          var errorMessage = options.resource + ' ' + response.statusText;
+          return _this11.failFetch(options, errorMessage, response.status, response);
+        });
       }
-      var redirection = kb.any(response, kb.rdfFactory.namedNode('http://www.w3.org/2007/ont/http#status'));
-      if (!redirection) {
-        break;
+      var diffLocation = null;
+      var absContentLocation = null;
+      if (contentLocation) {
+        absContentLocation = Uri.join(contentLocation, docuri);
+        if (absContentLocation !== docuri) {
+          diffLocation = absContentLocation;
+        }
       }
-      // @ts-ignore always true?
-      if (redirection !== '301' && redirection !== '302') {
-        break;
+      if (response.status === 200) {
+        this.addType(this.ns.link('Document'), reqNode, kb, docuri);
+        if (diffLocation) {
+          this.addType(this.ns.link('Document'), reqNode, kb, diffLocation);
+        }
+
+        // Before we parse new data clear old but only on 200
+        if (options.clearPreviousData) {
+          kb.removeDocument(options.resource);
+        }
+        var isImage = contentType.includes('image/') || contentType.includes('application/pdf');
+        if (contentType && isImage) {
+          this.addType(kb.rdfFactory.namedNode('http://purl.org/dc/terms/Image'), reqNode, kb, docuri);
+          if (diffLocation) {
+            this.addType(kb.rdfFactory.namedNode('http://purl.org/dc/terms/Image'), reqNode, kb, diffLocation);
+          }
+        }
       }
-    }
-  }
 
-  /**
-   * Handle fetch() response
-   */
-  handleResponse(response, docuri, options) {
-    const kb = this.store;
-    const headers = response.headers;
-    const reqNode = options.req;
-    const responseNode = this.saveResponseMetadata(response, options);
-    const contentType = this.normalizedContentType(options, headers) || '';
-    let contentLocation = headers.get('content-location');
-
-    // this.fireCallbacks('recv', xhr.args)
-    // this.fireCallbacks('headers', [{uri: docuri, headers: xhr.headers}])
-
-    // Check for masked errors (CORS, etc)
-    if (response.status === 0) {
-      console.log('Masked error - status 0 for ' + docuri);
-      return this.handleError(response, docuri, options);
-    }
-    if (response.status >= 400) {
-      if (response.status === 404) {
-        this.nonexistent[options.original.value] = true;
-        this.nonexistent[docuri] = true;
-      }
-      return this.saveErrorResponse(response, responseNode).then(() => {
-        let errorMessage = options.resource + ' ' + response.statusText;
-        return this.failFetch(options, errorMessage, response.status, response);
+      // If we have already got the thing at this location, abort
+      if (contentLocation) {
+        if (!options.force && diffLocation && this.requested[absContentLocation] === 'done') {
+          // we have already fetched this
+          // should we smush too?
+          // log.info("HTTP headers indicate we have already" + " retrieved " +
+          // xhr.resource + " as " + absContentLocation + ". Aborting.")
+          return this.doneFetch(options, response);
+        }
+        this.requested[absContentLocation] = true;
+      }
+      this.parseLinkHeader(headers.get('link'), options.original, reqNode);
+      var handler = this.handlerForContentType(contentType, response);
+      if (!handler) {
+        //  Not a problem, we just don't extract data
+        this.addStatus(reqNode, 'Fetch over. No data handled.');
+        return this.doneFetch(options, response);
+      }
+      return response.text()
+      // @ts-ignore Types seem right
+      .then(function (responseText) {
+        response.responseText = responseText;
+        return handler.parse(_this11, responseText, options, response);
       });
     }
-    var diffLocation = null;
-    var absContentLocation = null;
-    if (contentLocation) {
-      absContentLocation = Uri.join(contentLocation, docuri);
-      if (absContentLocation !== docuri) {
-        diffLocation = absContentLocation;
-      }
+  }, {
+    key: "saveErrorResponse",
+    value: function saveErrorResponse(response, responseNode) {
+      var _this12 = this;
+      var kb = this.store;
+      return response.text().then(function (content) {
+        if (content.length > 10) {
+          kb.add(responseNode, _this12.ns.http('content'), kb.rdfFactory.literal(content), responseNode);
+        }
+      });
     }
-    if (response.status === 200) {
-      this.addType(this.ns.link('Document'), reqNode, kb, docuri);
-      if (diffLocation) {
-        this.addType(this.ns.link('Document'), reqNode, kb, diffLocation);
+  }, {
+    key: "handlerForContentType",
+    value: function handlerForContentType(contentType, response) {
+      if (!contentType) {
+        return null;
       }
+      var Handler = this.handlers.find(function (handler) {
+        return contentType.match(handler.pattern);
+      });
 
-      // Before we parse new data clear old but only on 200
-      if (options.clearPreviousData) {
-        kb.removeDocument(options.resource);
+      // @ts-ignore in practice all Handlers have constructors.
+      return Handler ? new Handler(response) : null;
+    }
+  }, {
+    key: "guessContentType",
+    value: function guessContentType(uri) {
+      return CONTENT_TYPE_BY_EXT[uri.split('.').pop()];
+    }
+  }, {
+    key: "normalizedContentType",
+    value: function normalizedContentType(options, headers) {
+      if (options.forceContentType) {
+        return options.forceContentType;
       }
-      let isImage = contentType.includes('image/') || contentType.includes('application/pdf');
-      if (contentType && isImage) {
-        this.addType(kb.rdfFactory.namedNode('http://purl.org/dc/terms/Image'), reqNode, kb, docuri);
-        if (diffLocation) {
-          this.addType(kb.rdfFactory.namedNode('http://purl.org/dc/terms/Image'), reqNode, kb, diffLocation);
+      var contentType = headers.get('content-type');
+      if (!contentType || contentType.includes('application/octet-stream')) {
+        var guess = this.guessContentType(options.resource.value);
+        if (guess) {
+          return guess;
         }
       }
+      var protocol = Uri.protocol(options.resource.value);
+      if (!contentType && ['file', 'chrome'].includes(protocol)) {
+        return 'text/xml';
+      }
+      return contentType;
     }
 
-    // If we have already got the thing at this location, abort
-    if (contentLocation) {
-      if (!options.force && diffLocation && this.requested[absContentLocation] === 'done') {
-        // we have already fetched this
-        // should we smush too?
-        // log.info("HTTP headers indicate we have already" + " retrieved " +
-        // xhr.resource + " as " + absContentLocation + ". Aborting.")
-        return this.doneFetch(options, response);
+    /**
+     * Sends a new request to the specified uri. (Extracted from `onerrorFactory()`)
+     */
+  }, {
+    key: "redirectToProxy",
+    value: function redirectToProxy(newURI, options) {
+      var _this13 = this;
+      this.addStatus(options.req, 'BLOCKED -> Cross-site Proxy to <' + newURI + '>');
+      options.proxyUsed = true;
+      var kb = this.store;
+      var oldReq = options.req; // request metadata blank node
+
+      if (!options.noMeta) {
+        kb.add(oldReq, this.ns.link('redirectedTo'), kb.rdfFactory.namedNode(newURI), oldReq);
+        this.addStatus(oldReq, 'redirected to new request'); // why
       }
-      this.requested[absContentLocation] = true;
+
+      this.requested[options.resource.value] = 'redirected';
+      this.redirectedTo[options.resource.value] = newURI;
+      var newOptions = Object.assign({}, options);
+      newOptions.baseURI = options.resource.value;
+      return this.fetchUri(newURI, newOptions).then(function (response) {
+        if (!newOptions.noMeta) {
+          kb.add(oldReq, _this13.ns.link('redirectedRequest'), newOptions.req, _this13.appNode);
+        }
+        return response;
+      });
     }
-    this.parseLinkHeader(headers.get('link'), options.original, reqNode);
-    let handler = this.handlerForContentType(contentType, response);
-    if (!handler) {
-      //  Not a problem, we just don't extract data
-      this.addStatus(reqNode, 'Fetch over. No data handled.');
-      return this.doneFetch(options, response);
+  }, {
+    key: "setRequestTimeout",
+    value: function setRequestTimeout(uri, options) {
+      var _this14 = this;
+      return new Promise(function (resolve) {
+        _this14.timeouts[uri] = (_this14.timeouts[uri] || []).concat(setTimeout(function () {
+          if (_this14.isPending(uri) && !options.retriedWithNoCredentials && !options.proxyUsed) {
+            resolve(_this14.failFetch(options, "Request to ".concat(uri, " timed out"), 'timeout'));
+          }
+        }, _this14.timeout));
+      });
     }
-    return response.text()
-    // @ts-ignore Types seem right
-    .then(responseText => {
-      response.responseText = responseText;
-      return handler.parse(this, responseText, options, response);
-    });
-  }
-  saveErrorResponse(response, responseNode) {
-    let kb = this.store;
-    return response.text().then(content => {
-      if (content.length > 10) {
-        kb.add(responseNode, this.ns.http('content'), kb.rdfFactory.literal(content), responseNode);
+  }, {
+    key: "addFetchCallback",
+    value: function addFetchCallback(uri, callback) {
+      if (!this.fetchCallbacks[uri]) {
+        this.fetchCallbacks[uri] = [callback];
+      } else {
+        this.fetchCallbacks[uri].push(callback);
       }
-    });
-  }
-  handlerForContentType(contentType, response) {
-    if (!contentType) {
-      return null;
     }
-    let Handler = this.handlers.find(handler => {
-      return contentType.match(handler.pattern);
-    });
-
-    // @ts-ignore in practice all Handlers have constructors.
-    return Handler ? new Handler(response) : null;
-  }
-  guessContentType(uri) {
-    return CONTENT_TYPE_BY_EXT[uri.split('.').pop()];
-  }
-  normalizedContentType(options, headers) {
-    if (options.forceContentType) {
-      return options.forceContentType;
-    }
-    let contentType = headers.get('content-type');
-    if (!contentType || contentType.includes('application/octet-stream')) {
-      let guess = this.guessContentType(options.resource.value);
-      if (guess) {
-        return guess;
+  }, {
+    key: "acceptString",
+    value: function acceptString() {
+      var acceptstring = '';
+      for (var mediaType in this.mediatypes) {
+        if (acceptstring !== '') {
+          acceptstring += ', ';
+        }
+        acceptstring += mediaType;
+        for (var property in this.mediatypes[mediaType]) {
+          acceptstring += ';' + property + '=' + this.mediatypes[mediaType][property];
+        }
+      }
+      return acceptstring;
+    }
+    // var updatesVia = new $rdf.UpdatesVia(this) // Subscribe to headers
+    // @@@@@@@@ This is turned off because it causes a websocket to be set up for ANY fetch
+    // whether we want to track it ot not. including ontologies loaed though the XSSproxy
+  }], [{
+    key: "crossSiteProxy",
+    value: function crossSiteProxy(uri) {
+      if (Fetcher.crossSiteProxyTemplate) {
+        return Fetcher.crossSiteProxyTemplate.replace('{uri}', encodeURIComponent(uri));
+      } else {
+        return undefined;
       }
     }
-    let protocol = Uri.protocol(options.resource.value);
-    if (!contentType && ['file', 'chrome'].includes(protocol)) {
-      return 'text/xml';
-    }
-    return contentType;
-  }
+  }, {
+    key: "offlineOverride",
+    value: function offlineOverride(uri) {
+      // Map the URI to a localhost proxy if we are running on localhost
+      // This is used for working offline, e.g. on planes.
+      // Is the script itself is running in localhost, then access all
+      //   data in a localhost mirror.
+      // Do not remove without checking with TimBL
+      var requestedURI = uri;
+      var UI;
+      if (typeof window !== 'undefined' && window.panes && (UI = window.panes.UI) && UI.preferences && UI.preferences.get('offlineModeUsingLocalhost')) {
+        if (requestedURI.slice(0, 7) === 'http://' && requestedURI.slice(7, 17) !== 'localhost/') {
+          requestedURI = 'http://localhost/' + requestedURI.slice(7);
+          log.warn('Localhost kludge for offline use: actually getting <' + requestedURI + '>');
+        } else {
+          // log.warn("Localhost kludge NOT USED <" + requestedURI + ">")
+        }
+      } else {
+        // log.warn("Localhost kludge OFF offline use: actually getting <" +
+        //   requestedURI + ">")
+      }
+      return requestedURI;
+    }
+  }, {
+    key: "proxyIfNecessary",
+    value: function proxyIfNecessary(uri) {
+      var UI;
+      if (typeof window !== 'undefined' && window.panes && (UI = window.panes.UI) && UI.isExtension) {
+        return uri;
+      } // Extension does not need proxy
+
+      if (typeof $SolidTestEnvironment !== 'undefined' && $SolidTestEnvironment.localSiteMap) {
+        // nested dictionaries of URI parts from origin down
+        var hostpath = uri.split('/').slice(2); // the bit after the //
+
+        var lookup = function lookup(parts, index) {
+          var z = index[parts.shift()];
+          if (!z) {
+            return null;
+          }
+          if (typeof z === 'string') {
+            return z + parts.join('/');
+          }
+          if (!parts) {
+            return null;
+          }
+          return lookup(parts, z);
+        };
+        var y = lookup(hostpath, $SolidTestEnvironment.localSiteMap);
+        if (y) {
+          return y;
+        }
+      }
 
-  /**
-   * Sends a new request to the specified uri. (Extracted from `onerrorFactory()`)
-   */
-  redirectToProxy(newURI, options) {
-    this.addStatus(options.req, 'BLOCKED -> Cross-site Proxy to <' + newURI + '>');
-    options.proxyUsed = true;
-    const kb = this.store;
-    const oldReq = options.req; // request metadata blank node
+      // browser does 2014 on as https browser script not trusted
+      // If the web app origin is https: then the mixed content rules
+      // prevent it loading insecure http: stuff so we need proxy.
+      if (Fetcher.crossSiteProxyTemplate && typeof document !== 'undefined' && document.location && ('' + document.location).slice(0, 6) === 'https:' &&
+      // origin is secure
+      uri.slice(0, 5) === 'http:') {
+        // requested data is not
+        return Fetcher.crossSiteProxyTemplate.replace('{uri}', encodeURIComponent(uri));
+      }
+      return uri;
+    }
 
-    if (!options.noMeta) {
-      kb.add(oldReq, this.ns.link('redirectedTo'), kb.rdfFactory.namedNode(newURI), oldReq);
-      this.addStatus(oldReq, 'redirected to new request'); // why
+    /**
+     * Tests whether the uri's protocol is supported by the Fetcher.
+     * @param uri
+     */
+  }, {
+    key: "unsupportedProtocol",
+    value: function unsupportedProtocol(uri) {
+      var pcol = Uri.protocol(uri);
+      return pcol === 'tel' || pcol === 'mailto' || pcol === 'urn';
     }
 
-    this.requested[options.resource.value] = 'redirected';
-    this.redirectedTo[options.resource.value] = newURI;
-    let newOptions = Object.assign({}, options);
-    newOptions.baseURI = options.resource.value;
-    return this.fetchUri(newURI, newOptions).then(response => {
-      if (!newOptions.noMeta) {
-        kb.add(oldReq, this.ns.link('redirectedRequest'), newOptions.req, this.appNode);
-      }
-      return response;
-    });
-  }
-  setRequestTimeout(uri, options) {
-    return new Promise(resolve => {
-      this.timeouts[uri] = (this.timeouts[uri] || []).concat(setTimeout(() => {
-        if (this.isPending(uri) && !options.retriedWithNoCredentials && !options.proxyUsed) {
-          resolve(this.failFetch(options, `Request to ${uri} timed out`, 'timeout'));
+    /** Decide on credentials using old XXHR api or new fetch()  one
+     * @param requestedURI
+     * @param options
+     */
+  }, {
+    key: "setCredentials",
+    value: function setCredentials(requestedURI) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      // 2014 CORS problem:
+      // XMLHttpRequest cannot load http://www.w3.org/People/Berners-Lee/card.
+      // A wildcard '*' cannot be used in the 'Access-Control-Allow-Origin'
+      //   header when the credentials flag is true.
+      // @ Many ontology files under http: and need CORS wildcard ->
+      //   can't have credentials
+      if (options.credentials === undefined) {
+        // Caller using new fetch convention
+        if (options.withCredentials !== undefined) {
+          // XHR style is what Fetcher specified before
+          options.credentials = options.withCredentials ? 'include' : 'omit';
+        } else {
+          options.credentials = 'include'; // default is to be logged on
         }
-      }, this.timeout));
-    });
-  }
-  addFetchCallback(uri, callback) {
-    if (!this.fetchCallbacks[uri]) {
-      this.fetchCallbacks[uri] = [callback];
-    } else {
-      this.fetchCallbacks[uri].push(callback);
-    }
-  }
-  acceptString() {
-    let acceptstring = '';
-    for (let mediaType in this.mediatypes) {
-      if (acceptstring !== '') {
-        acceptstring += ', ';
-      }
-      acceptstring += mediaType;
-      for (let property in this.mediatypes[mediaType]) {
-        acceptstring += ';' + property + '=' + this.mediatypes[mediaType][property];
       }
     }
-    return acceptstring;
-  }
-  // var updatesVia = new $rdf.UpdatesVia(this) // Subscribe to headers
-  // @@@@@@@@ This is turned off because it causes a websocket to be set up for ANY fetch
-  // whether we want to track it ot not. including ontologies loaed though the XSSproxy
-}
+  }]);
+  return Fetcher;
+}();
 _defineProperty(Fetcher, "HANDLERS", void 0);
 _defineProperty(Fetcher, "CONTENT_TYPE_BY_EXT", void 0);
 _defineProperty(Fetcher, "crossSiteProxyTemplate", void 0);
+export { Fetcher as default };
 Fetcher.HANDLERS = defaultHandlers;
 Fetcher.CONTENT_TYPE_BY_EXT = CONTENT_TYPE_BY_EXT;