rdflib 2.2.22 → 2.2.23-6384f9a2

package/esm/blank-node.js

@@ -1,4 +1,12 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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; } }
 import ClassOrder from './class-order';
 import Node from './node-internal';
 import { BlankNodeTermType } from './types';
@@ -6,79 +14,100 @@ import { BlankNodeTermType } from './types';
  * An RDF blank node is a Node without a URI
  * @link https://rdf.js.org/data-model-spec/#blanknode-interface
  */
-export default class BlankNode extends Node {
-  /**
-   * The next unique identifier for blank nodes
-   */
-
-  static getId(id) {
-    if (id) {
-      if (typeof id !== 'string') {
-        console.log('Bad blank id:', id);
-        throw new Error('Bad id argument to new blank node: ' + id);
-      }
-      if (id.includes('#')) {
-        // Is a URI with hash fragment
-        let fragments = id.split('#');
-        return fragments[fragments.length - 1];
-      }
-      return id;
-    }
-    return 'n' + BlankNode.nextId++;
-  }
+var BlankNode = /*#__PURE__*/function (_Node) {
+  _inherits(BlankNode, _Node);
+  var _super = _createSuper(BlankNode);
   /**
    * Initializes this node
    * @param [id] The identifier for the blank node
    */
-  constructor(id) {
-    super(BlankNode.getId(id));
-    _defineProperty(this, "termType", BlankNodeTermType);
-    _defineProperty(this, "classOrder", ClassOrder.BlankNode);
-    _defineProperty(this, "isBlank", 1);
-    _defineProperty(this, "isVar", 1);
+  function BlankNode(id) {
+    var _this;
+    _classCallCheck(this, BlankNode);
+    _this = _super.call(this, BlankNode.getId(id));
+    _defineProperty(_assertThisInitialized(_this), "termType", BlankNodeTermType);
+    _defineProperty(_assertThisInitialized(_this), "classOrder", ClassOrder.BlankNode);
+    _defineProperty(_assertThisInitialized(_this), "isBlank", 1);
+    _defineProperty(_assertThisInitialized(_this), "isVar", 1);
+    return _this;
   }
 
   /**
    * The identifier for the blank node
    */
-  get id() {
-    return this.value;
-  }
-  set id(value) {
-    this.value = value;
-  }
-  compareTerm(other) {
-    if (this.classOrder < other.classOrder) {
-      return -1;
+  _createClass(BlankNode, [{
+    key: "id",
+    get: function get() {
+      return this.value;
+    },
+    set: function set(value) {
+      this.value = value;
     }
-    if (this.classOrder > other.classOrder) {
-      return +1;
+  }, {
+    key: "compareTerm",
+    value: function compareTerm(other) {
+      if (this.classOrder < other.classOrder) {
+        return -1;
+      }
+      if (this.classOrder > other.classOrder) {
+        return +1;
+      }
+      if (this.id < other.id) {
+        return -1;
+      }
+      if (this.id > other.id) {
+        return +1;
+      }
+      return 0;
     }
-    if (this.id < other.id) {
-      return -1;
+
+    /**
+     * Gets a copy of this blank node in the specified formula
+     * @param formula The formula
+     */
+  }, {
+    key: "copy",
+    value: function copy(formula) {
+      // depends on the formula
+      var bnodeNew = new BlankNode();
+      formula.copyTo(this, bnodeNew);
+      return bnodeNew;
     }
-    if (this.id > other.id) {
-      return +1;
+  }, {
+    key: "toCanonical",
+    value: function toCanonical() {
+      return BlankNode.NTAnonymousNodePrefix + this.value;
     }
-    return 0;
-  }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return BlankNode.NTAnonymousNodePrefix + this.id;
+    }
+  }], [{
+    key: "getId",
+    value:
+    /**
+     * The next unique identifier for blank nodes
+     */
 
-  /**
-   * Gets a copy of this blank node in the specified formula
-   * @param formula The formula
-   */
-  copy(formula) {
-    // depends on the formula
-    var bnodeNew = new BlankNode();
-    formula.copyTo(this, bnodeNew);
-    return bnodeNew;
-  }
-  toCanonical() {
-    return BlankNode.NTAnonymousNodePrefix + this.value;
-  }
-  toString() {
-    return BlankNode.NTAnonymousNodePrefix + this.id;
-  }
-}
+    function getId(id) {
+      if (id) {
+        if (typeof id !== 'string') {
+          console.log('Bad blank id:', id);
+          throw new Error('Bad id argument to new blank node: ' + id);
+        }
+        if (id.includes('#')) {
+          // Is a URI with hash fragment
+          var fragments = id.split('#');
+          return fragments[fragments.length - 1];
+        }
+        return id;
+      }
+      return 'n' + BlankNode.nextId++;
+    }
+  }]);
+  return BlankNode;
+}(Node);
 _defineProperty(BlankNode, "nextId", 0);
-_defineProperty(BlankNode, "NTAnonymousNodePrefix", '_:');
+_defineProperty(BlankNode, "NTAnonymousNodePrefix", '_:');
+export { BlankNode as default };

package/esm/class-order.js

@@ -1,7 +1,7 @@
 /**
 * Class orders
 */
-const ClassOrder = {
+var ClassOrder = {
   'Literal': 1,
   'Collection': 3,
   'Graph': 4,

package/esm/collection.js

@@ -1,4 +1,12 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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; } }
 import RdflibBlankNode from './blank-node';
 import ClassOrder from './class-order';
 import Literal from './literal';
@@ -32,86 +40,114 @@ export function fromValue(value) {
  *
  * Use generic T to control the contents of the array.
  */
-export default class Collection extends Node {
+var Collection = /*#__PURE__*/function (_Node) {
+  _inherits(Collection, _Node);
+  var _super = _createSuper(Collection);
   /**
    * The nodes in this collection
    */
 
-  constructor(initial) {
-    super((RdflibBlankNode.nextId++).toString());
-    _defineProperty(this, "termType", CollectionTermType);
-    _defineProperty(this, "classOrder", ClassOrder.Collection);
-    _defineProperty(this, "closed", false);
-    _defineProperty(this, "compareTerm", RdflibBlankNode.prototype.compareTerm);
-    _defineProperty(this, "elements", []);
-    _defineProperty(this, "isVar", 0);
+  function Collection(initial) {
+    var _this;
+    _classCallCheck(this, Collection);
+    _this = _super.call(this, (RdflibBlankNode.nextId++).toString());
+    _defineProperty(_assertThisInitialized(_this), "termType", CollectionTermType);
+    _defineProperty(_assertThisInitialized(_this), "classOrder", ClassOrder.Collection);
+    _defineProperty(_assertThisInitialized(_this), "closed", false);
+    _defineProperty(_assertThisInitialized(_this), "compareTerm", RdflibBlankNode.prototype.compareTerm);
+    _defineProperty(_assertThisInitialized(_this), "elements", []);
+    _defineProperty(_assertThisInitialized(_this), "isVar", 0);
     if (initial && initial.length > 0) {
-      initial.forEach(element => {
-        this.elements.push(fromValue(element));
+      initial.forEach(function (element) {
+        _this.elements.push(fromValue(element));
       });
     }
+    return _this;
   }
-  get id() {
-    return this.value;
-  }
-  set id(value) {
-    this.value = value;
-  }
-
-  /**
-   * Appends an element to this collection
-   * @param element - The new element
-   */
-  append(element) {
-    return this.elements.push(element);
-  }
+  _createClass(Collection, [{
+    key: "id",
+    get: function get() {
+      return this.value;
+    },
+    set: function set(value) {
+      this.value = value;
+    }
 
-  /**
-   * Closes this collection
-   */
-  close() {
-    this.closed = true;
-    return this.closed;
-  }
+    /**
+     * Appends an element to this collection
+     * @param element - The new element
+     */
+  }, {
+    key: "append",
+    value: function append(element) {
+      return this.elements.push(element);
+    }
 
-  /**
-   * Removes the first element from the collection (and return it)
-   */
-  shift() {
-    return this.elements.shift();
-  }
+    /**
+     * Closes this collection
+     */
+  }, {
+    key: "close",
+    value: function close() {
+      this.closed = true;
+      return this.closed;
+    }
 
-  /**
-   * Creates a new Collection with the substituting bindings applied
-   * @param bindings - The bindings to substitute
-   */
-  substitute(bindings) {
-    const elementsCopy = this.elements.map(ea => ea.substitute(bindings));
-    return new Collection(elementsCopy);
-  }
-  toNT() {
-    return Collection.toNT(this);
-  }
-  static toNT(collection) {
-    // return '(' + collection.elements.map(x => x.toNT()).join(' ') + ')'
-    // As lists are not in NT and toNT() must be a reversible function, we kludge it for a list
-    return RdflibBlankNode.NTAnonymousNodePrefix + collection.id;
-  }
+    /**
+     * Removes the first element from the collection (and return it)
+     */
+  }, {
+    key: "shift",
+    value: function shift() {
+      return this.elements.shift();
+    }
 
-  /**
-   * Serializes the collection to a string.
-   * Surrounded by (parentheses) and separated by spaces.
-   */
-  toString() {
-    return '(' + this.elements.join(' ') + ')';
-  }
+    /**
+     * Creates a new Collection with the substituting bindings applied
+     * @param bindings - The bindings to substitute
+     */
+  }, {
+    key: "substitute",
+    value: function substitute(bindings) {
+      var elementsCopy = this.elements.map(function (ea) {
+        return ea.substitute(bindings);
+      });
+      return new Collection(elementsCopy);
+    }
+  }, {
+    key: "toNT",
+    value: function toNT() {
+      return Collection.toNT(this);
+    }
+  }, {
+    key: "toString",
+    value:
+    /**
+     * Serializes the collection to a string.
+     * Surrounded by (parentheses) and separated by spaces.
+     */
+    function toString() {
+      return '(' + this.elements.join(' ') + ')';
+    }
 
-  /**
-   * Prepends the specified element to the collection's front
-   * @param element - The element to prepend
-   */
-  unshift(element) {
-    return this.elements.unshift(element);
-  }
-}
-_defineProperty(Collection, "termType", CollectionTermType);
+    /**
+     * Prepends the specified element to the collection's front
+     * @param element - The element to prepend
+     */
+  }, {
+    key: "unshift",
+    value: function unshift(element) {
+      return this.elements.unshift(element);
+    }
+  }], [{
+    key: "toNT",
+    value: function toNT(collection) {
+      // return '(' + collection.elements.map(x => x.toNT()).join(' ') + ')'
+      // As lists are not in NT and toNT() must be a reversible function, we kludge it for a list
+      return RdflibBlankNode.NTAnonymousNodePrefix + collection.id;
+    }
+  }]);
+  return Collection;
+}(Node);
+_defineProperty(Collection, "termType", CollectionTermType);
+export { Collection as default };

package/esm/default-graph.js

@@ -1,23 +1,43 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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; } }
 import Node from './node-internal';
 import { DefaultGraphTermType } from './types';
 import { defaultGraphURI } from './utils/default-graph-uri';
 
 /** The RDF default graph */
-export default class DefaultGraph extends Node {
-  constructor() {
-    super('');
-    _defineProperty(this, "value", '');
-    _defineProperty(this, "termType", DefaultGraphTermType);
-    _defineProperty(this, "uri", defaultGraphURI);
+var DefaultGraph = /*#__PURE__*/function (_Node) {
+  _inherits(DefaultGraph, _Node);
+  var _super = _createSuper(DefaultGraph);
+  function DefaultGraph() {
+    var _this;
+    _classCallCheck(this, DefaultGraph);
+    _this = _super.call(this, '');
+    _defineProperty(_assertThisInitialized(_this), "value", '');
+    _defineProperty(_assertThisInitialized(_this), "termType", DefaultGraphTermType);
+    _defineProperty(_assertThisInitialized(_this), "uri", defaultGraphURI);
+    return _this;
   }
-  toCanonical() {
-    return this.value;
-  }
-  toString() {
-    return 'DefaultGraph';
-  }
-}
+  _createClass(DefaultGraph, [{
+    key: "toCanonical",
+    value: function toCanonical() {
+      return this.value;
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return 'DefaultGraph';
+    }
+  }]);
+  return DefaultGraph;
+}(Node);
+export { DefaultGraph as default };
 export function isDefaultGraph(object) {
   return !!object && object.termType === DefaultGraphTermType;
 }

package/esm/empty.js

@@ -1,15 +1,33 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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; } }
 import Node from './node-internal';
 import { EmptyTermType } from './types';
 /**
 * An empty node
 */
-export default class Empty extends Node {
-  constructor() {
-    super('');
-    _defineProperty(this, "termType", EmptyTermType);
+var Empty = /*#__PURE__*/function (_Node) {
+  _inherits(Empty, _Node);
+  var _super = _createSuper(Empty);
+  function Empty() {
+    var _this;
+    _classCallCheck(this, Empty);
+    _this = _super.call(this, '');
+    _defineProperty(_assertThisInitialized(_this), "termType", EmptyTermType);
+    return _this;
   }
-  toString() {
-    return '()';
-  }
-}
+  _createClass(Empty, [{
+    key: "toString",
+    value: function toString() {
+      return '()';
+    }
+  }]);
+  return Empty;
+}(Node);
+export { Empty as default };

package/esm/factories/canonical-data-factory.js

@@ -1,3 +1,5 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+var _supports;
 import BlankNode from '../blank-node';
 import Literal from '../literal';
 import NamedNode from '../named-node';
@@ -12,31 +14,25 @@ export { defaultGraphURI } from '../utils/default-graph-uri';
 /**
  * Gets the default graph
  */
-const defaultGraph = new DefaultGraph();
+var _defaultGraph = new DefaultGraph();
 
 /** A basic internal RDFlib datafactory, which does not support Collections  */
-const CanonicalDataFactory = {
-  supports: {
-    [Feature.collections]: false,
-    [Feature.defaultGraphType]: false,
-    [Feature.equalsMethod]: true,
-    [Feature.identity]: false,
-    [Feature.id]: true,
-    [Feature.reversibleId]: false,
-    [Feature.variableType]: true
-  },
+var CanonicalDataFactory = {
+  supports: (_supports = {}, _defineProperty(_supports, Feature.collections, false), _defineProperty(_supports, Feature.defaultGraphType, false), _defineProperty(_supports, Feature.equalsMethod, true), _defineProperty(_supports, Feature.identity, false), _defineProperty(_supports, Feature.id, true), _defineProperty(_supports, Feature.reversibleId, false), _defineProperty(_supports, Feature.variableType, true), _supports),
   /**
    * Creates a new blank node
    * @param value - The blank node's identifier
    */
-  blankNode(value) {
+  blankNode: function blankNode(value) {
     return new BlankNode(value);
   },
-  defaultGraph: () => defaultGraph,
+  defaultGraph: function defaultGraph() {
+    return _defaultGraph;
+  },
   /**
    * Compares to (rdf) objects for equality.
    */
-  equals(a, b) {
+  equals: function equals(a, b) {
     if (a === b || !a || !b) {
       return true;
     }
@@ -59,7 +55,7 @@ const CanonicalDataFactory = {
    * @example Use this to associate data with a term in an object
    *   { obj[id(term)] = "myData" }
    */
-  id(term) {
+  id: function id(term) {
     if (!term) {
       return 'undefined';
     }
@@ -72,14 +68,14 @@ const CanonicalDataFactory = {
       case VariableTermType:
         return Variable.toString(term);
       default:
-        const nq = this.termToNQ(term);
+        var nq = this.termToNQ(term);
         if (nq) {
           return nq;
         }
-        throw new Error(`Can't id term with type '${term.termType}'`);
+        throw new Error("Can't id term with type '".concat(term.termType, "'"));
     }
   },
-  isQuad(obj) {
+  isQuad: function isQuad(obj) {
     return obj instanceof Statement;
   },
   /**
@@ -87,11 +83,11 @@ const CanonicalDataFactory = {
    * @param value - The lexical value
    * @param languageOrDatatype - Either the language or the datatype
    */
-  literal(value, languageOrDatatype) {
+  literal: function literal(value, languageOrDatatype) {
     if (typeof value !== "string" && !languageOrDatatype) {
       return Literal.fromValue(value);
     }
-    const strValue = typeof value === 'string' ? value : '' + value;
+    var strValue = typeof value === 'string' ? value : '' + value;
     if (typeof languageOrDatatype === 'string') {
       if (languageOrDatatype.indexOf(':') === -1) {
         return new Literal(strValue, languageOrDatatype);
@@ -106,7 +102,7 @@ const CanonicalDataFactory = {
    * Creates a new named node
    * @param value - The new named node
    */
-  namedNode(value) {
+  namedNode: function namedNode(value) {
     return new NamedNode(value);
   },
   /**
@@ -116,8 +112,8 @@ const CanonicalDataFactory = {
    * @param object - The object
    * @param graph - The containing graph
    */
-  quad(subject, predicate, object, graph) {
-    return new Statement(subject, predicate, object, graph || defaultGraph);
+  quad: function quad(subject, predicate, object, graph) {
+    return new Statement(subject, predicate, object, graph || _defaultGraph);
   },
   /**
    * Creates a new statement
@@ -126,14 +122,14 @@ const CanonicalDataFactory = {
    * @param object - The object
    * @param graph - The containing graph
    */
-  triple(subject, predicate, object, graph) {
+  triple: function triple(subject, predicate, object, graph) {
     return this.quad(subject, predicate, object, graph);
   },
-  quadToNQ(q) {
-    return `${this.termToNQ(q.subject)} ${this.termToNQ(q.predicate)} ${this.termToNQ(q.object)} ${this.termToNQ(q.graph)} .`;
+  quadToNQ: function quadToNQ(q) {
+    return "".concat(this.termToNQ(q.subject), " ").concat(this.termToNQ(q.predicate), " ").concat(this.termToNQ(q.object), " ").concat(this.termToNQ(q.graph), " .");
   },
-  /** Stringify a {term} to n-quads serialization. */
-  termToNQ(term) {
+  /** Stringify a {term} to n-quads serialization. */termToNQ: function termToNQ(term) {
+    var _this = this;
     switch (term.termType) {
       case BlankNodeTermType:
         return '_:' + term.value;
@@ -147,13 +143,14 @@ const CanonicalDataFactory = {
       case NamedNodeTermType:
         return '<' + term.value + '>';
       case CollectionTermType:
-        return '(' + term.elements.map(t => this.termToNQ(t)).join(' ') + ')';
+        return '(' + term.elements.map(function (t) {
+          return _this.termToNQ(t);
+        }).join(' ') + ')';
       default:
-        throw new Error(`Can't serialize nonstandard term type (was '${term.termType}')`);
+        throw new Error("Can't serialize nonstandard term type (was '".concat(term.termType, "')"));
     }
   },
-  /** Convert an rdf object (term or quad) to n-quads serialization. */
-  toNQ(term) {
+  /** Convert an rdf object (term or quad) to n-quads serialization. */toNQ: function toNQ(term) {
     if (this.isQuad(term)) {
       return this.quadToNQ(term);
     }
@@ -163,7 +160,7 @@ const CanonicalDataFactory = {
    * Creates a new variable
    * @param name - The name for the variable
    */
-  variable(name) {
+  variable: function variable(name) {
     return new Variable(name);
   }
 };