@retorquere/bibtex-parser 6.4.18 → 6.4.19

package/index.js

@@ -1357,7 +1357,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 = (0, sentence_case_2.restore)((0, sentence_case_2.toSentenceCase)(text), 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": "6.4.19",
   "description": "BibTeX parser",
   "main": "index.js",
   "typings": "./index.d.ts",
@@ -8,7 +8,8 @@
     "lint": "eslint . --ext .ts --cache --cache-location .eslintcache/",
     "prestart": "npm run lint && peggy grammar.peggy",
     "start": "tsc -d",
-    "poststart": "npm run docs",
+    "tsc": "tsc -d",
+    "poststart": "echo npm run docs",
     "pretest": "npm start",
     "test": "tap test/tap --no-timeout --no-coverage",
     "snap": "npm test --snapshot",

package/sentence-case.d.ts

@@ -4,5 +4,5 @@ export type TextRange = {
     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(text: string): string;
 //# sourceMappingURL=sentence-case.d.ts.map

package/sentence-case.js

@@ -1,11 +1,15 @@
 "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;
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
-const xregexp_1 = __importDefault(require("xregexp"));
+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');
 function restore(text, orig, preserve) {
     for (const { start, end } of preserve) {
         text = text.substring(0, start) + orig.substring(start, end) + text.substring(end);
@@ -13,84 +17,73 @@ function restore(text, orig, preserve) {
     return text;
 }
 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);
-            });
-        }
-        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);
-    }
-    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.
-        }
-    }
+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();
 }
-const sentenceCaser = new SentenceCaser;
-function toSentenceCase(text, ignoreHTML = false) {
-    return sentenceCaser.convert(text, ignoreHTML);
+function toSentenceCase(text) {
+    const preserve = [];
+    text.replace(/“.*?”/g, (match, i) => {
+        preserve.push({ start: i, end: i + match.length, description: 'quoted' });
+        return '';
+    });
+    text.replace(/‘.*?’/g, (match, i) => {
+        preserve.push({ start: i, end: i + match.length, description: 'quoted' });
+        return '';
+    });
+    text.replace(/(["]).*?\1/g, (match, _quote, i) => {
+        preserve.push({ start: i, end: i + match.length, description: 'quoted' });
+        return '';
+    });
+    text.replace(/([.?!][\s]+)(<[^>]+>)?([A-Z])/g, (match, end, markup, char, i) => {
+        if (!text.substring(0, i + 1).match(re.acronym)) {
+            preserve.push({ start: i + end.length + ((markup === null || markup === void 0 ? void 0 : markup.length) || 0), end: i + end.length + ((markup === null || markup === void 0 ? void 0 : markup.length) || 0) + char.length, description: 'sub-sentence-start' });
+        }
+        return '';
+    });
+    text.replace(/^(<[^>]+>)?([A-Z])/, (match, markup, char) => {
+        preserve.push({ start: ((markup === null || markup === void 0 ? void 0 : markup.length) || 0), end: ((markup === null || markup === void 0 ? void 0 : markup.length) || 0) + char.length, description: 'sentence-start' });
+        return '';
+    });
+    text.replace(/<span class="nocase">.*?<\/span>|<nc>.*?<\/nc>/gi, (match, i) => {
+        preserve.push({ start: i, end: i + match.length, description: 'nocase' });
+        return '';
+    });
+    let masked = text.replace(/<[^>]+>/g, (match, i) => {
+        preserve.push({ start: i, end: i + match.length, description: 'markup' });
+        return '\uFFFD'.repeat(match.length);
+    });
+    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));
+    return restore(masked, text, preserve);
 }
 exports.toSentenceCase = toSentenceCase;
 //# sourceMappingURL=sentence-case.js.map