@retorquere/bibtex-parser 7.0.16 → 8.0.1

package/verbatim.d.ts

@@ -0,0 +1,75 @@
+export type Entry = {
+    input: string;
+    type: string;
+    key: string;
+    fields: Record<string, string>;
+};
+export interface ParseError {
+    error: string;
+    input: string;
+    location?: {
+        line: number;
+        column: number;
+    };
+}
+export interface ParserOptions {
+    /**
+     * stop parsing after `max_entries` entries have been found. Useful for quick detection if a text file is in fact a bibtex file
+     */
+    max_entries?: number;
+}
+declare class Parser {
+    parsing: string;
+    entries: Entry[];
+    strings: Record<string, string>;
+    comments: string[];
+    errors: ParseError[];
+    preambles: string[];
+    private default_strings;
+    /**
+     * error found, if any.
+     */
+    error?: string;
+    private pos;
+    private linebreaks;
+    private input;
+    private max_entries;
+    private keywords;
+    constructor(input: string, options?: ParserOptions);
+    location(pos: number): {
+        line: number;
+        column: number;
+    };
+    parse(): void;
+    parseAsync(): Promise<void>;
+    private isWhitespace;
+    private match;
+    private tryMatch;
+    private skipWhitespace;
+    private value_braces;
+    private value_quotes;
+    private single_value;
+    private value;
+    private key;
+    private key_equals_value;
+    private entry;
+    private directive;
+    private string;
+    private preamble;
+    private comment;
+    private hasMore;
+    private bibtex;
+    private bibtexAsync;
+    private matchGuard;
+    private parseNext;
+}
+export type Bibliography = Parser;
+/**
+ * Parses a bibtex source in verbatim mode. Good for detection of bibtex and for later LaTeX-reparsing.
+ */
+export declare function parse(input: string, options?: ParserOptions): Bibliography;
+export declare const promises: {
+    parse(input: string, options?: ParserOptions): Promise<Bibliography>;
+};
+export {};
+//# sourceMappingURL=verbatim.d.ts.map

package/{chunker.js → verbatim.js}

@@ -5,14 +5,14 @@
 // CommonJS port by Mikola Lysenko 2013
 //
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promises = exports.entries = exports.parse = void 0;
-class ParseError extends Error {
+exports.promises = exports.parse = void 0;
+class ParsingError extends Error {
     constructor(message, parser) {
         message += ` @ ${parser.pos}`;
         if (parser.parsing)
             message += ` in ${JSON.stringify(parser.parsing)}`;
         super(message);
-        this.name = 'ParseError';
+        this.name = 'ParsingError';
     }
 }
 // eslint-disable-next-line prefer-template
@@ -28,61 +28,140 @@ const letter = new RegExp('[' + [
     // Letter, Other
     /\u00AA\u00BA\u01BB\u01C0-\u01C3\u0294\u05D0-\u05EA\u05F0-\u05F2\u0620-\u063F\u0641-\u064A\u066E-\u066F\u0671-\u06D3\u06D5\u06EE-\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u0800-\u0815\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0972-\u0980\u0985-\u098C\u098F-\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC-\u09DD\u09DF-\u09E1\u09F0-\u09F1\u0A05-\u0A0A\u0A0F-\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32-\u0A33\u0A35-\u0A36\u0A38-\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2-\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0-\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F-\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32-\u0B33\u0B35-\u0B39\u0B3D\u0B5C-\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99-\u0B9A\u0B9C\u0B9E-\u0B9F\u0BA3-\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60-\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0-\u0CE1\u0CF1-\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32-\u0E33\u0E40-\u0E45\u0E81-\u0E82\u0E84\u0E87-\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA-\u0EAB\u0EAD-\u0EB0\u0EB2-\u0EB3\u0EBD\u0EC0-\u0EC4\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065-\u1066\u106E-\u1070\u1075-\u1081\u108E\u10D0-\u10FA\u10FD-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17DC\u1820-\u1842\u1844-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE-\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C77\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5-\u1CF6\u2135-\u2138\u2D30-\u2D67\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3006\u303C\u3041-\u3096\u309F\u30A1-\u30FA\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA014\uA016-\uA48C\uA4D0-\uA4F7\uA500-\uA60B\uA610-\uA61F\uA62A-\uA62B\uA66E\uA6A0-\uA6E5\uA78F\uA7F7\uA7FB-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9E0-\uA9E4\uA9E7-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA6F\uAA71-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5-\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADC\uAAE0-\uAAEA\uAAF2\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40-\uFB41\uFB43-\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF66-\uFF6F\uFF71-\uFF9D\uFFA0-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC/.source,
 ].join('') + ']');
-class BibtexParser {
-    reset(input) {
-        this.input = input;
-        this.pos = 0;
+class Parser {
+    constructor(input, options = {}) {
         this.entries = [];
         this.strings = {};
+        this.comments = [];
+        this.errors = [];
+        this.preambles = [];
+        this.default_strings = {
+            JAN: '01',
+            JANUARY: '01',
+            FEB: '02',
+            FEBRUARY: '02',
+            MAR: '03',
+            MARCH: '03',
+            APR: '04',
+            APRIL: '04',
+            MAY: '05',
+            JUN: '06',
+            JUNE: '06',
+            JUL: '07',
+            JULY: '07',
+            AUG: '08',
+            AUGUST: '08',
+            SEP: '09',
+            SEPTEMBER: '09',
+            OCT: '10',
+            OCTOBER: '10',
+            NOV: '11',
+            NOVEMBER: '11',
+            DEC: '12',
+            DECEMBER: '12',
+            ACMCS: 'ACM Computing Surveys',
+            ACTA: 'Acta Informatica',
+            CACM: 'Communications of the ACM',
+            IBMJRD: 'IBM Journal of Research and Development',
+            IBMSJ: 'IBM Systems Journal',
+            IEEESE: 'IEEE Transactions on Software Engineering',
+            IEEETC: 'IEEE Transactions on Computers',
+            IEEETCAD: 'IEEE Transactions on Computer-Aided Design of Integrated Circuits',
+            IPL: 'Information Processing Letters',
+            JACM: 'Journal of the ACM',
+            JCSS: 'Journal of Computer and System Sciences',
+            SCP: 'Science of Computer Programming',
+            SICOMP: 'SIAM Journal on Computing',
+            TOCS: 'ACM Transactions on Computer Systems',
+            TODS: 'ACM Transactions on Database Systems',
+            TOG: 'ACM Transactions on Graphics',
+            TOMS: 'ACM Transactions on Mathematical Software',
+            TOOIS: 'ACM Transactions on Office Information Systems',
+            TOPLAS: 'ACM Transactions on Programming Languages and Systems',
+            TCS: 'Theoretical Computer Science',
+        };
+        this.pos = 0;
+        this.linebreaks = [];
+        this.max_entries = options.max_entries || 0;
+        this.input = input;
         this.parsing = null;
-        this.chunks = [];
-        // this.linebreaks = undefined
+        this.keywords = 0;
+        let pos = input.indexOf('\n');
+        while (pos !== -1) {
+            this.linebreaks.push(pos);
+            pos = input.indexOf('\n', pos + 1);
+        }
     }
-    parse(input, options = {}) {
-        this.reset(input);
-        this.max_entries = options.max_entries || 0;
+    location(pos) {
+        let line = 1;
+        let column = 1;
+        for (const linebreak of this.linebreaks) {
+            if (pos < linebreak)
+                break;
+            line++;
+            column = pos - linebreak;
+        }
+        return { line, column };
+    }
+    parse() {
         this.bibtex();
-        return this.chunks;
+        this.entries.reverse();
     }
-    async parseAsync(input, options = {}) {
-        this.reset(input);
-        this.max_entries = options.max_entries || 0;
+    async parseAsync() {
         await this.bibtexAsync();
-        return this.chunks;
+        this.entries.reverse();
     }
     isWhitespace(s, horizontalOnly = false) {
         return (s === ' ' || s === '\t' || (!horizontalOnly && (s === '\r' || s === '\n')));
     }
-    match(s) {
+    match(s, sws = true) {
         this.skipWhitespace();
         if (this.input.substr(this.pos, s.length) !== s) {
-            throw new ParseError(`Token mismatch, expected ${JSON.stringify(s)}, found ${JSON.stringify(this.input.substr(this.pos, 20))}...`, this); // eslint-disable-line no-magic-numbers
+            throw new ParsingError(`Token mismatch, expected ${JSON.stringify(s)}, found ${JSON.stringify(this.input.substr(this.pos, 20))}...`, this); // eslint-disable-line no-magic-numbers
         }
         this.pos += s.length;
-        this.skipWhitespace();
+        if (sws)
+            this.skipWhitespace();
     }
-    tryMatch(s) {
+    tryMatch(s, consume = false) {
         this.skipWhitespace();
-        return (this.input.substr(this.pos, s.length) === s);
+        const match = (this.input.substr(this.pos, s.length) === s);
+        if (match && consume)
+            this.pos += s.length;
+        return match;
         // this.skipWhitespace()
     }
     skipWhitespace() {
-        while (this.pos < this.input.length && this.isWhitespace(this.input[this.pos]))
-            this.pos++;
-        // shady
-        if (this.input[this.pos] === '%') {
-            while (this.pos < this.input.length && this.input[this.pos] !== '\n')
-                this.pos++;
-            while (this.pos < this.input.length && this.isWhitespace(this.input[this.pos]))
+        while (this.pos < this.input.length && this.input[this.pos].match(/[ \t\r\n%]/)) {
+            // test for '%' is shady
+            if (this.input[this.pos] === '%') {
+                while (this.pos < this.input.length && this.input[this.pos] !== '\n')
+                    this.pos++;
+            }
+            else {
                 this.pos++;
+            }
         }
     }
+    /*
+    private fix_path() {
+      // workaround for https://github.com/siefkenj/unified-latex/issues/94
+      const path = '\\path|'
+      const verb = path.replace('path', 'verb')
+      if (this.input.substring(this.pos).startsWith(path)) {
+        console.log('replacing path')
+        // eslint-disable-next-line prefer-template, no-magic-numbers
+        this.input = this.input.substring(0, this.pos) + verb + this.input.substring(this.pos + path.length)
+      }
+    }
+    */
     value_braces() {
         let bracecount = 0;
-        this.match('{');
+        this.match('{', false);
         const start = this.pos;
         let math = false;
         while (true) { // eslint-disable-line no-constant-condition
+            // this.fix_path()
             switch (this.input[this.pos]) {
                 case '\\':
                     this.pos += 1;
@@ -93,7 +172,7 @@ class BibtexParser {
                 case '}':
                     if (bracecount === 0) {
                         if (math)
-                            throw new ParseError('Unclosed math section', this);
+                            throw new ParsingError('Unclosed math section', this);
                         this.pos++;
                         return this.input.substring(start, this.pos - 1);
                     }
@@ -105,15 +184,16 @@ class BibtexParser {
             }
             this.pos++;
             if (this.pos >= this.input.length) {
-                throw new ParseError(`Unterminated brace-value ${JSON.stringify(this.input.substr(start, 20))}`, this); // eslint-disable-line no-magic-numbers
+                throw new ParsingError(`Unterminated brace-value ${JSON.stringify(this.input.substr(start, 20))}`, this); // eslint-disable-line no-magic-numbers
             }
         }
     }
     value_quotes() {
-        this.match('"');
+        this.match('"', false);
         const start = this.pos;
         let bracecount = 0;
         while (true) { // eslint-disable-line no-constant-condition
+            // this.fix_path()
             switch (this.input[this.pos]) {
                 case '\\':
                     this.pos += 1;
@@ -132,7 +212,7 @@ class BibtexParser {
             }
             this.pos++;
             if (this.pos >= this.input.length) {
-                throw new ParseError(`Unterminated quote-value ${JSON.stringify(this.input.substr(start, 20))}`, this); // eslint-disable-line no-magic-numbers
+                throw new ParsingError(`Unterminated quote-value ${JSON.stringify(this.input.substr(start, 20))}`, this); // eslint-disable-line no-magic-numbers
             }
         }
     }
@@ -145,7 +225,18 @@ class BibtexParser {
         }
         else {
             const bare = this.key();
-            return this.strings[bare] || bare;
+            if (bare.match(/^\d+$/))
+                return bare;
+            const u_bare = bare.toUpperCase();
+            const resolved = this.strings[u_bare] || this.default_strings[u_bare];
+            if (typeof resolved === 'undefined') {
+                this.errors.push({
+                    error: `Unresolved @string reference ${JSON.stringify(bare)}`,
+                    location: this.location(this.pos),
+                    input: bare,
+                });
+            }
+            return resolved || `{{${bare}}}`;
         }
     }
     value() {
@@ -157,16 +248,13 @@ class BibtexParser {
         }
         return values.join('');
     }
-    key(allowUnicode = false) {
+    key(allow = '') {
         const start = this.pos;
         while (true) { // eslint-disable-line no-constant-condition
             if (this.pos === this.input.length) {
-                throw new ParseError('Runaway key', this);
+                throw new ParsingError('Runaway key', this);
             }
-            if (this.input[this.pos].match(/['a-zA-Z0-9&;_:\\./-]/)) {
-                this.pos++;
-            }
-            else if (allowUnicode && this.input[this.pos].match(letter)) {
+            if (this.input[this.pos].match(/[+'a-zA-Z0-9&;_:\\./-]/) || this.input[this.pos].match(letter) || allow.includes(this.input[this.pos])) {
                 this.pos++;
             }
             else {
@@ -174,30 +262,56 @@ class BibtexParser {
             }
         }
     }
-    key_equals_value() {
-        const key = this.key();
+    key_equals_value(key) {
+        key = key || this.key();
+        if (!key)
+            return; // no key found, stray comma
         if (!this.tryMatch('=')) {
-            throw new ParseError(`... = value expected, equals sign missing: ${JSON.stringify(this.input.substr(this.pos, 20))}...`, this); // eslint-disable-line no-magic-numbers
+            throw new ParsingError(`${key} = value expected, equals sign missing: ${JSON.stringify(this.input.substr(this.pos, 20))}...`, this); // eslint-disable-line no-magic-numbers
         }
         this.match('=');
         const val = this.value();
         if (this.parsing === 'string') {
-            this.strings[key.toLowerCase()] = val;
+            this.strings[key.toUpperCase()] = val;
         }
         else {
+            key = key.toLowerCase();
+            if (key.toLowerCase() === 'keywords' && this.entries[0].fields.keywords) { // #873... the things people do with bibtex
+                this.keywords++;
+                key = `keywords[${this.keywords}]`;
+            }
             this.entries[0].fields[key] = val;
         }
     }
-    entry(_d) {
-        this.entries[0].key = this.key(true);
-        this.match(',');
+    entry(d, guard) {
+        if (this.tryMatch(guard))
+            return; // empty entry
+        let key;
+        // mendeley end endnote can output entries without key... sure...
+        if (this.tryMatch(',')) {
+            // mendeley absurdity which outputs keyless entries, but at least have the decency to put a comma there
+            key = '';
+        }
+        else {
+            // so maybe a real key?
+            key = this.key('*"');
+        }
+        if (this.tryMatch('=')) {
+            // nope; endnote just skips the comma; we can infer we're in this moronic situation because we've been dumped into field-parsing
+            this.key_equals_value(key);
+        }
+        else {
+            // so we did find the real key earlier
+            this.entries[0].key = key;
+        }
+        this.tryMatch(',', true);
+        if (this.tryMatch(guard))
+            return; // no fields
         this.key_equals_value();
-        while (this.tryMatch(',')) {
-            this.match(',');
+        while (this.tryMatch(',', true)) {
             // fixes problems with commas at the end of a list
-            if (this.tryMatch('}')) {
-                break;
-            }
+            if (this.tryMatch(guard))
+                return;
             this.key_equals_value();
         }
     }
@@ -209,27 +323,21 @@ class BibtexParser {
         this.key_equals_value();
     }
     preamble() {
-        this.value();
+        this.preambles.push(this.value());
     }
     comment() {
         while (this.isWhitespace(this.input[this.pos], true))
             this.pos++;
         if (this.input[this.pos] === '{') {
-            this.value_braces();
-            return;
+            this.comments.push(this.value_braces());
+        }
+        else {
+            const start = this.pos;
+            while (this.input[this.pos] !== '\n' && this.pos < this.input.length)
+                this.pos++;
+            this.comments.push(this.input.substring(start, this.pos));
         }
-        while (this.input[this.pos] !== '\n' && this.pos < this.input.length)
-            this.pos++;
-    }
-    /*
-    private progress() {
-      const progress = Math.round((this.pos / this.input.length * 100) / 5) * 5 // eslint-disable-line no-magic-numbers
-      if (this._progress !== progress) {
-        this._progress = progress
-        process.stdout.write(` (${this._progress}%) `)
-      }
     }
-    */
     hasMore() {
         if (this.max_entries && this.entries.length >= this.max_entries)
             return false;
@@ -251,22 +359,23 @@ class BibtexParser {
                 return guard[1];
             }
         }
-        throw new ParseError(`Token mismatch, expected '{' or '(', found ${JSON.stringify(this.input.substr(this.pos, 20))}...`, this); // eslint-disable-line no-magic-numbers
+        throw new ParsingError(`Token mismatch, expected '{' or '(', found ${JSON.stringify(this.input.substr(this.pos, 20))}...`, this); // eslint-disable-line no-magic-numbers
     }
     parseNext() {
-        // this.progress()
-        const chunk = {
-            offset: {
-                pos: this.pos,
-                line: this.input.substring(0, this.pos).split('\n').length - 1,
-            },
-            error: null,
-            text: null,
-        };
         this.skipWhitespace();
+        while (this.pos < this.input.length && this.input[this.pos] !== '@') {
+            if (this.input[this.pos] === '%') {
+                while (this.pos < this.input.length && this.input[this.pos] !== '\n')
+                    this.pos++;
+            }
+            else {
+                this.pos++;
+            }
+        }
         if (this.pos >= this.input.length)
             return;
         let guard = '';
+        const start = this.pos;
         try {
             const d = this.parsing = this.directive();
             switch (d) {
@@ -274,85 +383,50 @@ class BibtexParser {
                     guard = this.matchGuard();
                     this.string();
                     this.match(guard);
-                    chunk.stringDeclaration = true;
                     break;
                 case 'preamble':
-                    guard = this.matchGuard();
                     this.preamble();
-                    this.match(guard);
-                    chunk.preamble = true;
                     break;
                 case 'comment':
                     this.comment();
-                    chunk.comment = true;
                     break;
                 default:
                     guard = this.matchGuard();
-                    this.entries.unshift({ type: d, fields: {} });
-                    this.entry(d);
+                    this.entries.unshift({ input: '', type: d, key: '', fields: {} });
+                    this.entry(d, guard);
                     this.match(guard);
-                    chunk.entry = true;
+                    this.entries[0].input = this.input.substring(start, this.pos).trim();
                     break;
             }
         }
         catch (err) {
-            if (err.name !== 'ParseError')
+            if (err.name !== 'ParsingError')
                 throw err;
-            chunk.error = err.message;
             // skip ahead to the next @ and try again
-            this.pos = chunk.offset.pos + 1;
+            this.pos = start + 1;
             while (this.pos < this.input.length && this.input[this.pos] !== '@')
                 this.pos++;
-            /*
-            if (!this.linebreaks) {
-              this.linebreaks = []
-              for (let pos = 0; pos < this.input.length; pos++) {
-                if (this.input[pos] === '\n') this.linebreaks.push({ pos, line: this.linebreaks.length + 1 })
-              }
-            }
-            const line = this.linebreaks.find(l => l.pos >= chunk.offset.pos)
-            if (line) {
-              chunk.offset.line = line.line
-              chunk.offset.pos = chunk.offset.pos - line.pos
-            }
-            else {
-              chunk.offset.line = 1
-            }
-            */
-        }
-        const text = this.input.substring(chunk.offset.pos, this.pos);
-        const last = this.chunks.length - 1;
-        if (chunk.error && this.chunks.length && this.chunks[last].error) {
-            this.chunks[last].text += text;
-        }
-        else {
-            chunk.text = text;
-            this.chunks.push(chunk);
+            this.errors.push({
+                error: err.message,
+                input: this.input.substring(start, this.pos),
+            });
         }
     }
 }
 /**
- * Reads the bibtex input and splits it into separate chunks of `string`s, `@comment`s, and bibtex entries. Useful for detecting if a file is bibtex file and for filtering out basic errors that would
- * make the more sophisticated [[bibtex.parse]] reject the whole file
- *
- * @returns array of chunks, with markers for type and errors (if any) found.
+ * Parses a bibtex source in verbatim mode. Good for detection of bibtex and for later LaTeX-reparsing.
  */
 function parse(input, options = {}) {
-    return (new BibtexParser).parse(input, options);
+    const parser = new Parser(input, options);
+    parser.parse();
+    return parser;
 }
 exports.parse = parse;
-function entries(input, options = {}) {
-    const parser = new BibtexParser;
-    parser.parse(input, options);
-    return {
-        entries: parser.entries.reverse(),
-        errors: parser.chunks.filter(chunk => chunk.error),
-    };
-}
-exports.entries = entries;
 exports.promises = {
     async parse(input, options = {}) {
-        return await (new BibtexParser).parseAsync(input, options);
+        const parser = new Parser(input, options);
+        await parser.parseAsync();
+        return parser;
     },
 };
-//# sourceMappingURL=chunker.js.map
+//# sourceMappingURL=verbatim.js.map

package/chunker.d.ts

@@ -1,60 +0,0 @@
-export interface Chunk {
-    /**
-     * The text content of the chunk
-     */
-    text: string;
-    /**
-     * Start location of the chunk in the bib file
-     */
-    offset: {
-        pos: number;
-        line: number;
-    };
-    /**
-     * error found, if any.
-     */
-    error?: string;
-    /**
-     * set to `true` if the chunk is a `@preamble` block
-     */
-    preamble?: boolean;
-    /**
-     * set to `true` if the chunk is a bibtex entry
-     */
-    entry?: boolean;
-    /**
-     * set to `true` if the chunk is an `@string` declaration
-     */
-    stringDeclaration?: boolean;
-    /**
-     * set to `true` if the chunk is an `@comment`
-     */
-    comment?: boolean;
-}
-export interface ParserOptions {
-    /**
-     * stop parsing after `max_entries` entries have been found. Useful for quick detection if a text file is in fact a bibtex file
-     */
-    max_entries?: number;
-}
-type Entry = {
-    type: string;
-    key?: string;
-    fields: Record<string, string>;
-};
-/**
- * Reads the bibtex input and splits it into separate chunks of `string`s, `@comment`s, and bibtex entries. Useful for detecting if a file is bibtex file and for filtering out basic errors that would
- * make the more sophisticated [[bibtex.parse]] reject the whole file
- *
- * @returns array of chunks, with markers for type and errors (if any) found.
- */
-export declare function parse(input: string, options?: ParserOptions): Chunk[];
-export declare function entries(input: string, options?: ParserOptions): {
-    entries: Entry[];
-    errors: Chunk[];
-};
-export declare const promises: {
-    parse(input: string, options?: ParserOptions): Promise<Chunk[]>;
-};
-export {};
-//# sourceMappingURL=chunker.d.ts.map