rdflib 2.2.34 → 2.2.35-0ebb696c

package/lib/lists.js

@@ -10,10 +10,10 @@ exports.substituteNillsInDoc = substituteNillsInDoc;
 var _collection = _interopRequireDefault(require("./collection"));
 var _statement = _interopRequireDefault(require("./statement"));
 var _namespace = _interopRequireDefault(require("./namespace"));
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } /* Lists form conversion
-                                                                                                                                                                                    */ // import DataFactory from './factories/extended-term-factory'
+/* Lists form conversion
+*/
+
+// import DataFactory from './factories/extended-term-factory'
 // import jsonldParser from './jsonldparser'
 // @ts-ignore is this injected?
 // @@ Goal: remove this dependency
@@ -22,12 +22,17 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
 // import RDFParser from './rdfxmlparser'
 // import sparqlUpdateParser from './patch-parser'
 // import * as Util from './utils-js'
+
 // import BlankNode from './blank-node'
 // import NamedNode from './named-node'
+
 // import Formula from './formula'
+
 // import { ContentType, TurtleContentType, N3ContentType, RDFXMLContentType, XHTMLContentType, HTMLContentType, SPARQLUpdateContentType, SPARQLUpdateSingleMatchContentType, JSONLDContentType, NQuadsContentType, NQuadsAltContentType } from './types'
+
 // import { Quad } from './tf-types'
-var RDF = (0, _namespace.default)('http://www.w3.org/1999/02/22-rdf-syntax-ns#');
+
+const RDF = (0, _namespace.default)('http://www.w3.org/1999/02/22-rdf-syntax-ns#');
 
 /* Replace a given node with another node throughout a given document
 *
@@ -35,83 +40,38 @@ var RDF = (0, _namespace.default)('http://www.w3.org/1999/02/22-rdf-syntax-ns#')
 */
 function substituteInDoc(store, x, y, doc) {
   // console.log(`substituteInDoc put ${x} for ${y} in ${doc}}`)
-  var _iterator = _createForOfIteratorHelper(store.statementsMatching(y, null, null, doc)),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var quad = _step.value;
-      var newStatement = new _statement.default(x, quad.predicate, quad.object, doc);
-      store.remove(quad);
-      store.add(newStatement);
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+  for (const quad of store.statementsMatching(y, null, null, doc)) {
+    const newStatement = new _statement.default(x, quad.predicate, quad.object, doc);
+    store.remove(quad);
+    store.add(newStatement);
   }
-  var _iterator2 = _createForOfIteratorHelper(store.statementsMatching(null, y, null, doc)),
-    _step2;
-  try {
-    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-      var _quad = _step2.value;
-      store.remove(_quad);
-      // console.log(`  substituteInDoc predicate ${x} in ${quad}}`)
-      store.add(new _statement.default(_quad.subject, x, _quad.object, doc));
-    }
-  } catch (err) {
-    _iterator2.e(err);
-  } finally {
-    _iterator2.f();
+  for (const quad of store.statementsMatching(null, y, null, doc)) {
+    store.remove(quad);
+    // console.log(`  substituteInDoc predicate ${x} in ${quad}}`)
+    store.add(new _statement.default(quad.subject, x, quad.object, doc));
   }
-  var _iterator3 = _createForOfIteratorHelper(store.statementsMatching(null, null, y, doc)),
-    _step3;
-  try {
-    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-      var _quad2 = _step3.value;
-      store.remove(_quad2);
-      store.add(new _statement.default(_quad2.subject, _quad2.predicate, x, doc));
-    }
-  } catch (err) {
-    _iterator3.e(err);
-  } finally {
-    _iterator3.f();
+  for (const quad of store.statementsMatching(null, null, y, doc)) {
+    store.remove(quad);
+    store.add(new _statement.default(quad.subject, quad.predicate, x, doc));
   }
 }
 
 /* Change all lone rdf:nil nodes into empty Collections
 */
 function substituteNillsInDoc(store, doc) {
-  var x = RDF('nil');
-  var _iterator4 = _createForOfIteratorHelper(store.statementsMatching(x, null, null, doc)),
-    _step4;
-  try {
-    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
-      var quad = _step4.value;
-      store.remove(quad);
-      var y = new _collection.default();
-      store.add(new _statement.default(y, quad.predicate, quad.object, doc));
-    }
-  } catch (err) {
-    _iterator4.e(err);
-  } finally {
-    _iterator4.f();
+  const x = RDF('nil');
+  for (const quad of store.statementsMatching(x, null, null, doc)) {
+    store.remove(quad);
+    const y = new _collection.default();
+    store.add(new _statement.default(y, quad.predicate, quad.object, doc));
   }
-  var _iterator5 = _createForOfIteratorHelper(store.statementsMatching(null, null, x, doc)),
-    _step5;
-  try {
-    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-      var _quad3 = _step5.value;
-      if (!_quad3.predicate.sameTerm(RDF('rest'))) {
-        // If not a tail
-        store.remove(_quad3);
-        var _y = new _collection.default();
-        store.add(new _statement.default(_quad3.subject, _quad3.predicate, _y, doc));
-      }
+  for (const quad of store.statementsMatching(null, null, x, doc)) {
+    if (!quad.predicate.sameTerm(RDF('rest'))) {
+      // If not a tail
+      store.remove(quad);
+      const y = new _collection.default();
+      store.add(new _statement.default(quad.subject, quad.predicate, y, doc));
     }
-  } catch (err) {
-    _iterator5.e(err);
-  } finally {
-    _iterator5.f();
   }
 }
 /**
@@ -126,34 +86,34 @@ function substituteNillsInDoc(store, doc) {
 function convertFirstRestNil(store, doc // Do whole store?
 ) {
   function preceding(ele, listSoFar, trash) {
-    var rests = store.statementsMatching(ele, RDF('rest'), null, doc);
-    if (rests.length !== 1) throw new Error("Bad list structure: no rest at ".concat(ele));
-    var firsts = store.statementsMatching(ele, RDF('first'), null, doc);
-    if (firsts.length !== 1) throw new Error("Bad list structure: rest but ".concat(firsts.length, " firsts at ").concat(ele));
-    var value = firsts[0].object;
-    var total = [value].concat(listSoFar);
+    const rests = store.statementsMatching(ele, RDF('rest'), null, doc);
+    if (rests.length !== 1) throw new Error(`Bad list structure: no rest at ${ele}`);
+    const firsts = store.statementsMatching(ele, RDF('first'), null, doc);
+    if (firsts.length !== 1) throw new Error(`Bad list structure: rest but ${firsts.length} firsts at ${ele}`);
+    const value = firsts[0].object;
+    const total = [value].concat(listSoFar);
     // console.log('  List now is: ', total)
-    var totalTrash = trash.concat(rests).concat(firsts);
-    var pres = store.statementsMatching(null, RDF('rest'), ele, doc);
+    const totalTrash = trash.concat(rests).concat(firsts);
+    const pres = store.statementsMatching(null, RDF('rest'), ele, doc);
     if (pres.length === 0) {
       // Head of the list
-      var newList = new _collection.default(total);
+      const newList = new _collection.default(total);
       store.remove(totalTrash);
       // Replace old list with new list:
       substituteInDoc(store, newList, ele, doc);
       return;
     }
-    if (pres.length !== 1) throw new Error("Bad list structure: ".concat(pres.length, " pres at ").concat(ele));
-    var pre = pres[0].subject;
-    if (pre.termType !== 'BlankNode') throw new Error("Bad list element node ".concat(pre, " type: ").concat(pre.termType, " "));
+    if (pres.length !== 1) throw new Error(`Bad list structure: ${pres.length} pres at ${ele}`);
+    const pre = pres[0].subject;
+    if (pre.termType !== 'BlankNode') throw new Error(`Bad list element node ${pre} type: ${pre.termType} `);
     preceding(pre, total, totalTrash);
     return;
   }
   substituteNillsInDoc(store, doc); // lone ones only
 
-  var tails = store.statementsMatching(null, RDF('rest'), RDF('nil'), doc);
-  tails.forEach(function (tail) {
-    if (tail.subject.termType !== 'BlankNode') throw new Error("Bad list element node ".concat(tail.subject, " type: ").concat(tail.subject.termType, " "));
+  const tails = store.statementsMatching(null, RDF('rest'), RDF('nil'), doc);
+  tails.forEach(tail => {
+    if (tail.subject.termType !== 'BlankNode') throw new Error(`Bad list element node ${tail.subject} type: ${tail.subject.termType} `);
     preceding(tail.subject, [], []);
   });
 }

package/lib/literal.js

@@ -5,13 +5,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
-var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
-var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
-var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _classOrder = _interopRequireDefault(require("./class-order"));
 var _namedNode = _interopRequireDefault(require("./named-node"));
@@ -19,191 +12,162 @@ var _nodeInternal = _interopRequireDefault(require("./node-internal"));
 var _types = require("./types");
 var _terms = require("./utils/terms");
 var _xsdInternal = _interopRequireDefault(require("./xsd-internal"));
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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; } }
 /**
  * An RDF literal, containing some value which isn't expressed as an IRI.
  * @link https://rdf.js.org/data-model-spec/#literal-interface
  */
-var Literal = /*#__PURE__*/function (_Node) {
-  (0, _inherits2.default)(Literal, _Node);
-  var _super = _createSuper(Literal);
+class Literal extends _nodeInternal.default {
   /**
    * Initializes a literal
    * @param value - The literal's lexical value
    * @param language - The language for the literal. Defaults to ''.
    * @param datatype - The literal's datatype as a named node. Defaults to xsd:string.
    */
-  function Literal(value, language, datatype) {
-    var _this;
-    (0, _classCallCheck2.default)(this, Literal);
-    _this = _super.call(this, value);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "termType", _types.LiteralTermType);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "classOrder", _classOrder.default.Literal);
+  constructor(value, language, datatype) {
+    super(value);
+    (0, _defineProperty2.default)(this, "termType", _types.LiteralTermType);
+    (0, _defineProperty2.default)(this, "classOrder", _classOrder.default.Literal);
     /**
      * The literal's datatype as a named node
      */
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "datatype", _xsdInternal.default.string);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "isVar", 0);
+    (0, _defineProperty2.default)(this, "datatype", _xsdInternal.default.string);
+    (0, _defineProperty2.default)(this, "isVar", 0);
     /**
      * The language for the literal
      */
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "language", '');
+    (0, _defineProperty2.default)(this, "language", '');
     if (language) {
-      _this.language = language;
-      _this.datatype = _xsdInternal.default.langString;
+      this.language = language;
+      this.datatype = _xsdInternal.default.langString;
     } else if (datatype) {
-      _this.datatype = _namedNode.default.fromValue(datatype);
+      this.datatype = _namedNode.default.fromValue(datatype);
     } else {
-      _this.datatype = _xsdInternal.default.string;
+      this.datatype = _xsdInternal.default.string;
     }
-    return _this;
   }
 
   /**
    * Gets a copy of this literal
    */
-  (0, _createClass2.default)(Literal, [{
-    key: "copy",
-    value: function copy() {
-      return new Literal(this.value, this.lang, this.datatype);
-    }
+  copy() {
+    return new Literal(this.value, this.lang, this.datatype);
+  }
 
-    /**
-     * Gets whether two literals are the same
-     * @param other The other statement
-     */
-  }, {
-    key: "equals",
-    value: function equals(other) {
-      if (!other) {
-        return false;
-      }
-      return this.termType === other.termType && this.value === other.value && this.language === other.language && (!this.datatype && !other.datatype || this.datatype && this.datatype.equals(other.datatype));
+  /**
+   * Gets whether two literals are the same
+   * @param other The other statement
+   */
+  equals(other) {
+    if (!other) {
+      return false;
     }
+    return this.termType === other.termType && this.value === other.value && this.language === other.language && (!this.datatype && !other.datatype || this.datatype && this.datatype.equals(other.datatype));
+  }
 
-    /**
-     * The language for the literal
-     * @deprecated use {language} instead
-     */
-  }, {
-    key: "lang",
-    get: function get() {
-      return this.language;
-    },
-    set: function set(language) {
-      this.language = language || '';
+  /**
+   * The language for the literal
+   * @deprecated use {language} instead
+   */
+  get lang() {
+    return this.language;
+  }
+  set lang(language) {
+    this.language = language || '';
+  }
+  toNT() {
+    return Literal.toNT(this);
+  }
+
+  /** Serializes a literal to an N-Triples string */
+  static toNT(literal) {
+    if (typeof literal.value === 'number') {
+      return '' + literal.value;
+    } else if (typeof literal.value !== 'string') {
+      throw new Error('Value of RDF literal is not string or number: ' + literal.value);
     }
-  }, {
-    key: "toNT",
-    value: function toNT() {
-      return Literal.toNT(this);
+    var str = literal.value;
+    // #x22 ("), #x5C (\), #x0A (\n) and #xD (\r) are disallowed and need to be replaced
+    // see https://www.w3.org/TR/n-triples/#grammar-production-STRING_LITERAL_QUOTE
+    str = str.replace(/\\/g, '\\\\');
+    str = str.replace(/\"/g, '\\"');
+    str = str.replace(/\n/g, '\\n');
+    str = str.replace(/\r/g, '\\r');
+    str = '"' + str + '"';
+    if (literal.language) {
+      str += '@' + literal.language;
+    } else if (!literal.datatype.equals(_xsdInternal.default.string)) {
+      // Only add datatype if it's not a string
+      str += '^^' + literal.datatype.toCanonical();
     }
+    return str;
+  }
+  toString() {
+    return '' + this.value;
+  }
 
-    /** Serializes a literal to an N-Triples string */
-  }, {
-    key: "toString",
-    value: function toString() {
-      return '' + this.value;
-    }
+  /**
+   * Builds a literal node from a boolean value
+   * @param value - The value
+   */
+  static fromBoolean(value) {
+    let strValue = value ? '1' : '0';
+    return new Literal(strValue, null, _xsdInternal.default.boolean);
+  }
 
-    /**
-     * Builds a literal node from a boolean value
-     * @param value - The value
-     */
-  }], [{
-    key: "toNT",
-    value: function toNT(literal) {
-      if (typeof literal.value === 'number') {
-        return '' + literal.value;
-      } else if (typeof literal.value !== 'string') {
-        throw new Error('Value of RDF literal is not string or number: ' + literal.value);
-      }
-      var str = literal.value;
-      // #x22 ("), #x5C (\), #x0A (\n) and #xD (\r) are disallowed and need to be replaced
-      // see https://www.w3.org/TR/n-triples/#grammar-production-STRING_LITERAL_QUOTE
-      str = str.replace(/\\/g, '\\\\');
-      str = str.replace(/\"/g, '\\"');
-      str = str.replace(/\n/g, '\\n');
-      str = str.replace(/\r/g, '\\r');
-      str = '"' + str + '"';
-      if (literal.language) {
-        str += '@' + literal.language;
-      } else if (!literal.datatype.equals(_xsdInternal.default.string)) {
-        // Only add datatype if it's not a string
-        str += '^^' + literal.datatype.toCanonical();
-      }
-      return str;
-    }
-  }, {
-    key: "fromBoolean",
-    value: function fromBoolean(value) {
-      var strValue = value ? '1' : '0';
-      return new Literal(strValue, null, _xsdInternal.default.boolean);
+  /**
+   * Builds a literal node from a date value
+   * @param value The value
+   */
+  static fromDate(value) {
+    if (!(value instanceof Date)) {
+      throw new TypeError('Invalid argument to Literal.fromDate()');
     }
+    let d2 = function (x) {
+      return ('' + (100 + x)).slice(1, 3);
+    };
+    let date = '' + value.getUTCFullYear() + '-' + d2(value.getUTCMonth() + 1) + '-' + d2(value.getUTCDate()) + 'T' + d2(value.getUTCHours()) + ':' + d2(value.getUTCMinutes()) + ':' + d2(value.getUTCSeconds()) + 'Z';
+    return new Literal(date, null, _xsdInternal.default.dateTime);
+  }
 
-    /**
-     * Builds a literal node from a date value
-     * @param value The value
-     */
-  }, {
-    key: "fromDate",
-    value: function fromDate(value) {
-      if (!(value instanceof Date)) {
-        throw new TypeError('Invalid argument to Literal.fromDate()');
-      }
-      var d2 = function d2(x) {
-        return ('' + (100 + x)).slice(1, 3);
-      };
-      var date = '' + value.getUTCFullYear() + '-' + d2(value.getUTCMonth() + 1) + '-' + d2(value.getUTCDate()) + 'T' + d2(value.getUTCHours()) + ':' + d2(value.getUTCMinutes()) + ':' + d2(value.getUTCSeconds()) + 'Z';
-      return new Literal(date, null, _xsdInternal.default.dateTime);
+  /**
+   * Builds a literal node from a number value
+   * @param value - The value
+   */
+  static fromNumber(value) {
+    if (typeof value !== 'number') {
+      throw new TypeError('Invalid argument to Literal.fromNumber()');
     }
-
-    /**
-     * Builds a literal node from a number value
-     * @param value - The value
-     */
-  }, {
-    key: "fromNumber",
-    value: function fromNumber(value) {
-      if (typeof value !== 'number') {
-        throw new TypeError('Invalid argument to Literal.fromNumber()');
-      }
-      var datatype;
-      var strValue = value.toString();
-      if (strValue.indexOf('e') < 0 && Math.abs(value) <= Number.MAX_SAFE_INTEGER) {
-        datatype = Number.isInteger(value) ? _xsdInternal.default.integer : _xsdInternal.default.decimal;
-      } else {
-        datatype = _xsdInternal.default.double;
-      }
-      return new Literal(strValue, null, datatype);
+    let datatype;
+    const strValue = value.toString();
+    if (strValue.indexOf('e') < 0 && Math.abs(value) <= Number.MAX_SAFE_INTEGER) {
+      datatype = Number.isInteger(value) ? _xsdInternal.default.integer : _xsdInternal.default.decimal;
+    } else {
+      datatype = _xsdInternal.default.double;
     }
+    return new Literal(strValue, null, datatype);
+  }
 
-    /**
-     * Builds a literal node from an input value
-     * @param value - The input value
-     */
-  }, {
-    key: "fromValue",
-    value: function fromValue(value) {
-      if ((0, _terms.isLiteral)(value)) {
-        return value;
-      }
-      switch ((0, _typeof2.default)(value)) {
-        case 'object':
-          if (value instanceof Date) {
-            return Literal.fromDate(value);
-          }
-        case 'boolean':
-          return Literal.fromBoolean(value);
-        case 'number':
-          return Literal.fromNumber(value);
-        case 'string':
-          return new Literal(value);
-      }
-      throw new Error("Can't make literal from " + value + ' of type ' + (0, _typeof2.default)(value));
+  /**
+   * Builds a literal node from an input value
+   * @param value - The input value
+   */
+  static fromValue(value) {
+    if ((0, _terms.isLiteral)(value)) {
+      return value;
     }
-  }]);
-  return Literal;
-}(_nodeInternal.default);
+    switch (typeof value) {
+      case 'object':
+        if (value instanceof Date) {
+          return Literal.fromDate(value);
+        }
+      case 'boolean':
+        return Literal.fromBoolean(value);
+      case 'number':
+        return Literal.fromNumber(value);
+      case 'string':
+        return new Literal(value);
+    }
+    throw new Error("Can't make literal from " + value + ' of type ' + typeof value);
+  }
+}
 exports.default = Literal;

package/lib/log.js

@@ -8,13 +8,12 @@ exports.default = void 0;
  * A Dummy log
  * @module log
  */
-var log = {
-  debug: function debug(x) {},
-  warn: function warn(x) {},
-  info: function info(x) {},
-  error: function error(x) {},
-  success: function success(x) {},
-  msg: function msg(x) {}
+const log = {
+  debug(x) {},
+  warn(x) {},
+  info(x) {},
+  error(x) {},
+  success(x) {},
+  msg(x) {}
 };
-var _default = log;
-exports.default = _default;
+var _default = exports.default = log;