citation-js 0.7.8 → 0.7.9

package/build/citation.js

@@ -1663,6 +1663,14 @@ var fieldTypes = {
 };
 function correctName(name, bestGuessConversions) {
   if (_typeof(name) === 'object' && name !== null && (name.literal || name.given || name.family)) {
+    if (name.ORCID || name.orcid || name._ORCID) {
+      name = _objectSpread({
+        _orcid: name.ORCID || name.orcid || name._ORCID
+      }, name);
+      delete name.ORCID;
+      delete name.orcid;
+      delete name._ORCID;
+    }
     return name;
   } else if (!bestGuessConversions) {
     return undefined;
@@ -3421,7 +3429,7 @@ Translator.CONVERT_TO_TARGET = Symbol('convert to target');
 },{}],43:[function(require,module,exports){
 module.exports={
   "name": "@citation-js/core",
-  "version": "0.7.6",
+  "version": "0.7.9",
   "description": "Convert different bibliographic metadata sources",
   "keywords": [
     "citation-js",
@@ -3461,7 +3469,7 @@ module.exports={
     "fetch-ponyfill": "^7.1.0",
     "sync-fetch": "^0.4.1"
   },
-  "gitHead": "c88a4c1aacf82cfa8f1b55cc8673cb38e807c421"
+  "gitHead": "8fa1b9d3d420f489f9a8a57f9759b50a6369182c"
 }
 
 },{}],44:[function(require,module,exports){
@@ -4265,6 +4273,10 @@ var _default = exports["default"] = {
   format: {
     useIdAsLabel: false,
     asciiOnly: true
+  },
+  biber: {
+    annotationMarker: '+an',
+    namedAnnotationMarker: ':'
   }
 };
 
@@ -4660,6 +4672,11 @@ function parseEntryValues(entry) {
     }
     output[property] = (0, _value.parse)(value + '', property, output.language);
   }
+  for (var _property in entry.annotations) {
+    for (var annotation in entry.annotations[_property]) {
+      output[_property + '+an:' + annotation] = (0, _value.parseAnnotation)(entry.annotations[_property][annotation]);
+    }
+  }
   return _objectSpread(_objectSpread({}, entry), {}, {
     properties: output
   });
@@ -4847,6 +4864,7 @@ exports.bibtexGrammar = void 0;
 exports.parse = parse;
 var _core = require("@citation-js/core");
 var _moo = _interopRequireDefault(require("moo"));
+var _config = _interopRequireDefault(require("../config.js"));
 var _constants = require("./constants.js");
 function _interopRequireDefault(obj) {
   return obj && obj.__esModule ? obj : {
@@ -4902,7 +4920,7 @@ function _toPrimitive(t, r) {
   }
   return ("string" === r ? String : Number)(t);
 }
-var identifier = /[a-zA-Z_][a-zA-Z0-9_:-]*/;
+var identifier = /[a-zA-Z_][a-zA-Z0-9_:+-]*/;
 var whitespace = {
   comment: /%.*/,
   whitespace: {
@@ -5043,12 +5061,11 @@ var bibtexGrammar = exports.bibtexGrammar = new _core.util.Grammar({
       this.consumeRule('_');
       this.consumeToken('comma');
       this.consumeRule('_');
-      var properties = this.consumeRule('EntryBody');
-      result = {
+      var entryBody = this.consumeRule('EntryBody');
+      result = _objectSpread({
         type: type,
-        label: label,
-        properties: properties
-      };
+        label: label
+      }, entryBody);
     }
     this.consumeRule('_');
     var closeBrace = this.consumeToken('rbrace').value;
@@ -5058,13 +5075,35 @@ var bibtexGrammar = exports.bibtexGrammar = new _core.util.Grammar({
     return result;
   },
   EntryBody: function EntryBody() {
-    var properties = {};
+    var output = {
+      properties: {}
+    };
     while (this.matchToken('identifier')) {
       var _this$consumeRule3 = this.consumeRule('Field'),
         _this$consumeRule4 = _slicedToArray(_this$consumeRule3, 2),
         field = _this$consumeRule4[0],
         value = _this$consumeRule4[1];
-      properties[field] = value;
+      var annotationField = void 0;
+      var annotationName = 'default';
+      if (field.endsWith(_config["default"].biber.annotationMarker)) {
+        annotationField = field.slice(0, -_config["default"].biber.annotationMarker.length);
+      } else if (field.includes(_config["default"].biber.annotationMarker + _config["default"].biber.namedAnnotationMarker)) {
+        var _field$split = field.split(_config["default"].biber.annotationMarker + _config["default"].biber.namedAnnotationMarker);
+        var _field$split2 = _slicedToArray(_field$split, 2);
+        annotationField = _field$split2[0];
+        annotationName = _field$split2[1];
+      }
+      if (annotationField) {
+        if (!output.annotations) {
+          output.annotations = {};
+        }
+        if (!output.annotations[annotationField]) {
+          output.annotations[annotationField] = {};
+        }
+        output.annotations[annotationField][annotationName] = value;
+      } else {
+        output.properties[field] = value;
+      }
       this.consumeRule('_');
       if (this.consumeToken('comma', true)) {
         this.consumeRule('_');
@@ -5072,7 +5111,7 @@ var bibtexGrammar = exports.bibtexGrammar = new _core.util.Grammar({
         break;
       }
     }
-    return properties;
+    return output;
   },
   Field: function Field() {
     var field = this.consumeToken('identifier').value.toLowerCase();
@@ -5136,7 +5175,7 @@ function parse(text) {
   return bibtexGrammar.parse(lexer.reset(text));
 }
 
-},{"./constants.js":55,"@citation-js/core":10,"moo":651}],59:[function(require,module,exports){
+},{"../config.js":52,"./constants.js":55,"@citation-js/core":10,"moo":651}],59:[function(require,module,exports){
 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
@@ -5332,6 +5371,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.parse = parse;
+exports.parseAnnotation = parseAnnotation;
 exports.valueGrammar = void 0;
 var _core = require("@citation-js/core");
 var _moo = _interopRequireDefault(require("moo"));
@@ -5418,12 +5458,12 @@ function _toPrimitive(t, r) {
   return ("string" === r ? String : Number)(t);
 }
 var text = {
+  commandBegin: {
+    match: '\\begin',
+    push: 'environment'
+  },
   command: {
     match: /\\(?:[a-zA-Z]+|.) */,
-    type: _moo["default"].keywords({
-      commandBegin: '\\begin',
-      commandEnd: '\\end'
-    }),
     value: function value(s) {
       return s.slice(1).trim();
     }
@@ -5466,6 +5506,15 @@ var lexer = _moo["default"].states({
   }, text), {}, {
     text: /[^{$}\s~\\,]+/
   }),
+  annotation: _objectSpread(_objectSpread({}, text), {}, {
+    colon: ':',
+    equals: '=',
+    comma: ',',
+    semicolon: ';',
+    quote: '"',
+    itemCount: /\d+/,
+    text: /[^{$}\s~\\":;,=]+/
+  }),
   bracedLiteral: _objectSpread(_objectSpread({}, text), {}, {
     rbrace: {
       match: '}',
@@ -5480,6 +5529,14 @@ var lexer = _moo["default"].states({
     },
     script: /[\^_]/,
     text: /[^{$}\s~\\^_]+/
+  }),
+  environment: _objectSpread(_objectSpread({
+    commandEnd: {
+      match: '\\end',
+      pop: true
+    }
+  }, text), {}, {
+    text: /[^{$}\s~\\]+/
   })
 });
 function flattenConsString(string) {
@@ -5632,6 +5689,87 @@ var valueGrammar = exports.valueGrammar = new _core.util.Grammar({
     }
     return flattenConsString(output);
   },
+  Annotations: function Annotations() {
+    var annotations = {};
+    while (true) {
+      var _this$consumeRule = this.consumeRule('Annotation'),
+        scope = _this$consumeRule.scope,
+        item = _this$consumeRule.item,
+        part = _this$consumeRule.part,
+        value = _this$consumeRule.value;
+      if (scope === 'part') {
+        if (!annotations.part) {
+          annotations.part = [];
+        }
+        if (!annotations.part[item]) {
+          annotations.part[item] = {};
+        }
+        annotations.part[item][part] = value;
+      } else if (scope === 'item') {
+        if (!annotations.item) {
+          annotations.item = [];
+        }
+        annotations.item[item] = value;
+      } else {
+        annotations.field = value;
+      }
+      if (this.matchEndOfFile()) {
+        break;
+      } else {
+        this.consumeToken('semicolon');
+        this.consumeRule('_');
+      }
+    }
+    return annotations;
+  },
+  Annotation: function Annotation() {
+    var annotation = {};
+    if (this.matchToken('itemCount')) {
+      annotation.item = parseInt(this.consumeToken('itemCount')) - 1;
+      if (this.matchToken('colon')) {
+        this.consumeToken('colon');
+        annotation.part = this.consumeToken('text');
+        annotation.scope = 'part';
+      } else {
+        annotation.scope = 'item';
+      }
+    } else {
+      annotation.scope = 'field';
+    }
+    this.consumeToken('equals');
+    this.consumeRule('_');
+    if (this.matchToken('quote')) {
+      this.consumeToken('quote');
+      var literal = '';
+      while (!this.matchToken('quote')) {
+        if (this.matchToken('itemCount') || this.matchToken('colon') || this.matchToken('comma') || this.matchToken('semicolon') || this.matchToken('equals')) {
+          literal += this.token.value;
+          this.token = this.lexer.next();
+        } else {
+          literal += this.consumeRule('Text');
+        }
+      }
+      this.consumeToken('quote');
+      annotation.value = flattenConsString(literal);
+      this.consumeRule('_');
+    } else {
+      annotation.value = [];
+      var output = '';
+      while (true) {
+        output += this.consumeRule('Text');
+        if (this.matchToken('comma')) {
+          this.consumeToken('comma');
+          this.consumeRule('_');
+          annotation.value.push(flattenConsString(output));
+          output = '';
+        } else if (this.matchEndOfFile() || this.matchToken('semicolon')) {
+          annotation.value.push(flattenConsString(output));
+          break;
+        }
+      }
+    }
+    return annotation;
+  },
   BracketString: function BracketString() {
     var _this$state;
     var output = '';
@@ -5776,6 +5914,11 @@ var valueGrammar = exports.valueGrammar = new _core.util.Grammar({
       throw new SyntaxError(this.lexer.formatError(end, "environment started with \"".concat(beginEnv, "\", ended with \"").concat(endEnv, "\"")));
     }
     return applyFormatting(output, constants.formattingEnvs[beginEnv]);
+  },
+  _: function _() {
+    while (this.matchToken('whitespace')) {
+      this.consumeToken('whitespace');
+    }
   }
 }, {
   sentenceCase: false,
@@ -5841,6 +5984,13 @@ function parse(text, field) {
     col: 0
   }), getMainRule(fieldType, languages));
 }
+function parseAnnotation(text) {
+  return valueGrammar.parse(lexer.reset(text, {
+    state: 'annotation',
+    line: 0,
+    col: 0
+  }), 'Annotations');
+}
 
 },{"../config.js":52,"./constants.js":55,"./name.js":60,"@citation-js/core":10,"moo":651}],64:[function(require,module,exports){
 "use strict";
@@ -5985,9 +6135,9 @@ var _default = exports["default"] = new _core.util.Translator([].concat(aliases,
   source: 'annotation',
   target: 'annote'
 }, {
-  source: 'author',
+  source: ['author', 'author+an:orcid'],
   target: 'author',
-  convert: _shared.Converters.NAMES
+  convert: _shared.Converters.NAMES_ORCID
 }, {
   source: 'library',
   target: 'call-number'
@@ -7377,6 +7527,31 @@ var Converters = exports.Converters = {
       return list.map(name.convertToSource);
     }
   },
+  NAMES_ORCID: {
+    toTarget: function toTarget(list, orcid) {
+      return list.map(function (inputName, i) {
+        var _orcid$item;
+        var outputName = name.convertToTarget(inputName);
+        if (typeof (orcid === null || orcid === void 0 || (_orcid$item = orcid.item) === null || _orcid$item === void 0 ? void 0 : _orcid$item[i]) === 'string') {
+          outputName._orcid = orcid.item[i];
+        }
+        return outputName;
+      });
+    },
+    toSource: function toSource(list) {
+      var names = [];
+      var orcid = [];
+      for (var i = 0; i < list.length; i++) {
+        names.push(name.convertToSource(list[i]));
+        if (list[i]._orcid) {
+          orcid[i] = list[i]._orcid;
+        }
+      }
+      return [names, orcid.length ? {
+        item: orcid
+      } : undefined];
+    }
+  },
   PAGES: {
     toTarget: function toTarget(pages) {
       return pages.replace(/[–—]/, '-');
@@ -7420,27 +7595,34 @@ var Converters = exports.Converters = {
 },{"../config.js":52,"@citation-js/core":10}],71:[function(require,module,exports){
 "use strict";
 
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-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; }
-function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.format = format;
-function formatEntry(_ref, dict) {
-  var type = _ref.type,
-    label = _ref.label,
-    properties = _ref.properties;
-  var fields = Object.entries(properties).map(function (_ref2) {
-    var _ref3 = _slicedToArray(_ref2, 2),
-      field = _ref3[0],
-      value = _ref3[1];
-    return dict.listItem.join("".concat(field, " = {").concat(value, "},"));
-  });
-  return dict.entry.join("@".concat(type, "{").concat(label, ",").concat(dict.list.join(fields.join('')), "}"));
+var _config = _interopRequireDefault(require("../config.js"));
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    "default": obj
+  };
+}
+function formatField(field, value, dict) {
+  return dict.listItem.join("".concat(field, " = {").concat(value, "},"));
+}
+function formatEntry(entry, dict) {
+  var fields = [];
+  for (var field in entry.properties) {
+    fields.push(formatField(field, entry.properties[field], dict));
+    if (entry.annotations && entry.annotations[field]) {
+      for (var annotation in entry.annotations[field]) {
+        var annotationField = field + _config["default"].biber.annotationMarker;
+        if (annotation !== 'default') {
+          annotationField += _config["default"].biber.namedAnnotationMarker + annotation;
+        }
+        fields.push(formatField(annotationField, entry.annotations[field][annotation], dict));
+      }
+    }
+  }
+  return dict.entry.join("@".concat(entry.type, "{").concat(entry.label, ",").concat(dict.list.join(fields.join('')), "}"));
 }
 function format(src, dict) {
   var entries = src.map(function (entry) {
@@ -7449,7 +7631,7 @@ function format(src, dict) {
   return dict.bibliographyContainer.join(entries);
 }
 
-},{}],72:[function(require,module,exports){
+},{"../config.js":52}],72:[function(require,module,exports){
 "use strict";
 
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
@@ -7484,6 +7666,12 @@ function format(src, dict) {
 },{}],73:[function(require,module,exports){
 "use strict";
 
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+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; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -7495,16 +7683,30 @@ function formatEntryValues(_ref) {
   var type = _ref.type,
     label = _ref.label,
     properties = _ref.properties;
-  var output = {};
-  for (var property in properties) {
-    var value = properties[property];
-    output[property] = (0, _value.format)(property, value);
-  }
-  return {
+  var output = {
     type: type,
     label: label,
-    properties: output
+    properties: {}
   };
+  for (var property in properties) {
+    var value = properties[property];
+    var _property$split = property.split('+an:'),
+      _property$split2 = _slicedToArray(_property$split, 2),
+      field = _property$split2[0],
+      annotation = _property$split2[1];
+    if (annotation) {
+      if (!output.annotations) {
+        output.annotations = {};
+      }
+      if (!output.annotations[field]) {
+        output.annotations[field] = {};
+      }
+      output.annotations[field][annotation] = (0, _value.formatAnnotation)(value);
+    } else {
+      output.properties[property] = (0, _value.format)(property, value);
+    }
+  }
+  return output;
 }
 function format(entries) {
   return (0, _index.format)(entries).map(formatEntryValues);
@@ -7559,6 +7761,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.format = format;
+exports.formatAnnotation = formatAnnotation;
 var _config = _interopRequireDefault(require("../config.js"));
 var _constants = require("../input/constants.js");
 function _interopRequireDefault(obj) {
@@ -7681,6 +7884,15 @@ function formatList(values, valueType, listType) {
     return formatted.includes(delimiter) ? "{".concat(formatted, "}") : formatted;
   }).join(delimiter);
 }
+function formatAnnotationValue(values) {
+  if (Array.isArray(values)) {
+    return values.map(function (value) {
+      return escapeValue(value).replace(/([;,"])/g, '{$1}');
+    }).join(', ');
+  } else {
+    return '"' + escapeValue(values).replace(/(["])/g, '{$1}') + '"';
+  }
+}
 function format(field, value) {
   if (!(field in _constants.fieldTypes)) {
     return formatSingleValue(value, 'verbatim');
@@ -7694,6 +7906,42 @@ function format(field, value) {
     return formatSingleValue(value, valueType);
   }
 }
+function formatAnnotation(value) {
+  var annotations = [];
+  if (value.field) {
+    annotations.push('=' + formatAnnotationValue(value.field));
+  }
+  if (value.item) {
+    for (var _i = 0, _Object$entries = Object.entries(value.item); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        itemCount = _Object$entries$_i[0],
+        itemValue = _Object$entries$_i[1];
+      if (!itemValue) {
+        continue;
+      }
+      var i = parseInt(itemCount) + 1;
+      annotations.push(i + '=' + formatAnnotationValue(itemValue));
+    }
+  }
+  if (value.part) {
+    for (var _i2 = 0, _Object$entries2 = Object.entries(value.part); _i2 < _Object$entries2.length; _i2++) {
+      var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+        _itemCount = _Object$entries2$_i[0],
+        _itemValue = _Object$entries2$_i[1];
+      if (!_itemValue) {
+        continue;
+      }
+      var _i3 = parseInt(_itemCount) + 1;
+      for (var part in _itemValue) {
+        if (!_itemValue[part]) {
+          continue;
+        }
+        annotations.push(_i3 + ':' + part + '=' + formatAnnotationValue(_itemValue[part]));
+      }
+    }
+  }
+  return annotations.join('; ');
+}
 
 },{"../config.js":52,"../input/constants.js":55}],76:[function(require,module,exports){
 "use strict";