rdflib 2.2.9 → 2.2.10-4fa7e876

package/esm/rdfxmlparser.js

@@ -1,3 +1,7 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
 /**
  *  RDF/XML PARSER
  *
@@ -57,515 +61,528 @@
  *
 */
 import * as uriUtil from './uri';
-/*
- * @constructor
- * @param {RDFStore} store An RDFStore object
- */
 
-export default function RDFParser(store) {
-  var RDFParser = {};
-  /** Standard namespaces that we know how to handle @final
-   *  @member RDFParser
+var RDFParser = /*#__PURE__*/function () {
+  /*
+   * @constructor
+   * @param {RDFStore} store An RDFStore object
    */
+  function RDFParser(store) {
+    _classCallCheck(this, RDFParser);
+
+    /** Our triple store reference @private */
+    this.store = store;
+    /** Our identified blank nodes @private */
+
+    this.bnodes = {};
+    /** A context for context-aware stores @private */
+
+    this.why = null;
+    /** Reification flag */
 
-  RDFParser.ns = {
-    'RDF': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
-    'RDFS': 'http://www.w3.org/2000/01/rdf-schema#'
-  };
-  /** DOM Level 2 node type magic numbers @final
+    this.reify = false;
+  }
+  /** Standard namespaces that we know how to handle @final
    *  @member RDFParser
    */
 
-  RDFParser.nodeType = {
-    'ELEMENT': 1,
-    'ATTRIBUTE': 2,
-    'TEXT': 3,
-    'CDATA_SECTION': 4,
-    'ENTITY_REFERENCE': 5,
-    'ENTITY': 6,
-    'PROCESSING_INSTRUCTION': 7,
-    'COMMENT': 8,
-    'DOCUMENT': 9,
-    'DOCUMENT_TYPE': 10,
-    'DOCUMENT_FRAGMENT': 11,
-    'NOTATION': 12
-  };
-  /**
-   * Frame class for namespace and base URI lookups
-   * Base lookups will always resolve because the parser knows
-   * the default base.
-   *
-   * @private
-   */
 
-  this.frameFactory = function (parser, parent, element) {
-    return {
-      'NODE': 1,
-      'ARC': 2,
-      'parent': parent,
-      'parser': parser,
-      'store': parser.store,
-      'element': element,
-      'lastChild': 0,
-      'base': null,
-      'lang': null,
-      'node': null,
-      'nodeType': null,
-      'listIndex': 1,
-      'rdfid': null,
-      'datatype': null,
-      'collection': false,
-
-      /** Terminate the frame and notify the store that we're done */
-      'terminateFrame': function terminateFrame() {
-        if (this.collection) {
-          this.node.close();
-        }
-      },
-
-      /** Add a symbol of a certain type to the this frame */
-      'addSymbol': function addSymbol(type, uri) {
-        uri = uriUtil.join(uri, this.base);
-        this.node = this.store.sym(uri);
-        this.nodeType = type;
-      },
-
-      /** Load any constructed triples into the store */
-      'loadTriple': function loadTriple() {
-        if (this.parent.parent.collection) {
-          this.parent.parent.node.append(this.node);
-        } else {
-          this.store.add(this.parent.parent.node, this.parent.node, this.node, this.parser.why);
-        }
+  _createClass(RDFParser, [{
+    key: "frameFactory",
+    value:
+    /**
+     * Frame class for namespace and base URI lookups
+     * Base lookups will always resolve because the parser knows
+     * the default base.
+     *
+     * @private
+     */
+    function frameFactory(parser, parent, element) {
+      return {
+        'NODE': 1,
+        'ARC': 2,
+        'parent': parent,
+        'parser': parser,
+        'store': parser.store,
+        'element': element,
+        'lastChild': 0,
+        'base': null,
+        'lang': null,
+        'node': null,
+        'nodeType': null,
+        'listIndex': 1,
+        'rdfid': null,
+        'datatype': null,
+        'collection': false,
+
+        /** Terminate the frame and notify the store that we're done */
+        'terminateFrame': function terminateFrame() {
+          if (this.collection) {
+            this.node.close();
+          }
+        },
+
+        /** Add a symbol of a certain type to the this frame */
+        'addSymbol': function addSymbol(type, uri) {
+          uri = uriUtil.join(uri, this.base);
+          this.node = this.store.sym(uri);
+          this.nodeType = type;
+        },
+
+        /** Load any constructed triples into the store */
+        'loadTriple': function loadTriple() {
+          if (this.parent.parent.collection) {
+            this.parent.parent.node.append(this.node);
+          } else {
+            this.store.add(this.parent.parent.node, this.parent.node, this.node, this.parser.why);
+          }
 
-        if (this.parent.rdfid != null) {
-          // reify
-          var triple = this.store.sym(uriUtil.join('#' + this.parent.rdfid, this.base));
-          this.store.add(triple, this.store.sym(RDFParser.ns.RDF + 'type'), this.store.sym(RDFParser.ns.RDF + 'Statement'), this.parser.why);
-          this.store.add(triple, this.store.sym(RDFParser.ns.RDF + 'subject'), this.parent.parent.node, this.parser.why);
-          this.store.add(triple, this.store.sym(RDFParser.ns.RDF + 'predicate'), this.parent.node, this.parser.why);
-          this.store.add(triple, this.store.sym(RDFParser.ns.RDF + 'object'), this.node, this.parser.why);
-        }
-      },
+          if (this.parent.rdfid != null) {
+            // reify
+            var triple = this.store.sym(uriUtil.join('#' + this.parent.rdfid, this.base));
+            this.store.add(triple, this.store.sym(RDFParser.ns.RDF + 'type'), this.store.sym(RDFParser.ns.RDF + 'Statement'), this.parser.why);
+            this.store.add(triple, this.store.sym(RDFParser.ns.RDF + 'subject'), this.parent.parent.node, this.parser.why);
+            this.store.add(triple, this.store.sym(RDFParser.ns.RDF + 'predicate'), this.parent.node, this.parser.why);
+            this.store.add(triple, this.store.sym(RDFParser.ns.RDF + 'object'), this.node, this.parser.why);
+          }
+        },
 
-      /** Check if it's OK to load a triple */
-      'isTripleToLoad': function isTripleToLoad() {
-        return this.parent != null && this.parent.parent != null && this.nodeType === this.NODE && this.parent.nodeType === this.ARC && this.parent.parent.nodeType === this.NODE;
-      },
+        /** Check if it's OK to load a triple */
+        'isTripleToLoad': function isTripleToLoad() {
+          return this.parent != null && this.parent.parent != null && this.nodeType === this.NODE && this.parent.nodeType === this.ARC && this.parent.parent.nodeType === this.NODE;
+        },
 
-      /** Add a symbolic node to this frame */
-      'addNode': function addNode(uri) {
-        this.addSymbol(this.NODE, uri);
+        /** Add a symbolic node to this frame */
+        'addNode': function addNode(uri) {
+          this.addSymbol(this.NODE, uri);
 
-        if (this.isTripleToLoad()) {
-          this.loadTriple();
-        }
-      },
+          if (this.isTripleToLoad()) {
+            this.loadTriple();
+          }
+        },
 
-      /** Add a collection node to this frame */
-      'addCollection': function addCollection() {
-        this.nodeType = this.NODE;
-        this.node = this.store.collection();
-        this.collection = true;
+        /** Add a collection node to this frame */
+        'addCollection': function addCollection() {
+          this.nodeType = this.NODE;
+          this.node = this.store.collection();
+          this.collection = true;
 
-        if (this.isTripleToLoad()) {
-          this.loadTriple();
-        }
-      },
-
-      /** Add a collection arc to this frame */
-      'addCollectionArc': function addCollectionArc() {
-        this.nodeType = this.ARC;
-      },
-
-      /** Add a bnode to this frame */
-      'addBNode': function addBNode(id) {
-        if (id != null) {
-          if (this.parser.bnodes[id] != null) {
-            this.node = this.parser.bnodes[id];
+          if (this.isTripleToLoad()) {
+            this.loadTriple();
+          }
+        },
+
+        /** Add a collection arc to this frame */
+        'addCollectionArc': function addCollectionArc() {
+          this.nodeType = this.ARC;
+        },
+
+        /** Add a bnode to this frame */
+        'addBNode': function addBNode(id) {
+          if (id != null) {
+            if (this.parser.bnodes[id] != null) {
+              this.node = this.parser.bnodes[id];
+            } else {
+              this.node = this.parser.bnodes[id] = this.store.bnode();
+            }
           } else {
-            this.node = this.parser.bnodes[id] = this.store.bnode();
+            this.node = this.store.bnode();
           }
-        } else {
-          this.node = this.store.bnode();
-        }
 
-        this.nodeType = this.NODE;
+          this.nodeType = this.NODE;
 
-        if (this.isTripleToLoad()) {
-          this.loadTriple();
-        }
-      },
+          if (this.isTripleToLoad()) {
+            this.loadTriple();
+          }
+        },
 
-      /** Add an arc or property to this frame */
-      'addArc': function addArc(uri) {
-        if (uri === RDFParser.ns.RDF + 'li') {
-          uri = RDFParser.ns.RDF + '_' + this.parent.listIndex;
-          this.parent.listIndex++;
-        }
+        /** Add an arc or property to this frame */
+        'addArc': function addArc(uri) {
+          if (uri === RDFParser.ns.RDF + 'li') {
+            uri = RDFParser.ns.RDF + '_' + this.parent.listIndex;
+            this.parent.listIndex++;
+          }
 
-        this.addSymbol(this.ARC, uri);
-      },
+          this.addSymbol(this.ARC, uri);
+        },
 
-      /** Add a literal to this frame */
-      'addLiteral': function addLiteral(value) {
-        if (this.parent.datatype && this.parent.datatype !== RDFParser.ns.RDF + 'langString') {
-          this.node = this.store.literal(value, this.store.sym(this.parent.datatype));
-        } else {
-          this.node = this.store.literal(value, this.lang);
-        }
+        /** Add a literal to this frame */
+        'addLiteral': function addLiteral(value) {
+          if (this.parent.datatype && this.parent.datatype !== RDFParser.ns.RDF + 'langString') {
+            this.node = this.store.literal(value, this.store.sym(this.parent.datatype));
+          } else {
+            this.node = this.store.literal(value, this.lang);
+          }
 
-        this.nodeType = this.NODE;
+          this.nodeType = this.NODE;
 
-        if (this.isTripleToLoad()) {
-          this.loadTriple();
+          if (this.isTripleToLoad()) {
+            this.loadTriple();
+          }
         }
-      }
-    };
-  }; // from the OpenLayers source .. needed to get around IE problems.
+      };
+    } // from the OpenLayers source .. needed to get around IE problems.
 
+  }, {
+    key: "getAttributeNodeNS",
+    value: function getAttributeNodeNS(node, uri, name) {
+      var attributeNode = null;
 
-  this.getAttributeNodeNS = function (node, uri, name) {
-    var attributeNode = null;
+      if (node.getAttributeNodeNS) {
+        attributeNode = node.getAttributeNodeNS(uri, name);
+      } else {
+        var attributes = node.attributes;
+        var potentialNode, fullName;
 
-    if (node.getAttributeNodeNS) {
-      attributeNode = node.getAttributeNodeNS(uri, name);
-    } else {
-      var attributes = node.attributes;
-      var potentialNode, fullName;
+        for (var i = 0; i < attributes.length; ++i) {
+          potentialNode = attributes[i];
 
-      for (var i = 0; i < attributes.length; ++i) {
-        potentialNode = attributes[i];
+          if (potentialNode.namespaceURI === uri) {
+            fullName = potentialNode.prefix ? potentialNode.prefix + ':' + name : name;
 
-        if (potentialNode.namespaceURI === uri) {
-          fullName = potentialNode.prefix ? potentialNode.prefix + ':' + name : name;
+            if (fullName === potentialNode.nodeName) {
+              attributeNode = potentialNode;
+              break;
+            }
+          }
+        }
+      }
 
-          if (fullName === potentialNode.nodeName) {
-            attributeNode = potentialNode;
+      return attributeNode;
+    }
+    /**
+     * Build our initial scope frame and parse the DOM into triples
+     * @param {DOMTree} document The DOM to parse
+     * @param {String} base The base URL to use
+     * @param {Object} why The context to which this resource belongs
+     */
+
+  }, {
+    key: "parse",
+    value: function parse(document, base, why) {
+      var children = document.childNodes; // clean up for the next run
+
+      this.cleanParser(); // figure out the root element
+
+      var root;
+
+      if (document.nodeType === RDFParser.nodeType.DOCUMENT) {
+        for (var c = 0; c < children.length; c++) {
+          if (children[c].nodeType === RDFParser.nodeType.ELEMENT) {
+            root = children[c];
             break;
           }
         }
+      } else if (document.nodeType === RDFParser.nodeType.ELEMENT) {
+        root = document;
+      } else {
+        throw new Error("RDFParser: can't find root in " + base + '. Halting. '); // return false
       }
-    }
-
-    return attributeNode;
-  };
-  /** Our triple store reference @private */
-
-
-  this.store = store;
-  /** Our identified blank nodes @private */
 
-  this.bnodes = {};
-  /** A context for context-aware stores @private */
-
-  this.why = null;
-  /** Reification flag */
-
-  this.reify = false;
-  /**
-   * Build our initial scope frame and parse the DOM into triples
-   * @param {DOMTree} document The DOM to parse
-   * @param {String} base The base URL to use
-   * @param {Object} why The context to which this resource belongs
-   */
+      this.why = why; // our topmost frame
 
-  this.parse = function (document, base, why) {
-    var children = document.childNodes; // clean up for the next run
+      var f = this.frameFactory(this);
+      this.base = base;
+      f.base = base;
+      f.lang = null; // was '' but can't have langs like that 2015 (!)
 
-    this.cleanParser(); // figure out the root element
+      this.parseDOM(this.buildFrame(f, root));
+      return true;
+    }
+  }, {
+    key: "parseDOM",
+    value: function parseDOM(frame) {
+      // a DOM utility function used in parsing
+      var rdfid;
 
-    var root;
+      var elementURI = function (el) {
+        var result = '';
 
-    if (document.nodeType === RDFParser.nodeType.DOCUMENT) {
-      for (var c = 0; c < children.length; c++) {
-        if (children[c].nodeType === RDFParser.nodeType.ELEMENT) {
-          root = children[c];
-          break;
+        if (el.namespaceURI == null) {
+          throw new Error('RDF/XML syntax error: No namespace for ' + el.localName + ' in ' + this.base);
         }
-      }
-    } else if (document.nodeType === RDFParser.nodeType.ELEMENT) {
-      root = document;
-    } else {
-      throw new Error("RDFParser: can't find root in " + base + '. Halting. '); // return false
-    }
 
-    this.why = why; // our topmost frame
+        if (el.namespaceURI) {
+          result = result + el.namespaceURI;
+        }
 
-    var f = this.frameFactory(this);
-    this.base = base;
-    f.base = base;
-    f.lang = null; // was '' but can't have langs like that 2015 (!)
+        if (el.localName) {
+          result = result + el.localName;
+        } else if (el.nodeName) {
+          if (el.nodeName.indexOf(':') >= 0) result = result + el.nodeName.split(':')[1];else result = result + el.nodeName;
+        }
 
-    this.parseDOM(this.buildFrame(f, root));
-    return true;
-  };
+        return result;
+      }.bind(this);
 
-  this.parseDOM = function (frame) {
-    // a DOM utility function used in parsing
-    var rdfid;
+      var dig = true; // if we'll dig down in the tree on the next iter
 
-    var elementURI = function (el) {
-      var result = '';
+      while (frame.parent) {
+        var dom = frame.element;
+        var attrs = dom.attributes;
+
+        if (dom.nodeType === RDFParser.nodeType.TEXT || dom.nodeType === RDFParser.nodeType.CDATA_SECTION) {
+          // we have a literal
+          if (frame.parent.nodeType === frame.NODE) {
+            // must have had attributes, store as rdf:value
+            frame.addArc(RDFParser.ns.RDF + 'value');
+            frame = this.buildFrame(frame);
+          }
 
-      if (el.namespaceURI == null) {
-        throw new Error('RDF/XML syntax error: No namespace for ' + el.localName + ' in ' + this.base);
-      }
+          frame.addLiteral(dom.nodeValue);
+        } else if (elementURI(dom) !== RDFParser.ns.RDF + 'RDF') {
+          // not root
+          if (frame.parent && frame.parent.collection) {
+            // we're a collection element
+            frame.addCollectionArc();
+            frame = this.buildFrame(frame, frame.element);
+            frame.parent.element = null;
+          }
 
-      if (el.namespaceURI) {
-        result = result + el.namespaceURI;
-      }
+          if (!frame.parent || !frame.parent.nodeType || frame.parent.nodeType === frame.ARC) {
+            // we need a node
+            var about = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'about');
+            rdfid = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'ID');
 
-      if (el.localName) {
-        result = result + el.localName;
-      } else if (el.nodeName) {
-        if (el.nodeName.indexOf(':') >= 0) result = result + el.nodeName.split(':')[1];else result = result + el.nodeName;
-      }
+            if (about && rdfid) {
+              throw new Error('RDFParser: ' + dom.nodeName + ' has both rdf:id and rdf:about.' + ' Halting. Only one of these' + ' properties may be specified on a' + ' node.');
+            }
 
-      return result;
-    }.bind(this);
+            if (!about && rdfid) {
+              frame.addNode('#' + rdfid.nodeValue);
+              dom.removeAttributeNode(rdfid);
+            } else if (about == null && rdfid == null) {
+              var bnid = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'nodeID');
 
-    var dig = true; // if we'll dig down in the tree on the next iter
+              if (bnid) {
+                frame.addBNode(bnid.nodeValue);
+                dom.removeAttributeNode(bnid);
+              } else {
+                frame.addBNode();
+              }
+            } else {
+              frame.addNode(about.nodeValue);
+              dom.removeAttributeNode(about);
+            } // Typed nodes
 
-    while (frame.parent) {
-      var dom = frame.element;
-      var attrs = dom.attributes;
 
-      if (dom.nodeType === RDFParser.nodeType.TEXT || dom.nodeType === RDFParser.nodeType.CDATA_SECTION) {
-        // we have a literal
-        if (frame.parent.nodeType === frame.NODE) {
-          // must have had attributes, store as rdf:value
-          frame.addArc(RDFParser.ns.RDF + 'value');
-          frame = this.buildFrame(frame);
-        }
+            var rdftype = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'type');
 
-        frame.addLiteral(dom.nodeValue);
-      } else if (elementURI(dom) !== RDFParser.ns.RDF + 'RDF') {
-        // not root
-        if (frame.parent && frame.parent.collection) {
-          // we're a collection element
-          frame.addCollectionArc();
-          frame = this.buildFrame(frame, frame.element);
-          frame.parent.element = null;
-        }
+            if (RDFParser.ns.RDF + 'Description' !== elementURI(dom)) {
+              rdftype = {
+                'nodeValue': elementURI(dom)
+              };
+            }
 
-        if (!frame.parent || !frame.parent.nodeType || frame.parent.nodeType === frame.ARC) {
-          // we need a node
-          var about = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'about');
-          rdfid = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'ID');
+            if (rdftype != null) {
+              this.store.add(frame.node, this.store.sym(RDFParser.ns.RDF + 'type'), this.store.sym(uriUtil.join(rdftype.nodeValue, frame.base)), this.why);
 
-          if (about && rdfid) {
-            throw new Error('RDFParser: ' + dom.nodeName + ' has both rdf:id and rdf:about.' + ' Halting. Only one of these' + ' properties may be specified on a' + ' node.');
-          }
+              if (rdftype.nodeName) {
+                dom.removeAttributeNode(rdftype);
+              }
+            } // Property Attributes
 
-          if (!about && rdfid) {
-            frame.addNode('#' + rdfid.nodeValue);
-            dom.removeAttributeNode(rdfid);
-          } else if (about == null && rdfid == null) {
-            var bnid = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'nodeID');
 
-            if (bnid) {
-              frame.addBNode(bnid.nodeValue);
-              dom.removeAttributeNode(bnid);
-            } else {
-              frame.addBNode();
+            for (var x = attrs.length - 1; x >= 0; x--) {
+              this.store.add(frame.node, this.store.sym(elementURI(attrs[x])), this.store.literal(attrs[x].nodeValue, frame.lang), this.why);
             }
           } else {
-            frame.addNode(about.nodeValue);
-            dom.removeAttributeNode(about);
-          } // Typed nodes
-
-
-          var rdftype = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'type');
+            // we should add an arc (or implicit bnode+arc)
+            frame.addArc(elementURI(dom)); // save the arc's rdf:ID if it has one
 
-          if (RDFParser.ns.RDF + 'Description' !== elementURI(dom)) {
-            rdftype = {
-              'nodeValue': elementURI(dom)
-            };
-          }
-
-          if (rdftype != null) {
-            this.store.add(frame.node, this.store.sym(RDFParser.ns.RDF + 'type'), this.store.sym(uriUtil.join(rdftype.nodeValue, frame.base)), this.why);
+            if (this.reify) {
+              rdfid = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'ID');
 
-            if (rdftype.nodeName) {
-              dom.removeAttributeNode(rdftype);
+              if (rdfid) {
+                frame.rdfid = rdfid.nodeValue;
+                dom.removeAttributeNode(rdfid);
+              }
             }
-          } // Property Attributes
 
+            var parsetype = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'parseType');
+            var datatype = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'datatype');
 
-          for (var x = attrs.length - 1; x >= 0; x--) {
-            this.store.add(frame.node, this.store.sym(elementURI(attrs[x])), this.store.literal(attrs[x].nodeValue, frame.lang), this.why);
-          }
-        } else {
-          // we should add an arc (or implicit bnode+arc)
-          frame.addArc(elementURI(dom)); // save the arc's rdf:ID if it has one
-
-          if (this.reify) {
-            rdfid = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'ID');
-
-            if (rdfid) {
-              frame.rdfid = rdfid.nodeValue;
-              dom.removeAttributeNode(rdfid);
+            if (datatype) {
+              frame.datatype = datatype.nodeValue;
+              dom.removeAttributeNode(datatype);
             }
-          }
 
-          var parsetype = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'parseType');
-          var datatype = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'datatype');
+            if (parsetype) {
+              var nv = parsetype.nodeValue;
 
-          if (datatype) {
-            frame.datatype = datatype.nodeValue;
-            dom.removeAttributeNode(datatype);
-          }
+              if (nv === 'Literal') {
+                frame.datatype = RDFParser.ns.RDF + 'XMLLiteral';
+                frame = this.buildFrame(frame); // Don't include the literal node, only its children
 
-          if (parsetype) {
-            var nv = parsetype.nodeValue;
-
-            if (nv === 'Literal') {
-              frame.datatype = RDFParser.ns.RDF + 'XMLLiteral';
-              frame = this.buildFrame(frame); // Don't include the literal node, only its children
-
-              frame.addLiteral(dom.childNodes);
-              dig = false;
-            } else if (nv === 'Resource') {
-              frame = this.buildFrame(frame, frame.element);
-              frame.parent.element = null;
-              frame.addBNode();
-            } else if (nv === 'Collection') {
-              frame = this.buildFrame(frame, frame.element);
-              frame.parent.element = null;
-              frame.addCollection();
-            }
+                frame.addLiteral(dom.childNodes);
+                dig = false;
+              } else if (nv === 'Resource') {
+                frame = this.buildFrame(frame, frame.element);
+                frame.parent.element = null;
+                frame.addBNode();
+              } else if (nv === 'Collection') {
+                frame = this.buildFrame(frame, frame.element);
+                frame.parent.element = null;
+                frame.addCollection();
+              }
 
-            dom.removeAttributeNode(parsetype);
-          }
+              dom.removeAttributeNode(parsetype);
+            }
 
-          if (attrs.length !== 0) {
-            var resource = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'resource');
-            var bnid2 = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'nodeID');
-            frame = this.buildFrame(frame);
+            if (attrs.length !== 0) {
+              var resource = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'resource');
+              var bnid2 = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, 'nodeID');
+              frame = this.buildFrame(frame);
 
-            if (resource) {
-              frame.addNode(resource.nodeValue);
-              dom.removeAttributeNode(resource);
-            } else {
-              if (bnid2) {
-                frame.addBNode(bnid2.nodeValue);
-                dom.removeAttributeNode(bnid2);
+              if (resource) {
+                frame.addNode(resource.nodeValue);
+                dom.removeAttributeNode(resource);
               } else {
-                frame.addBNode();
+                if (bnid2) {
+                  frame.addBNode(bnid2.nodeValue);
+                  dom.removeAttributeNode(bnid2);
+                } else {
+                  frame.addBNode();
+                }
               }
-            }
 
-            for (var x1 = attrs.length - 1; x1 >= 0; x1--) {
-              var f = this.buildFrame(frame);
-              f.addArc(elementURI(attrs[x1]));
+              for (var x1 = attrs.length - 1; x1 >= 0; x1--) {
+                var f = this.buildFrame(frame);
+                f.addArc(elementURI(attrs[x1]));
 
-              if (elementURI(attrs[x1]) === RDFParser.ns.RDF + 'type') {
-                this.buildFrame(f).addNode(attrs[x1].nodeValue);
-              } else {
-                this.buildFrame(f).addLiteral(attrs[x1].nodeValue);
+                if (elementURI(attrs[x1]) === RDFParser.ns.RDF + 'type') {
+                  this.buildFrame(f).addNode(attrs[x1].nodeValue);
+                } else {
+                  this.buildFrame(f).addLiteral(attrs[x1].nodeValue);
+                }
               }
+            } else if (dom.childNodes.length === 0) {
+              this.buildFrame(frame).addLiteral('');
             }
-          } else if (dom.childNodes.length === 0) {
-            this.buildFrame(frame).addLiteral('');
           }
-        }
-      } // rdf:RDF
-      // dig dug
-
-
-      dom = frame.element;
+        } // rdf:RDF
+        // dig dug
 
-      while (frame.parent) {
-        var pframe = frame;
-
-        while (dom == null) {
-          frame = frame.parent;
-          dom = frame.element;
-        }
 
-        var candidate = dom.childNodes && dom.childNodes[frame.lastChild];
+        dom = frame.element;
 
-        if (!candidate || !dig) {
-          frame.terminateFrame();
+        while (frame.parent) {
+          var pframe = frame;
 
-          if (!(frame = frame.parent)) {
-            break;
-          } // done
-
-
-          dom = frame.element;
-          dig = true;
-        } else if (candidate.nodeType !== RDFParser.nodeType.ELEMENT && candidate.nodeType !== RDFParser.nodeType.TEXT && candidate.nodeType !== RDFParser.nodeType.CDATA_SECTION || (candidate.nodeType === RDFParser.nodeType.TEXT || candidate.nodeType === RDFParser.nodeType.CDATA_SECTION) && dom.childNodes.length !== 1) {
-          frame.lastChild++;
-        } else {
-          // not a leaf
-          frame.lastChild++;
-          frame = this.buildFrame(pframe, dom.childNodes[frame.lastChild - 1]);
-          break;
-        }
-      }
-    } // while
+          while (dom == null) {
+            frame = frame.parent;
+            dom = frame.element;
+          }
 
-  };
-  /**
-   * Cleans out state from a previous parse run
-   * @private
-   */
+          var candidate = dom.childNodes && dom.childNodes[frame.lastChild];
 
+          if (!candidate || !dig) {
+            frame.terminateFrame();
 
-  this.cleanParser = function () {
-    this.bnodes = {};
-    this.why = null;
-  };
-  /**
-   * Builds scope frame
-   * @private
-   */
+            if (!(frame = frame.parent)) {
+              break;
+            } // done
 
 
-  this.buildFrame = function (parent, element) {
-    var frame = this.frameFactory(this, parent, element);
+            dom = frame.element;
+            dig = true;
+          } else if (candidate.nodeType !== RDFParser.nodeType.ELEMENT && candidate.nodeType !== RDFParser.nodeType.TEXT && candidate.nodeType !== RDFParser.nodeType.CDATA_SECTION || (candidate.nodeType === RDFParser.nodeType.TEXT || candidate.nodeType === RDFParser.nodeType.CDATA_SECTION) && dom.childNodes.length !== 1) {
+            frame.lastChild++;
+          } else {
+            // not a leaf
+            frame.lastChild++;
+            frame = this.buildFrame(pframe, dom.childNodes[frame.lastChild - 1]);
+            break;
+          }
+        }
+      } // while
 
-    if (parent) {
-      frame.base = parent.base;
-      frame.lang = parent.lang;
     }
-
-    if (!element || element.nodeType === RDFParser.nodeType.TEXT || element.nodeType === RDFParser.nodeType.CDATA_SECTION) {
-      return frame;
+    /**
+     * Cleans out state from a previous parse run
+     * @private
+     */
+
+  }, {
+    key: "cleanParser",
+    value: function cleanParser() {
+      this.bnodes = {};
+      this.why = null;
     }
+    /**
+     * Builds scope frame
+     * @private
+     */
+
+  }, {
+    key: "buildFrame",
+    value: function buildFrame(parent, element) {
+      var frame = this.frameFactory(this, parent, element);
+
+      if (parent) {
+        frame.base = parent.base;
+        frame.lang = parent.lang;
+      }
 
-    var attrs = element.attributes;
-    var base = element.getAttributeNode('xml:base');
+      if (!element || element.nodeType === RDFParser.nodeType.TEXT || element.nodeType === RDFParser.nodeType.CDATA_SECTION) {
+        return frame;
+      }
 
-    if (base != null) {
-      frame.base = base.nodeValue;
-      element.removeAttribute('xml:base');
-    }
+      var attrs = element.attributes;
+      var base = element.getAttributeNode('xml:base');
+
+      if (base != null) {
+        frame.base = base.nodeValue;
+        element.removeAttribute('xml:base');
+      }
 
-    var lang = element.getAttributeNode('xml:lang');
+      var lang = element.getAttributeNode('xml:lang');
 
-    if (lang != null) {
-      frame.lang = lang.nodeValue;
-      element.removeAttribute('xml:lang');
-    } // remove all extraneous xml and xmlns attributes
+      if (lang != null) {
+        frame.lang = lang.nodeValue;
+        element.removeAttribute('xml:lang');
+      } // remove all extraneous xml and xmlns attributes
 
 
-    for (var x = attrs.length - 1; x >= 0; x--) {
-      if (attrs[x].nodeName.substr(0, 3) === 'xml') {
-        if (attrs[x].name.slice(0, 6) === 'xmlns:') {
-          var uri = attrs[x].nodeValue; // alert('base for namespac attr:'+this.base)
+      for (var x = attrs.length - 1; x >= 0; x--) {
+        if (attrs[x].nodeName.substr(0, 3) === 'xml') {
+          if (attrs[x].name.slice(0, 6) === 'xmlns:') {
+            var uri = attrs[x].nodeValue; // alert('base for namespac attr:'+this.base)
 
-          if (this.base) uri = uriUtil.join(uri, this.base);
-          this.store.setPrefixForURI(attrs[x].name.slice(6), uri);
-        } //		alert('rdfparser: xml atribute: '+attrs[x].name) //@@
+            if (this.base) uri = uriUtil.join(uri, this.base);
+            this.store.setPrefixForURI(attrs[x].name.slice(6), uri);
+          } //		alert('rdfparser: xml atribute: '+attrs[x].name) //@@
 
 
-        element.removeAttributeNode(attrs[x]);
+          element.removeAttributeNode(attrs[x]);
+        }
       }
-    }
 
-    return frame;
-  };
-}
+      return frame;
+    }
+  }]);
+
+  return RDFParser;
+}();
+
+_defineProperty(RDFParser, "ns", {
+  'RDF': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+  'RDFS': 'http://www.w3.org/2000/01/rdf-schema#'
+});
+
+_defineProperty(RDFParser, "nodeType", {
+  'ELEMENT': 1,
+  'ATTRIBUTE': 2,
+  'TEXT': 3,
+  'CDATA_SECTION': 4,
+  'ENTITY_REFERENCE': 5,
+  'ENTITY': 6,
+  'PROCESSING_INSTRUCTION': 7,
+  'COMMENT': 8,
+  'DOCUMENT': 9,
+  'DOCUMENT_TYPE': 10,
+  'DOCUMENT_FRAGMENT': 11,
+  'NOTATION': 12
+});
+
+export { RDFParser as default };