@retorquere/bibtex-parser 6.4.18 → 7.0.0

package/index.d.ts

@@ -205,6 +205,10 @@ export interface ParserOptions {
      * If you pass an empty array, or `false`, no sentence casing will be applied (even when there's no language field).
      */
     sentenceCase?: string[] | boolean;
+    /**
+     * If you have sentence-casing on, you can independently choose whether quoted titles within a title are preserved as-is (true) or also sentence-cased(false)
+     */
+    sentenceCasePreserveQuoted?: boolean;
     /**
      * Some bibtex has titles in sentence case, or all-uppercase. If this is on, and there is a field that would normally have sentence-casing applied in which more words are all-`X`case
      * (where `X` is either lower or upper) than mixed-case, it is assumed that you want them this way, and no sentence-casing will be applied to that field

package/index.js

@@ -1228,6 +1228,12 @@ class Parser {
         }
         return parsed;
     }
+    restore(text, orig, preserve) {
+        for (const { start, end } of preserve) {
+            text = text.substring(0, start) + orig.substring(start, end) + text.substring(end);
+        }
+        return text;
+    }
     convert_entry(node) {
         this.entry = {
             key: node.id,
@@ -1357,7 +1363,7 @@ class Parser {
     convertToSentenceCase(text) {
         if (!this.field.preserveRanges)
             return text;
-        const sentenceCased = (0, sentence_case_2.restore)((0, sentence_case_2.toSentenceCase)(text, true), text, this.field.preserveRanges);
+        const sentenceCased = this.restore((0, sentence_case_2.toSentenceCase)(text, this.options.sentenceCasePreserveQuoted || false), text, this.field.preserveRanges);
         if (text !== sentenceCased)
             this.entry.sentenceCased = true;
         return sentenceCased;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retorquere/bibtex-parser",
-  "version": "6.4.18",
+  "version": "7.0.0",
   "description": "BibTeX parser",
   "main": "index.js",
   "typings": "./index.d.ts",
@@ -8,6 +8,7 @@
     "lint": "eslint . --ext .ts --cache --cache-location .eslintcache/",
     "prestart": "npm run lint && peggy grammar.peggy",
     "start": "tsc -d",
+    "tsc": "tsc -d",
     "poststart": "npm run docs",
     "pretest": "npm start",
     "test": "tap test/tap --no-timeout --no-coverage",

package/sentence-case.d.ts

@@ -1,8 +1,2 @@
-export type TextRange = {
-    start: number;
-    end: number;
-    description?: string;
-};
-export declare function restore(text: string, orig: string, preserve: TextRange[]): string;
-export declare function toSentenceCase(text: string, ignoreHTML?: boolean): string;
+export declare function toSentenceCase(sentence: string, preserveQuoted?: boolean): string;
 //# sourceMappingURL=sentence-case.d.ts.map

package/sentence-case.js

@@ -1,96 +1,85 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toSentenceCase = exports.restore = void 0;
+exports.toSentenceCase = void 0;
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
-const xregexp_1 = __importDefault(require("xregexp"));
-function restore(text, orig, preserve) {
-    for (const { start, end } of preserve) {
-        text = text.substring(0, start) + orig.substring(start, end) + text.substring(end);
-    }
-    return text;
+const categories = require("xregexp/tools/output/categories");
+const cat = name => categories.find(c => c.name === name).bmp;
+const L = cat('L');
+const Lu = cat('Lu');
+const Ll = cat('Ll');
+const N = cat('N');
+const No = cat('No');
+const Pc = cat('Pc');
+const re = {
+    acronym: new RegExp(`([${Lu}][.])+$`),
+    innerCaps: new RegExp(`.[${Lu}]`),
+    ident: new RegExp(`^[$p{L}]+[${N}${No}][${L}${N}${No}]*$`),
+    allCaps: new RegExp(`^[${Lu}${N}${No}]+$`),
+    skipWords: /^(but|or|yet|so|for|and|nor|a|an|the|at|by|from|in|into|of|on|to|with|updown|as)$/i,
+    // chemElements: /^(H|He|Li|Be|B|C|N|O|F|Ne|Na|Mg|Al|Si|P|S|Cl|Ar|K|Ca|Sc|Ti|V|Cr|Mn|Fe|Co|Ni|Cu|Zn|Ga|Ge|As|Se|Br|Kr|Rb|Sr|Y|Zr|Nb|Mo|Tc|Ru|Rh|Pb|Ag|Cd|In|Sn|Sb|Te|I|Xe|Cs|Ba|La|Hf|Ta|W|Re|Os|Ir|Pt|Au|Hg|Tl|Pb|Bi|Po|At|Rn|Fr|Ra|Ac|Rf|Db|Sg|Bh|Hs|Mt|Ds|Rg|Cn|Nh|Fl|Mc|Lv|Ts|Og|La|Ce|Pr|Nd|Pm|Sm|Eu|Gd|Tb|Dy|Ho|Er|Tm|Yb|Lu|Ac|Th|Pa|U|Np|Pu|Am|Cm|Bk|Cf|Es|Fm|Md|No|Lr)$/,
+    words: new RegExp(`([\uFFFD${L}${N}${No}]+([\uFFFD${Pc}${L}${N}${No}]*))|(\\s([\uFFFD${Lu}]+[.]){2,})?`, 'g'),
+    titleCase: new RegExp(`^[${Lu}][${Ll}${N}${No}]+$`),
+    // private aint = XRegExp("^\\p{L}n't(?=$|[\\P{L}])") // isn't
+    // private word = XRegExp('^\\p{L}+([-.]\\p{L}+)*') // also match gallium-nitride as one word
+    // private and = XRegExp('^\\p{Lu}&\\p{Lu}(?=$|[\\P{L}])') // Q&A
+};
+function lowercase(word) {
+    if (!word)
+        return word;
+    const unmasked = word.replace(/\uFFFD/g, '');
+    if (unmasked.match(re.skipWords))
+        return word.toLowerCase();
+    if (unmasked.match(re.titleCase))
+        return word.toLowerCase();
+    // if (unmasked.match(re.chemElements)) return word
+    if (unmasked.length === 1)
+        return unmasked === 'A' ? word.toLowerCase() : word;
+    if (unmasked.match(re.innerCaps))
+        return word;
+    if (unmasked.match(re.ident) || unmasked.match(re.allCaps))
+        return word;
+    return word.toLowerCase();
 }
-exports.restore = restore;
-class SentenceCaser {
-    constructor() {
-        this.acronym = (0, xregexp_1.default)('^(\\p{Lu}[.])+(?=$|[\\P{L}])');
-        this.quoted = (0, xregexp_1.default)('^"[^"]+"(?=$|[\\P{L}])');
-        this.innerCaps = (0, xregexp_1.default)('\\p{Ll}\\p{Lu}');
-        this.allCaps = (0, xregexp_1.default)('^\\p{Lu}+$');
-        this.aint = (0, xregexp_1.default)("^\\p{L}n't(?=$|[\\P{L}])"); // isn't
-        this.word = (0, xregexp_1.default)('^\\p{L}+(-\\p{L}+)*'); // also match gallium-nitride as one word
-        this.and = (0, xregexp_1.default)('^\\p{Lu}&\\p{Lu}(?=$|[\\P{L}])'); // Q&A
-    }
-    convert(text, ignoreHTML = false) {
-        this.input = text;
-        this.result = '';
-        this.sentenceStart = true;
-        const preserve = [];
-        if (ignoreHTML) {
-            this.input.replace(/[^<>]<[^>]+>/g, (match, i) => {
-                preserve.push({ start: i + 1, end: i + match.length });
-                // replace markup by the preceding char
-                return match[0].repeat(match.length);
-            });
-            this.input = this.input.replace(/<[^>]+>[^<>]/g, (match, i) => {
-                preserve.push({ start: i, end: i + match.length - 1 });
-                // replace markup by the following char
-                return match[match.length - 1].repeat(match.length);
-            });
+function toSentenceCase(sentence, preserveQuoted = false) {
+    const preserve = [];
+    sentence.replace(/([.?!][\s]+)(<[^>]+>)?([A-Z])/g, (match, end, markup, char, i) => {
+        if (!sentence.substring(0, i + 1).match(re.acronym)) {
+            preserve.push({ pos: i + end.length + ((markup === null || markup === void 0 ? void 0 : markup.length) || 0), text: char, description: 'sub-sentence-start' });
         }
-        this.input = this.input.replace(/[;:]\s+A\s/g, match => match.toLowerCase());
-        this.input = this.input.replace(/[–—]\s*A\s/g, match => match.toLowerCase());
-        let m;
-        while (this.input) {
-            if (m = xregexp_1.default.exec(this.input, this.quoted)) { // "Hello There"
-                this.add(m[0], undefined, true);
-            }
-            else if (m = xregexp_1.default.exec(this.input, this.acronym)) { // U.S.
-                this.add(m[0], undefined, true);
-            }
-            else if (m = xregexp_1.default.exec(this.input, this.aint)) { // isn't
-                this.add(m[0], undefined, false);
-            }
-            else if (m = xregexp_1.default.exec(this.input, this.word)) {
-                this.add(m[0], '-', false);
-            }
-            else if (m = xregexp_1.default.exec(this.input, this.and)) {
-                this.add(m[0], undefined, true);
-            }
-            else {
-                this.add(this.input[0], undefined, false);
-            }
-        }
-        return restore(this.result, text, preserve);
+        return '';
+    });
+    sentence.replace(/^(<[^>]+>)?([A-Z])/, (match, markup, char) => {
+        preserve.push({ pos: ((markup === null || markup === void 0 ? void 0 : markup.length) || 0), text: char, description: 'sentence-start' });
+        return '';
+    });
+    sentence.replace(/<span class="nocase">.*?<\/span>|<nc>.*?<\/nc>/gi, (text, pos) => {
+        preserve.push({ pos, text, description: 'nocase' });
+        return '';
+    });
+    let masked = sentence.replace(/<[^>]+>/g, (text, pos) => {
+        preserve.push({ pos, text, description: 'markup' });
+        return '\uFFFD'.repeat(text.length);
+    });
+    // last because we're potentially modifying the original
+    for (const q of [/(“)(.*?)”/g, /(‘)(.*?)’/g, /(["])(.*?)\1/g]) {
+        sentence.replace(q, (text, quote, quoted, pos) => {
+            preserve.push({
+                pos: pos + (preserveQuoted ? 0 : quote.length),
+                text: preserveQuoted ? text : toSentenceCase(quoted, preserveQuoted),
+                description: `quoted with ${q}`,
+            });
+            return '';
+        });
     }
-    add(word, splitter, keep) {
-        if (splitter) {
-            word = word.split(splitter).map((part, i) => {
-                if ((keep || this.sentenceStart) && i === 0)
-                    return part;
-                if (xregexp_1.default.exec(part, this.innerCaps))
-                    return part;
-                if (xregexp_1.default.exec(part, this.allCaps))
-                    return part;
-                return part.toLowerCase();
-            }).join(splitter);
-        }
-        else {
-            if (!keep)
-                word = word.toLowerCase();
-        }
-        this.result += word;
-        this.input = this.input.substr(word.length);
-        if (!word.match(/^\s+$/)) {
-            this.sentenceStart = !!word.match(/^[.?!]$/) || (word.length === 2 && word[1] === '.'); // Vitamin A. Vitamin B.
-        }
+    masked = masked
+        .replace(/[;:]\uFFFD*\s+\uFFFD*A\s/g, match => match.toLowerCase())
+        .replace(/[–—]\uFFFD*\s*\uFFFD*A\s/g, match => match.toLowerCase())
+        .replace(re.words, word => lowercase(word));
+    sentence = masked;
+    for (const { pos, text } of preserve) {
+        sentence = sentence.substring(0, pos) + text + sentence.substring(pos + text.length);
     }
-}
-const sentenceCaser = new SentenceCaser;
-function toSentenceCase(text, ignoreHTML = false) {
-    return sentenceCaser.convert(text, ignoreHTML);
+    return sentence;
 }
 exports.toSentenceCase = toSentenceCase;
 //# sourceMappingURL=sentence-case.js.map