rehype-citation
Version:
rehype plugin to add citation and bibliography from bibtex files
621 lines (620 loc) • 20.1 kB
JavaScript
function ownKeys(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r &&
(o = o.filter(function (r) {
return Object.getOwnPropertyDescriptor(e, r).enumerable;
})),
t.push.apply(t, o);
}
return t;
}
function _objectSpread(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2
? ownKeys(Object(t), !0).forEach(function (r) {
_defineProperty(e, r, t[r]);
})
: Object.getOwnPropertyDescriptors
? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t))
: ownKeys(Object(t)).forEach(function (r) {
Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
});
}
return e;
}
function _defineProperty(obj, key, value) {
key = _toPropertyKey(key);
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true,
});
}
else {
obj[key] = value;
}
return obj;
}
function _toPropertyKey(t) {
var i = _toPrimitive(t, 'string');
return 'symbol' == typeof i ? i : i + '';
}
function _toPrimitive(t, r) {
if ('object' != typeof t || !t)
return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || 'default');
if ('object' != typeof i)
return i;
throw new TypeError('@@toPrimitive must return a primitive value.');
}
return ('string' === r ? String : Number)(t);
}
import { util } from '../../core/index.js';
import moo from 'moo';
import config from '../config.js';
import * as constants from './constants.js';
import { orderNamePieces, formatNameParts, getStringCase } from './name.js';
const text = {
commandBegin: {
match: '\\begin',
push: 'environment',
},
command: {
match: /\\(?:[a-zA-Z]+|.) */,
value: (s) => s.slice(1).trim(),
},
lbrace: {
match: '{',
push: 'bracedLiteral',
},
mathShift: {
match: '$',
push: 'mathLiteral',
},
whitespace: {
match: /[\s]+|~/,
lineBreaks: true,
value(token) {
return token === '~' ? '\xa0' : ' ';
},
},
};
const lexer = moo.states({
stringLiteral: _objectSpread(_objectSpread({}, text), {}, {
text: /[^{$}\s~\\]+/,
}),
namesLiteral: _objectSpread(_objectSpread({
and: /\s+[aA][nN][dD]\s+/,
comma: ',',
hyphen: '-',
equals: '=',
}, text), {}, {
text: /[^{$}\s~\\,=-]+/,
}),
listLiteral: _objectSpread(_objectSpread({
and: /\s+and\s+/,
}, text), {}, {
text: /[^{$}\s~\\]+/,
}),
separatedLiteral: _objectSpread(_objectSpread({
comma: ',',
}, text), {}, {
text: /[^{$}\s~\\,]+/,
}),
annotation: _objectSpread(_objectSpread({}, text), {}, {
colon: ':',
equals: '=',
comma: ',',
semicolon: ';',
quote: '"',
itemCount: /\d+/,
text: /[^{$}\s~\\":;,=]+/,
}),
bracedLiteral: _objectSpread(_objectSpread({}, text), {}, {
rbrace: {
match: '}',
pop: true,
},
text: /[^{$}\s~\\]+/,
}),
mathLiteral: _objectSpread(_objectSpread({}, text), {}, {
mathShift: {
match: '$',
pop: true,
},
script: /[\^_]/,
text: /[^{$}\s~\\^_]+/,
}),
environment: _objectSpread(_objectSpread({
commandEnd: {
match: '\\end',
pop: true,
},
}, text), {}, {
text: /[^{$}\s~\\]+/,
}),
});
function flattenConsString(string) {
string[0];
return string;
}
function applyFormatting(text, format) {
if (format in constants.formatting) {
return text && constants.formatting[format].join(text);
}
else {
return text;
}
}
export const valueGrammar = new util.Grammar({
String() {
let output = '';
while (!this.matchEndOfFile()) {
output += this.consumeRule('Text');
}
return flattenConsString(output);
},
StringNames() {
const list = [];
while (true) {
this.consumeToken('whitespace', true);
list.push(this.consumeRule('Name'));
this.consumeToken('whitespace', true);
if (this.matchEndOfFile()) {
return list;
}
else {
this.consumeToken('and');
}
}
},
Name() {
const pieces = [];
while (true) {
pieces.push(this.consumeRule('NamePiece'));
if (this.matchEndOfFile() || this.matchToken('and')) {
return orderNamePieces(pieces);
}
else {
this.consumeToken('comma');
this.consumeToken('whitespace', true);
}
}
},
NamePiece() {
const parts = [];
while (true) {
const part = this.consumeRule('NameToken');
if (part.label) {
part.label = formatNameParts([
...parts,
{
value: part.label,
},
]);
return [part];
}
parts.push(part);
if (this.matchEndOfFile() || this.matchToken('and') || this.matchToken('comma')) {
return parts;
}
else {
while (this.matchToken('hyphen') || this.matchToken('whitespace')) {
this.consumeToken();
}
}
}
},
NameToken() {
let upperCase = null;
let value = '';
while (true) {
if (upperCase === null && this.matchToken('text')) {
const text = this.consumeToken().value;
value += text;
upperCase = getStringCase(text);
}
else if (this.matchEndOfFile() ||
this.matchToken('and') ||
this.matchToken('comma') ||
this.matchToken('whitespace')) {
return {
value,
upperCase,
};
}
else if (this.matchToken('hyphen')) {
return {
value,
upperCase,
hyphenated: true,
};
}
else if (this.matchToken('equals')) {
this.consumeToken('equals');
const text = this.consumeRule('NamePiece');
if (text[0].label) {
value += '=' + text[0].label;
}
return {
value: formatNameParts(text),
label: value,
};
}
else {
value += this.consumeRule('Text');
}
}
},
StringList() {
const list = [];
while (!this.matchEndOfFile()) {
let output = '';
while (!this.matchEndOfFile() && !this.matchToken('and')) {
output += this.consumeRule('Text');
}
list.push(flattenConsString(output));
this.consumeToken('and', true);
}
return list.length === 1 ? list[0] : list;
},
StringSeparated() {
const list = [];
while (!this.matchEndOfFile()) {
let output = '';
while (!this.matchEndOfFile() && !this.matchToken('comma')) {
output += this.consumeRule('Text');
}
list.push(output.trim());
this.consumeToken('comma', true);
this.consumeToken('whitespace', true);
}
return list;
},
StringVerbatim() {
let output = '';
while (!this.matchEndOfFile()) {
output += this.consumeToken().text;
}
return flattenConsString(output);
},
StringUri() {
const uri = this.consumeRule('StringVerbatim');
try {
if (decodeURI(uri) === uri) {
return encodeURI(uri);
}
else {
return uri;
}
}
catch (e) {
return encodeURI(uri);
}
},
StringTitleCase() {
this.state.sentenceCase = true;
let output = '';
while (!this.matchEndOfFile()) {
output += this.consumeRule('Text');
}
return flattenConsString(output);
},
Annotations() {
const annotations = {};
while (true) {
const { scope, item, part, value } = this.consumeRule('Annotation');
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() {
const 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');
let 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 = [];
let 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() {
var _this$state;
let output = '';
this.consumeToken('lbrace');
const sentenceCase = this.state.sentenceCase;
this.state.sentenceCase = sentenceCase && this.matchToken('command');
(_this$state = this.state).partlyLowercase &&
(_this$state.partlyLowercase = this.state.sentenceCase);
while (!this.matchToken('rbrace')) {
output += this.consumeRule('Text');
}
const topLevel = sentenceCase && !this.state.sentenceCase;
const protectCase = topLevel && this.state.partlyLowercase;
this.state.sentenceCase = sentenceCase;
this.consumeToken('rbrace');
return protectCase ? applyFormatting(output, 'nocase') : output;
},
MathString() {
let output = '';
this.consumeToken('mathShift');
while (!this.matchToken('mathShift')) {
if (this.matchToken('script')) {
const script = this.consumeToken('script').value;
const text = this.consumeRule('Text').split('');
if (text.every((char) => char in constants.mathScripts[script])) {
output += text.map((char) => constants.mathScripts[script][char]).join('');
}
else {
const formatName = constants.mathScriptFormatting[script];
output += constants.formatting[formatName].join(text.join(''));
}
continue;
}
if (this.matchToken('command')) {
const command = this.token.value;
if (command in constants.mathScriptFormatting) {
this.consumeToken('command');
const text = this.consumeRule('BracketString');
output += applyFormatting(text, constants.mathScriptFormatting[command]);
continue;
}
}
output += this.consumeRule('Text');
}
this.consumeToken('mathShift');
return output;
},
Text() {
if (this.matchToken('lbrace')) {
return this.consumeRule('BracketString');
}
else if (this.matchToken('mathShift')) {
return this.consumeRule('MathString');
}
else if (this.matchToken('whitespace')) {
return this.consumeToken('whitespace').value;
}
else if (this.matchToken('commandBegin')) {
return this.consumeRule('EnclosedEnv');
}
else if (this.matchToken('command')) {
return this.consumeRule('Command');
}
const text = this.consumeToken('text').value.replace(constants.ligaturePattern, (ligature) => constants.ligatures[ligature]);
const afterPunctuation = this.state.afterPunctuation;
this.state.afterPunctuation = /[?!.:]$/.test(text);
if (!this.state.sentenceCase) {
var _this$state2;
(_this$state2 = this.state).partlyLowercase ||
(_this$state2.partlyLowercase =
text === text.toLowerCase() && text !== text.toUpperCase());
return text;
}
const [first, ...otherCharacters] = text;
const rest = otherCharacters.join('');
const restLowerCase = rest.toLowerCase();
if (rest !== restLowerCase) {
return text;
}
if (!afterPunctuation) {
return text.toLowerCase();
}
return first + restLowerCase;
},
Command() {
const commandToken = this.consumeToken('command');
const command = commandToken.value;
if (command in constants.formattingEnvs) {
const text = this.consumeRule('Env');
const format = constants.formattingEnvs[command];
return applyFormatting(text, format);
}
else if (command in constants.formattingCommands) {
const text = this.consumeRule('BracketString');
const format = constants.formattingCommands[command];
return applyFormatting(text, format);
}
else if (command in constants.commands) {
return constants.commands[command];
}
else if (command in constants.mathCommands) {
return constants.mathCommands[command];
}
else if (command in constants.diacritics && !this.matchEndOfFile()) {
const text = this.consumeRule('Text');
const diacritic = text[0] + constants.diacritics[command];
return diacritic.normalize('NFC') + text.slice(1);
}
else if (command in constants.argumentCommands) {
const func = constants.argumentCommands[command];
const args = [];
let arity = func.length;
while (arity-- > 0) {
this.consumeToken('whitespace', true);
args.push(this.consumeRule('BracketString'));
}
return func(...args);
}
else if (/^[&%$#_{}]$/.test(command)) {
return commandToken.text.slice(1);
}
else {
return commandToken.text;
}
},
Env() {
let output = '';
while (!this.matchEndOfFile() && !this.matchToken('rbrace')) {
output += this.consumeRule('Text');
}
return output;
},
EnclosedEnv() {
this.consumeToken('commandBegin');
const beginEnv = this.consumeRule('BracketString');
let output = '';
while (!this.matchToken('commandEnd')) {
output += this.consumeRule('Text');
}
const end = this.consumeToken('commandEnd');
const endEnv = this.consumeRule('BracketString');
if (beginEnv !== endEnv) {
throw new SyntaxError(this.lexer.formatError(end, `environment started with "${beginEnv}", ended with "${endEnv}"`));
}
return applyFormatting(output, constants.formattingEnvs[beginEnv]);
},
_() {
while (this.matchToken('whitespace')) {
this.consumeToken('whitespace');
}
},
}, {
sentenceCase: false,
partlyLowercase: false,
afterPunctuation: true,
});
function singleLanguageIsEnglish(language) {
return constants.sentenceCaseLanguages.includes(language.toLowerCase());
}
function isEnglish(languages) {
if (Array.isArray(languages)) {
return languages.every(singleLanguageIsEnglish);
}
return singleLanguageIsEnglish(languages);
}
function getMainRule(fieldType, languages) {
if (fieldType[1] === 'name') {
return fieldType[0] === 'list' ? 'StringNames' : 'Name';
}
if (fieldType[1] === 'title') {
const option = config.parse.sentenceCase;
if (option === 'always' || (option === 'english' && isEnglish(languages))) {
return 'StringTitleCase';
}
else {
return 'String';
}
}
switch (fieldType[0] === 'field' ? fieldType[1] : fieldType[0]) {
case 'list':
return 'StringList';
case 'separated':
return 'StringSeparated';
case 'verbatim':
return 'StringVerbatim';
case 'uri':
return 'StringUri';
case 'title':
case 'literal':
default:
return 'String';
}
}
function getLexerState(fieldType) {
if (fieldType[1] === 'name') {
return 'namesLiteral';
}
switch (fieldType[0]) {
case 'list':
return 'listLiteral';
case 'separated':
return 'separatedLiteral';
case 'field':
default:
return 'stringLiteral';
}
}
export function parse(text, field, languages = []) {
const fieldType = constants.fieldTypes[field] || [];
return valueGrammar.parse(lexer.reset(text, {
state: getLexerState(fieldType),
line: 0,
col: 0,
}), getMainRule(fieldType, languages));
}
export function parseAnnotation(text) {
return valueGrammar.parse(lexer.reset(text, {
state: 'annotation',
line: 0,
col: 0,
}), 'Annotations');
}