@retorquere/bibtex-parser 6.3.0 → 6.3.4

package/index.d.ts

@@ -1,6 +1,6 @@
 import * as bibtex from './grammar';
 import { JabRefMetadata } from './jabref';
-export declare function toSentenceCase(text: string): string;
+export declare function toSentenceCase(text: string, ignoreHTML?: boolean): string;
 declare type Node = bibtex.Bibliography | bibtex.Math | bibtex.Environment | bibtex.Block | bibtex.RegularCommand | bibtex.DiacriticCommand | bibtex.Entry | bibtex.Field | bibtex.NumberValue | bibtex.StringDeclaration | bibtex.StringReference | bibtex.SubscriptCommand | bibtex.SuperscriptCommand | bibtex.SymbolCommand | bibtex.TextValue | bibtex.PreambleExpression | bibtex.BracedComment | bibtex.LineComment | bibtex.Markup | bibtex.NonEntryText;
 export interface Name {
     /**

package/index.js

@@ -8,56 +8,101 @@ const chunker = tslib_1.__importStar(require("./chunker"));
 const jabref_1 = require("./jabref");
 const unicode2latex_1 = require("unicode2latex");
 const crossref_json_1 = tslib_1.__importDefault(require("./crossref.json"));
+const xregexp_1 = tslib_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;
+}
 class SentenceCaser {
     constructor() {
-        this.acronym = /^[A-Z][.]([A-Z][.])+(?=$|[^\w])/;
-        this.quoted = /^"[^"]+"(?=$|[^\w])/;
+        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) {
+    convert(text, ignoreHTML = false) {
         this.input = text;
         this.result = '';
         this.sentenceStart = true;
+        const preserve = [];
+        if (ignoreHTML) {
+            let replace = true;
+            while (replace) {
+                replace = false;
+                // always keep the leading char, but skip markup
+                this.input = this.input.replace(/[^<>]<[^>]+>/, (match, i) => {
+                    preserve.push({ start: i + 1, end: i + match.length });
+                    replace = true;
+                    return match[0].repeat(match.length);
+                });
+            }
+            replace = true;
+            while (replace) {
+                replace = false;
+                // always keep the leading char, but skip markup
+                this.input = this.input.replace(/<[^>]+>[^<>]/, (match, i) => {
+                    preserve.push({ start: i, end: i + match.length - 1 });
+                    replace = true;
+                    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 = this.input.match(this.quoted)) { // "Hello There"
-                this.add(m[0], true);
+            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 = this.input.match(this.acronym)) { // U.S.
-                this.add(m[0], true);
+            else if (m = xregexp_1.default.exec(this.input, this.aint)) { // isn't
+                this.add(m[0], undefined, false);
             }
-            else if (m = this.input.match(/^[a-z]+n't\b/i)) { // isn't
-                this.add(m[0]);
+            else if (m = xregexp_1.default.exec(this.input, this.word)) {
+                this.add(m[0], '-', false);
             }
-            else if (m = this.input.match(/^[\w-]+/)) { // gallium-nitride
-                this.add(m[0]);
+            else if (m = xregexp_1.default.exec(this.input, this.and)) {
+                this.add(m[0], undefined, true);
             }
             else {
-                this.add(this.input[0]);
+                this.add(this.input[0], undefined, false);
             }
         }
-        return this.result;
+        return restore(this.result, text, preserve);
     }
-    add(word, keep = false) {
-        const parts = word.split('-');
-        const result = [];
-        if (this.sentenceStart || keep)
-            result.push(parts.shift());
-        for (word of parts) {
-            if (!word.match(/[a-z][A-Z]/))
+    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();
-            result.push(word);
         }
-        word = result.join('-');
         this.result += word;
         this.input = this.input.substr(word.length);
         if (!word.match(/^\s+$/)) {
-            this.sentenceStart = !!word.match(/^[.?!]$/);
+            this.sentenceStart = !!word.match(/^[.?!]$/) || (word.length === 2 && word[1] === '.'); // Vitamin A. Vitamin B.
         }
     }
 }
 const sentenceCaser = new SentenceCaser;
-function toSentenceCase(text) {
-    return sentenceCaser.convert(text);
+function toSentenceCase(text, ignoreHTML = false) {
+    return sentenceCaser.convert(text, ignoreHTML);
 }
 exports.toSentenceCase = toSentenceCase;
 class ParserError extends Error {
@@ -245,7 +290,7 @@ class Parser {
             options.sentenceCase = false;
             options.caseProtection = false;
         }
-        this.options = Object.assign({ caseProtection: 'as-needed', verbatimFields: [/^citeulike-linkout-[0-9]+$/, ...exports.fields.verbatim], verbatimCommands: ['url'], unnestFields: [...exports.fields.title, ...exports.fields.unnest, ...exports.fields.verbatim], unnestMode: 'unwrap', htmlFields: exports.fields.html, guessAlreadySentenceCased: true, applyCrossRef: options.applyCrossRef || typeof options.applyCrossRef === 'undefined', markup: {} }, options);
+        this.options = Object.assign({ caseProtection: 'as-needed', verbatimFields: [/^citeulike-linkout-[0-9]+$/, /^bdsk-url-[0-9]+$/, ...exports.fields.verbatim], verbatimCommands: ['url'], unnestFields: [...exports.fields.title, ...exports.fields.unnest, ...exports.fields.verbatim], unnestMode: 'unwrap', htmlFields: exports.fields.html, guessAlreadySentenceCased: true, applyCrossRef: options.applyCrossRef || typeof options.applyCrossRef === 'undefined', markup: {} }, options);
         const markup_defaults = {
             enquote: { open: '\u201c', close: '\u201d' },
             sub: { open: '<sub>', close: '</sub>' },
@@ -405,7 +450,7 @@ class Parser {
           if (start < last.start) throw new Error(JSON.stringify({...last, new: { start, end, reason }, text: this.field.text}))
         }
         */
-        this.field.preserveRanges.push({ start, end, reason });
+        this.field.preserveRanges.push({ start, end, description: reason });
     }
     parseChunk(chunk) {
         this.chunk = chunk.text;
@@ -1328,18 +1373,7 @@ class Parser {
     convertToSentenceCase(text) {
         if (!this.field.preserveRanges)
             return text;
-        // always keep the leading char, but skip markup
-        const lead = text.match(/^(<[^>]+>)*./);
-        if (lead) {
-            this.preserve(lead[0].length - 1, lead[0].length);
-        }
-        else {
-            this.preserve(0, 1);
-        }
-        let sentenceCased = toSentenceCase(text);
-        for (const { start, end } of this.field.preserveRanges) {
-            sentenceCased = sentenceCased.substring(0, start) + text.substring(start, end) + sentenceCased.substring(end);
-        }
+        const sentenceCased = restore(sentenceCaser.convert(text, true), 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.3.0",
+  "version": "6.3.4",
   "description": "BibTeX parser",
   "main": "index.js",
   "scripts": {