@retorquere/bibtex-parser 12.1.13 → 13.0.1

package/dist/cjs/index.js

@@ -1,1126 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var index_exports = {};
-__export(index_exports, {
-  English: () => English,
-  FieldMode: () => FieldMode,
-  JabRefMetadata: () => import_jabref.JabRefMetadata,
-  VerbatimLibrary: () => import_verbatim.Library,
-  parse: () => parse2,
-  parseAsync: () => parseAsync,
-  parseVerbatim: () => import_verbatim.parse,
-  toSentenceCase: () => import_sentence_case2.toSentenceCase,
-  tokenize: () => import_tokenizer2.tokenize
-});
-module.exports = __toCommonJS(index_exports);
-var import_unified_latex_util_pegjs = require("@unified-latex/unified-latex-util-pegjs");
-var import_unified_latex_util_print_raw = require("@unified-latex/unified-latex-util-print-raw");
-var import_unified_latex_util_replace = require("@unified-latex/unified-latex-util-replace");
-var import_unified_latex_util_visit = require("@unified-latex/unified-latex-util-visit");
-var import_unicode2latex = require("unicode2latex");
-var JabRef = __toESM(require("./jabref.js"), 1);
-var bibtex = __toESM(require("./verbatim.js"), 1);
-var import_jabref = require("./jabref.js");
-var import_verbatim = require("./verbatim.js");
-var import_sentence_case = require("./sentence-case.js");
-var import_sentence_case2 = require("./sentence-case.js");
-var import_tokenizer = require("./tokenizer.js");
-var import_tokenizer2 = require("./tokenizer.js");
-var import_yield = require("./yield.js");
-var import_crossref = require("./crossref.js");
-var import_fields = require("./fields.js");
-var import_merge = require("./merge.js");
-function latexMode(node) {
-  return node._renderInfo.mode;
-}
-const macroAliases = {
-  sb: "textsubscript",
-  sp: "textsuperscript"
-};
-function latex2unicode(tex, node) {
-  if (node.type === "macro" && macroAliases[node.content]) {
-    tex = `\\${macroAliases[node.content]}${tex.slice(node.content.length + 1)}`;
-  }
-  const text = import_unicode2latex.latex2unicode[tex];
-  if (typeof text === "string") return text;
-  return text && text[latexMode(node)];
-}
-const open = {};
-const close = {};
-for (const tag of ["i", "b", "sc", "nc", "ncx", "br", "p", "li", "code"]) {
-  open[tag] = `${tag}`;
-  close[tag] = `/${tag}`;
-}
-const collapsable = /\x0E\/([a-z]+)\x0F(\s*)\x0E\1\x0F/ig;
-const Month = {
-  jan: "1",
-  january: "1",
-  feb: "2",
-  february: "2",
-  mar: "3",
-  march: "3",
-  apr: "4",
-  april: "4",
-  may: "5",
-  jun: "6",
-  june: "6",
-  jul: "7",
-  july: "7",
-  aug: "8",
-  august: "8",
-  sep: "9",
-  september: "9",
-  oct: "10",
-  october: "10",
-  nov: "11",
-  november: "11",
-  dec: "12",
-  december: "12"
-};
-const FieldMode = {
-  creatorlist: [
-    "author",
-    "bookauthor",
-    "collaborator",
-    "commentator",
-    "director",
-    "editor",
-    "editora",
-    "editorb",
-    "editors",
-    "holder",
-    "scriptwriter",
-    "translator"
-  ],
-  title: [
-    "title",
-    "subtitle",
-    "series",
-    "shorttitle",
-    "booktitle",
-    // 'type',
-    "origtitle",
-    "maintitle",
-    "eventtitle"
-  ],
-  verbatim: [
-    "doi",
-    "eprint",
-    "file",
-    "files",
-    "pdf",
-    "groups",
-    // jabref unilaterally decided to make this non-standard field verbatim
-    "ids",
-    "url",
-    "verba",
-    "verbb",
-    "verbc",
-    /^keywords([+]duplicate-\d+)?$/,
-    /^citeulike-linkout-[0-9]+$/,
-    /^bdsk-url-[0-9]+$/
-  ],
-  richtext: [
-    "annotation",
-    "comment",
-    "annote",
-    "review",
-    "notes",
-    "note"
-  ],
-  literallist: [
-    "institution",
-    "publisher",
-    "origpublisher",
-    "organization",
-    "location",
-    "origlocation"
-  ]
-};
-const English = [
-  "",
-  "american",
-  "british",
-  "canadian",
-  "english",
-  "australian",
-  "newzealand",
-  "usenglish",
-  "ukenglish",
-  "en",
-  "eng",
-  "en-au",
-  "en-bz",
-  "en-ca",
-  "en-cb",
-  "en-gb",
-  "en-ie",
-  "en-jm",
-  "en-nz",
-  "en-ph",
-  "en-tt",
-  "en-us",
-  "en-za",
-  "en-zw",
-  "anglais"
-  // don't do this people
-];
-const FieldAction = {
-  removeOuterBraces: [
-    "doi"
-    // 'publisher',
-    // 'location',
-  ],
-  parseInt: [
-    "year",
-    "month"
-  ]
-};
-const narguments = {
-  advance: 1,
-  allcaps: 1,
-  ElsevierGlyph: 1,
-  bar: 1,
-  bibcyr: 1,
-  bibstring: 1,
-  chsf: 1,
-  cite: 1,
-  citeauthor: 1,
-  cyrchar: 1,
-  discretionary: 3,
-  ding: 1,
-  emph: 1,
-  enquote: 1,
-  frac: 2,
-  hbox: 1,
-  href: 2,
-  hskip: 1,
-  hspace: 1,
-  ht: 1,
-  mathrm: 1,
-  mbox: 1,
-  mkbibbold: 1,
-  mkbibemph: 1,
-  mkbibitalic: 1,
-  mkbibquote: 1,
-  newcommand: 2,
-  noopsort: 1,
-  ocirc: 1,
-  overline: 1,
-  ProvideTextCommandDefault: 2,
-  rlap: 1,
-  sb: 1,
-  section: 1,
-  symbol: 1,
-  sp: 1,
-  subsection: 1,
-  subsubsection: 1,
-  subsubsubsection: 1,
-  t: 1,
-  textbf: 1,
-  textcite: 1,
-  textit: 1,
-  textrm: 1,
-  textsc: 1,
-  textsl: 1,
-  textsubscript: 1,
-  textsuperscript: 1,
-  texttt: 1,
-  textup: 1,
-  url: 1,
-  vphantom: 1,
-  vspace: 1,
-  wd: 1,
-  // math
-  "math	_": 1,
-  "math	^": 1
-};
-for (const m in import_unicode2latex.combining.tounicode) {
-  narguments[m] = 1;
-}
-class UnsupportedError extends Error {
-}
-class BibTeXParser {
-  current;
-  english;
-  options;
-  fieldMode;
-  newcommands = {};
-  bib;
-  unhandled = /* @__PURE__ */ new Set();
-  split(ast, sep, split) {
-    const roots = [];
-    const nodes = [...ast.content];
-    const types = nodes.map((node) => {
-      if (node.type === "whitespace") return " ";
-      if (node.type === "string" && node.content.match(sep)) return "&";
-      return ".";
-    }).join("");
-    types.split(split).forEach((match, i) => {
-      const content = match.length ? nodes.splice(0, match.length) : [];
-      if (i % 2 === 0) roots.push({ type: "root", content });
-    });
-    return roots;
-  }
-  trimCreator(cr) {
-    return JSON.parse(JSON.stringify(cr, (k, v) => typeof v === "string" ? v.trim() || void 0 : v));
-  }
-  parseCreator(ast) {
-    if (ast.content.length === 1 && ast.content[0].type === "group") return this.trimCreator({ name: this.stringify(ast, { mode: "creatorlist" }) });
-    const { parts, extended } = this.commaSeparatedCreator(ast);
-    if (extended) {
-      const name = {};
-      for (const [attr, value] of Object.entries(extended)) {
-        const rendered = this.stringify(value, { mode: "creatorlist" }).trim();
-        switch (attr) {
-          case "":
-            break;
-          case "given":
-            name.firstName = rendered;
-            break;
-          case "family":
-            name.lastName = rendered;
-            break;
-          case "given-i":
-            name.initial = rendered;
-            break;
-          case "useprefix":
-          case "juniorcomma":
-            name[attr] = rendered.toLowerCase() === "true";
-            break;
-          default:
-            name[attr] = rendered;
-            break;
-        }
-      }
-      return this.trimCreator(name);
-    } else if (parts.length) {
-      const nameparts = parts.map((part) => this.stringify(part, { mode: "creatorlist" }).trim());
-      if (nameparts.length === 3 && nameparts[2] === "") nameparts.pop();
-      if (nameparts.length > 3) {
-        const key = this.current.key ? `@${this.current.key}: ` : "";
-        this.bib.errors.push({
-          error: `${key}unexpected ${nameparts.length}-part name "${nameparts.join(", ")}", dropping "${nameparts.slice(3).join(", ")}"`,
-          input: nameparts.join(", ")
-        });
-      }
-      let [lastName, suffix, firstName] = nameparts.length === 2 ? [nameparts[0], void 0, nameparts[1]] : nameparts.slice(0, 3);
-      let prefix;
-      const m = lastName.match(/^([a-z'. ]+) (.+)/);
-      if (m) {
-        prefix = m[1];
-        lastName = m[2];
-      }
-      return this.trimCreator({
-        lastName,
-        firstName,
-        prefix,
-        suffix
-      });
-    } else {
-      const nameparts = this.split(ast, /^$/, /( )/).map((part) => this.stringify(part, { mode: "creatorlist" })).filter((n) => n);
-      if (nameparts.length === 1) return this.trimCreator({ lastName: nameparts[0] });
-      const prefix = nameparts.findIndex((n) => n.match(/^[a-z]/));
-      const postfix = prefix <= 0 ? -1 : nameparts.findIndex((n, i) => i > prefix && !n.match(/^[a-z]/));
-      if (postfix === -1) {
-        const lastName = nameparts.pop();
-        return this.trimCreator({ lastName, firstName: nameparts.join(" ") });
-      }
-      return this.trimCreator({
-        firstName: nameparts.slice(0, prefix).join(" "),
-        prefix: nameparts.slice(prefix, postfix).join(" "),
-        lastName: nameparts.slice(postfix).join(" ")
-      });
-    }
-  }
-  ligature(nodes) {
-    if (latexMode(nodes[0]) !== "text") return null;
-    const max = 3;
-    const slice = nodes.slice(0, max);
-    const type = slice.map((n) => n.type === "string" ? "s" : " ").join("");
-    if (type[0] !== "s") return null;
-    const content = slice.map((n) => n.type === "string" ? n.content : "");
-    let latex;
-    while (content.length) {
-      if (type.startsWith("s".repeat(content.length)) && (latex = latex2unicode(content.join(""), slice[0]))) {
-        try {
-          return { type: "string", content: latex, _renderInfo: {} };
-        } finally {
-          nodes.splice(0, content.length);
-        }
-      }
-      content.pop();
-    }
-    return null;
-  }
-  wraparg(node, macro) {
-    if (macro.content.match(/^(itshape|textsl|textit|emph|mkbibemph)$/)) node._renderInfo.emph = true;
-    if (macro.content.match(/^(textbf|mkbibbold|bfseries)$/)) node._renderInfo.bold = true;
-    if (macro.content.match(/^(textsc)$/)) node._renderInfo.smallCaps = true;
-    if (macro.content.match(/^(texttt)$/)) node._renderInfo.code = true;
-    return { type: "argument", content: [node], openMark: "", closeMark: "", _renderInfo: { mode: node._renderInfo.mode } };
-  }
-  argtogroup(node) {
-    if (node.content.length === 1 && node.content[0].type === "group") return node.content[0];
-    return { type: "group", content: node.content };
-  }
-  argument(nodes, macro) {
-    if (!nodes.length) return null;
-    if (nodes[0].type === "whitespace") nodes.shift();
-    if (!nodes.length) return null;
-    if (nodes[0].type === "string") {
-      const char = nodes[0].content[0];
-      nodes[0].content = nodes[0].content.substr(1);
-      const arg = { ...nodes[0], content: char };
-      if (!nodes[0].content) nodes.shift();
-      return this.wraparg(arg, macro);
-    }
-    return this.wraparg(nodes.shift(), macro);
-  }
-  unsupported(node) {
-    const tex = (0, import_unified_latex_util_print_raw.printRaw)(node);
-    if (this.options.unsupported === "throw") throw new UnsupportedError(`unhandled ${node.type} ${tex}`);
-    let id;
-    switch (node.type) {
-      case "macro":
-        id = `${node.type}.${node.content}`;
-        if (!this.unhandled.has(id)) {
-          this.unhandled.add(id);
-          this.bib.errors.push({ error: `unhandled ${node.type} ${(0, import_unified_latex_util_print_raw.printRaw)(node)}`, input: (0, import_unified_latex_util_print_raw.printRaw)(node) });
-        }
-        break;
-      case "environment":
-        id = `${node.type}.${node.env}`;
-        if (!this.unhandled.has(id)) {
-          this.unhandled.add(id);
-          this.bib.errors.push({ error: `unhandled ${node.type} ${node.env} (${(0, import_unified_latex_util_print_raw.printRaw)(node)})`, input: (0, import_unified_latex_util_print_raw.printRaw)(node) });
-        }
-        break;
-      default:
-        this.bib.errors.push({ error: `unhandled ${node.type} (${(0, import_unified_latex_util_print_raw.printRaw)(node)})`, input: (0, import_unified_latex_util_print_raw.printRaw)(node) });
-        break;
-    }
-    const command = node.type === "macro" ? `\\${node.content}` : tex;
-    switch (this.options.unsupported) {
-      case "ignore":
-        return "";
-      case "text":
-        return command.replace(/^\\/, "");
-      case "tex":
-        return `<script>${command}<\/script>`;
-      default:
-        return tex;
-    }
-  }
-  wrap(text, tag, wrap = true) {
-    if (!text || !wrap) return text || "";
-    return `${tag}${text}/${tag}`;
-  }
-  registercommand(node) {
-    const types = (nodes) => nodes.map((n) => n.type).join(".");
-    const group = (arg, kind) => {
-      if (!arg) throw new Error(`missing ${kind} for ${(0, import_unified_latex_util_print_raw.printRaw)(node)} @ ${JSON.stringify(node.position)}`);
-      if (types(arg.content) !== "group") throw new Error(`Malformed ${kind} for ${(0, import_unified_latex_util_print_raw.printRaw)(node)} @ ${JSON.stringify(node.position)}`);
-      return arg.content[0].content;
-    };
-    if (!node.args) throw new Error(`No arguments for ${(0, import_unified_latex_util_print_raw.printRaw)(node)} @ ${JSON.stringify(node.position)}`);
-    const namearg = group(node.args[0], "name");
-    if (types(namearg) !== "macro") throw new Error(`Unexpected name for ${(0, import_unified_latex_util_print_raw.printRaw)(node)} @ ${JSON.stringify(node.position)}`);
-    this.newcommands[namearg[0].content] = node.args[1];
-    return "";
-  }
-  subp(text, mode) {
-    const macro = { sub: "_", sup: "^" }[mode];
-    let subp = "";
-    for (let char of text) {
-      const mapped = import_unicode2latex.latex2unicode[`${macro}{${char}}`];
-      switch (typeof mapped) {
-        case "string":
-          subp += mapped;
-          break;
-        case "undefined":
-          return `${mode}${text}/${mode}`;
-        default:
-          subp += mapped.math;
-      }
-    }
-    return subp;
-  }
-  macro(node, context) {
-    var _a, _b, _c;
-    const name = macroAliases[node.content] ?? node.content;
-    if (name === "discretionary") {
-      return ((_a = node.args) == null ? void 0 : _a[2]) ? this.stringify(node.args[2], context) : "";
-    }
-    if (name === "symbol") {
-      const argument = ((_c = (_b = node.args) == null ? void 0 : _b[0]) == null ? void 0 : _c.content) ?? [];
-      const content = argument.length === 1 && argument[0].type === "group" ? argument[0].content : argument;
-      const code = content.map((n) => this.stringify(n, context)).join("").trim();
-      const value = /^\d+$/.test(code) ? Number(code) : NaN;
-      if (Number.isSafeInteger(value) && value <= 1114111 && !(value >= 55296 && value <= 57343)) {
-        return String.fromCodePoint(value);
-      }
-      return this.unsupported(node);
-    }
-    const text = latex2unicode((0, import_unified_latex_util_print_raw.printRaw)(node), node);
-    if (text) return text;
-    let url;
-    let label;
-    let arg;
-    switch (name) {
-      case "newcommand":
-      case "ProvideTextCommandDefault":
-        return this.registercommand(node);
-      // too complex to deal with these
-      case "raise":
-      case "accent":
-      case "def":
-      case "hss":
-      case "ifmmode":
-      case "makeatletter":
-      case "makeatother":
-      case "scriptscriptstyle":
-      case "setbox":
-      case "dimen":
-      case "advance":
-        return "";
-      case "vphantom":
-      case "noopsort":
-      case "left":
-      case "right":
-      case "ensuremath":
-      case "wd":
-      case "ht":
-        return "";
-      case "path":
-        return "";
-      // until https://github.com/siefkenj/unified-latex/issues/94 is fixed
-      case "hspace":
-      case "hskip":
-        if (node.args && node.args.length) {
-          if ((0, import_unified_latex_util_print_raw.printRaw)(node.args).match(/^[{]?0[a-z]*$/)) return "";
-          return " ";
-        }
-        return "";
-      case "overline":
-      case "bar":
-        return node.args.map((a) => this.stringify(a, context)).join("").replace(/[a-z0-9]/ig, (m) => `${m}\u0305`);
-      // accents dealt with by preprocessor
-      case "textup":
-      case "textsc":
-      case "textrm":
-      case "texttt":
-      case "mathrm":
-      case "mbox":
-      case "hbox":
-      case "rlap":
-        return node.args.map((n) => this.stringify(n, context)).join("");
-      case "href":
-      case "url":
-        if (node.args) {
-          url = node.args[0];
-          label = node.args[node.content === "url" ? 0 : 1];
-        }
-        return `<a href="${this.stringify(url, context)}">${this.stringify(label, context)}</a>`;
-      case "relax":
-      case "aftergroup":
-      case "ignorespaces":
-      case "undefined":
-      case "em":
-      case "it":
-      case "tt":
-      case "sl":
-      case "if":
-      case "ifx":
-      case "else":
-        return "";
-      case "rm":
-      case "sc":
-        return "";
-      // bold/emph/smallcaps is handled in the wrapper
-      case "textbf":
-      case "mkbibbold":
-      case "textit":
-      case "emph":
-      case "mkbibemph":
-        return this.stringify(node.args[0], context);
-      case "textsuperscript":
-        return this.subp(this.stringify(node.args[0], context), "sup");
-      case "textsubscript":
-        return this.subp(this.stringify(node.args[0], context), "sub");
-      case "allcaps":
-        return this.wrap(this.stringify(node.args[0], { ...context, caseProtected: true }), "nc", this.english && context.mode === "title");
-      case "_":
-      case "^":
-        switch (latexMode(node)) {
-          case "math":
-            return this.subp(this.stringify(node.args[0], context), node.content === "^" ? "sup" : "sub");
-          default:
-            return node.content;
-        }
-      case "LaTeX":
-        return this.wrap(`L${this.subp("A", "sup")}T${this.subp("E", "sub")}X`, "ncx");
-      case "enquote":
-      case "mkbibquote":
-        return this.wrap(this.stringify(node.args[0], context), "enquote");
-      case "\\":
-        return context.mode === "richtext" ? open.br : " ";
-      case " ":
-        return " ";
-      case "par":
-        return context.mode === "richtext" ? open.p : " ";
-      case "item":
-        return context.mode === "richtext" ? open.li : " ";
-      case "section":
-      case "subsection":
-      case "subsubsection":
-      case "subsubsubsection":
-        return this.wrap(this.stringify(node.args[0], context), `h${node.content.split("sub").length}`);
-      case "frac":
-        arg = node.args.map((a) => this.stringify(a, context));
-        if (arg.length === 2) {
-          const resolved = import_unicode2latex.latex2unicode[`\\frac${arg.map((a) => `{${a}}`).join("")}`];
-          if (resolved) return typeof resolved === "string" ? resolved : resolved.math || resolved.text;
-        }
-        return arg.map((part, i) => this.subp(part, i ? "sub" : "sup")).join("\u2044");
-      case "chsf":
-      case "bibstring":
-      case "cite":
-      case "textcite":
-      case "citeauthor":
-        return this.wrap(this.stringify(node.args[0], context), "ncx", context.mode === "title");
-      default:
-        if (this.newcommands[node.content]) return this.stringify(this.newcommands[node.content], context);
-        return this.unsupported(node);
-    }
-  }
-  what(node) {
-    if (!node) return "";
-    switch (node.type) {
-      case "macro":
-        return `macro:${node._renderInfo.mode ?? "text"}:${node.content}`;
-      case "environment":
-        return `env:${node.env}`;
-      default:
-        return node.type;
-    }
-  }
-  environment(node, context) {
-    while (node.content.length && this.what(node.content[0]).match(/^parbreak|whitespace|macro:text:par$/)) node.content.shift();
-    while (node.content.length && this.what(node.content[node.content.length - 1]).match(/^parbreak|whitespace|macro:text:par$/)) node.content.pop();
-    switch (node.env) {
-      case "quotation":
-        return this.wrap(node.content.map((n) => this.stringify(n, context)).join(""), "blockquote", context.mode === "richtext");
-      case "itemize":
-        return this.wrap(node.content.map((n) => this.stringify(n, context)).join(""), "ul", context.mode === "richtext");
-      case "em":
-        return this.wrap(node.content.map((n) => this.stringify(n, context)).join(""), "i", context.mode === "richtext");
-      default:
-        return this.unsupported(node);
-    }
-  }
-  stringify(node, context) {
-    let content = this.stringifyContent(node, context);
-    if (content && node._renderInfo) {
-      if (node._renderInfo.emph) content = `${open.i}${content}${close.i}`;
-      if (node._renderInfo.bold) content = `${open.b}${content}${close.b}`;
-      if (node._renderInfo.smallCaps) content = `${open.sc}${content}${close.sc}`;
-      if (node._renderInfo.code) content = `${open.code}${content}${close.code}`;
-      if (this.english && node._renderInfo.protectCase && !context.caseProtected) content = `${open.nc}${content}${close.nc}`;
-    }
-    return content;
-  }
-  stringifyContent(node, context) {
-    if (!node) return "";
-    switch (node.type) {
-      case "root":
-      case "argument":
-      case "group":
-      case "inlinemath":
-        return node.content.map((n) => this.stringify(n, context)).join("");
-      case "string":
-      case "verbatim":
-        return node.content;
-      case "macro":
-        return this.macro(node, context);
-      case "parbreak":
-        return context.mode === "richtext" ? open.p : " ";
-      case "whitespace":
-        return node._renderInfo.mode === "math" ? "" : " ";
-      case "comment":
-        return "";
-      case "environment":
-        return this.environment(node, context);
-      case "verb":
-        return node.content;
-      default:
-        return this.unsupported(node);
-    }
-  }
-  protect(node) {
-    if (node.type === "inlinemath") return true;
-    if (node.type !== "group") return false;
-    if (!node.content.length) return false;
-    return node.content[0].type !== "macro";
-  }
-  mode(field) {
-    if (this.options.verbatimFields && this.options.verbatimFields.find((name) => typeof name === "string" ? name === field : field.match(name))) return "verbatim";
-    let mode = "literal";
-    for (const [selected, fields] of Object.entries(this.fieldMode)) {
-      if (fields.find((match) => typeof match === "string" ? field === match : field.match(match))) mode = selected;
-    }
-    return mode;
-  }
-  restoreMarkup(s) {
-    if (!s.includes("")) return s;
-    const restored = [s.replace(/\x0E\/?ncx\x0F/ig, "")];
-    while (restored[0] !== restored[1]) {
-      restored.unshift(restored[0].replace(collapsable, "$2"));
-    }
-    return restored[0].replace(/(\x0Ep\x0F\s*){2,}/ig, "p").replace(/\s*(\x0E\/p\x0F){2,}/ig, "/p").replace(/\x0Eenquote\x0F/ig, "\u201C").replace(/\x0E\/enquote\x0F/ig, "\u201D").replace(/\x0Esc\x0F/ig, '<span style="font-variant:small-caps;">').replace(/\x0E\/sc\x0F/ig, "</span>").replace(/\x0Enc\x0F/ig, '<span class="nocase">').replace(/\x0E\/nc\x0F/ig, "</span>").replace(/\x0E/ig, "<").replace(/\x0F/ig, ">");
-  }
-  stringField(field, value, mode, guessSC) {
-    if (field === "crossref") return value;
-    if (FieldAction.parseInt.includes(field) && value.trim().match(/^-?\d+$/)) return `${parseInt(value)}`;
-    if (this.english && mode === "title") {
-      value = (0, import_sentence_case.toSentenceCase)(value, {
-        preserveQuoted: this.options.sentenceCase && this.options.sentenceCase.preserveQuoted,
-        subSentenceCapitalization: this.options.sentenceCase && this.options.sentenceCase.subSentence,
-        markup: /\x0E\/?([a-z]+)\x0F/ig,
-        nocase: /\x0E(ncx?)\x0F.*?\x0E\/\1\x0F/ig,
-        guess: guessSC
-      });
-      let cancel = (_match, stripped) => stripped;
-      switch (this.options.caseProtection) {
-        case "strict":
-          cancel = (match, _stripped) => match;
-          break;
-        case "as-needed":
-          cancel = (match, stripped) => {
-            const words = (0, import_tokenizer.tokenize)(stripped, /\x0E\/?([a-z]+)\x0F/ig);
-            return words.find((w) => w.shape.match(/^(?!.*X).*x.*$/)) ? match : this.wrap(stripped, "ncx");
-          };
-          break;
-      }
-      return value.replace(/\x0Enc\x0F(.*?)\x0E\/nc\x0F/ig, cancel);
-    }
-    return value;
-  }
-  commaSeparatedCreator(ast) {
-    var _a;
-    const result = {
-      parts: []
-    };
-    if (!ast.content.find((node) => node.type === "string" && node.content === ",")) return result;
-    result.parts = this.split(ast, /^,$/, /(&)/);
-    result.extended = {};
-    for (const part of result.parts) {
-      const start = ((_a = part.content[0]) == null ? void 0 : _a.type) === "whitespace" ? 1 : 0;
-      let signature = part.content.slice(start, start + 4).map((node, i) => node._renderInfo.mode === "text" && node.type === "string" ? node.content.replace(i % 2 ? /[^=-]/g : /[^a-z]/gi, ".") : ".").join("");
-      if (signature.match(/^[a-z]+(-[a-z]+)?=/i)) {
-        signature = signature.replace(/=.*/, "").toLowerCase();
-        result.extended[signature] = { type: "root", content: part.content.slice(signature.includes("-") ? start + 4 : start + 2) };
-      } else {
-        delete result.extended;
-        break;
-      }
-    }
-    return result;
-  }
-  field(entry, field, value) {
-    const mode = entry.mode[field] = this.mode(field);
-    const caseProtection = {
-      present: false,
-      intuitive: 0
-      // a lot of people don't realise `some text \textit{in italics}` will protect 'in italics'
-    };
-    const ast = import_unified_latex_util_pegjs.LatexPegParser.parse(value);
-    if (this.options.removeOuterBraces.includes(field) && ast.content.length === 1 && ast.content[0].type === "group") {
-      ast.content = ast.content[0].content;
-    }
-    if (mode === "verbatim") {
-      entry.fields[field] = (0, import_unified_latex_util_print_raw.printRaw)(ast);
-      return;
-    }
-    if (this.english && mode === "title") {
-      let root = [...ast.content];
-      while (root.length) {
-        const node = root.shift();
-        if (this.protect(node)) node._renderInfo = { root: true };
-        if (node.type === "environment") root = [...root, ...node.content];
-      }
-    }
-    (0, import_unified_latex_util_visit.visit)(ast, (node, info) => {
-      if (!node._renderInfo) node._renderInfo = {};
-      node._renderInfo.mode = info.context.inMathMode ? "math" : "text";
-      if (mode === "title" && node.type === "inlinemath" && !info.parents.find((p) => p._renderInfo.protectCase)) node._renderInfo.protectCase = true;
-      if (!info.context.inMathMode) {
-        if (mode === "title" && node._renderInfo.root && (node.type !== "group" || node.content[0].type !== "macro")) {
-          node._renderInfo.protectCase = true;
-          if (node.type === "group") {
-            caseProtection.present = true;
-            caseProtection.intuitive += 1;
-          }
-        }
-        if (node.type === "macro" && typeof node.escapeToken !== "string") node.escapeToken = "\\";
-        if (node.type === "environment" && node.env === "em") node._renderInfo.emph = true;
-      }
-    });
-    if (this.options.raw) {
-      switch (mode) {
-        case "creatorlist":
-          entry.fields[field] = this.split(ast, /^and$/i, /(^& | & | &$)/).map((cr) => {
-            const { parts, extended } = this.commaSeparatedCreator(cr);
-            if (parts.length === 2 && !extended) {
-              return this.trimCreator({ lastName: (0, import_unified_latex_util_print_raw.printRaw)(parts[0]), firstName: (0, import_unified_latex_util_print_raw.printRaw)(parts[1]) });
-            }
-            if (!parts.length) {
-              const nameparts = this.split(ast, /^$/, /( )/);
-              if (nameparts.length === 2) {
-                return this.trimCreator({
-                  lastName: (0, import_unified_latex_util_print_raw.printRaw)(nameparts[1]),
-                  firstName: (0, import_unified_latex_util_print_raw.printRaw)(nameparts[0])
-                });
-              }
-            }
-            return { name: (0, import_unified_latex_util_print_raw.printRaw)(cr) };
-          });
-          return;
-        case "literallist":
-          entry.fields[field] = this.split(ast, /^and$/i, /(^& | & | &$)/).map((elt) => (0, import_unified_latex_util_print_raw.printRaw)(elt));
-          return;
-        default:
-          entry.fields[field] = (0, import_unified_latex_util_print_raw.printRaw)(ast);
-          return;
-      }
-    }
-    (0, import_unified_latex_util_visit.visit)(ast, (nodes, info) => {
-      var _a;
-      const compacted = [];
-      let inif = 0;
-      while (nodes.length) {
-        const ligatureResult = this.ligature(nodes);
-        if (ligatureResult) {
-          compacted.push(ligatureResult);
-          continue;
-        }
-        const node = nodes.shift();
-        if (node.type === "macro" && node.content === "ifdefined") {
-          inif += 1;
-          continue;
-        } else if (node.type === "macro" && node.content === "else") {
-          continue;
-        } else if (node.type === "macro" && node.content === "fi") {
-          inif = Math.max(inif - 1, 0);
-          continue;
-        } else if (inif) {
-          continue;
-        }
-        const nargs = node.type === "macro" ? narguments[node.content] || narguments[`${info.context.inMathMode ? "math" : "text"}	${node.content}`] : 0;
-        if (node.type === "macro" && nargs) {
-          const args = Array(nargs).fill(void 0).map((_i) => this.argument(nodes, node)).filter((arg) => arg !== null);
-          node.args = args;
-          if (node.content.match(/^(url|href)$/) && args.length) {
-            let url = args[0].content;
-            if (url.length === 1 && url[0].type === "group") url = url[0].content;
-            args[0] = this.wraparg({ type: "string", content: (0, import_unified_latex_util_print_raw.printRaw)(url), _renderInfo: { mode: url[0]._renderInfo.mode } }, node);
-          }
-          caseProtection.intuitive -= args.filter((arg) => arg.content[0].type === "group" && arg.content[0]._renderInfo.protectCase).length;
-        } else if (node.type === "macro" && node.content.match(/^[a-z]+$/i) && ((_a = nodes[0]) == null ? void 0 : _a.type) === "whitespace") {
-          nodes.shift();
-        }
-        compacted.push(node);
-      }
-      if (!info.context.inMathMode) {
-        for (const [macro, markup] of Object.entries({ em: "emph", it: "emph", sl: "emph", bf: "bold", sc: "smallCaps", tt: "code" })) {
-          if (info.parents.find((p) => {
-            var _a2;
-            return (_a2 = p._renderInfo) == null ? void 0 : _a2[markup];
-          })) continue;
-          compacted.forEach((markup_node, i) => {
-            if (markup_node.type === "macro" && markup_node.content === macro) {
-              compacted.slice(i + 1).forEach((n) => n._renderInfo[markup] = true);
-            }
-          });
-        }
-      }
-      nodes.push(...compacted);
-    }, { test: Array.isArray, includeArrays: true });
-    (0, import_unified_latex_util_replace.replaceNode)(ast, (node, _info) => {
-      var _a;
-      if (node.type !== "macro") return;
-      if (node.escapeToken && import_unicode2latex.combining.tounicode[node.content]) {
-        let arg;
-        if (!node.args || node.args.length === 0 || node.args[0].content.length === 0) {
-          arg = { type: "string", content: " ", _renderInfo: {} };
-        } else if (node.args.length !== 1 || node.args[0].content.length !== 1) {
-          return;
-        } else {
-          arg = node.args[0].content[0];
-        }
-        if (arg.type === "group") {
-          switch (arg.content.length) {
-            case 0:
-              arg = { type: "string", content: " ", _renderInfo: {} };
-              break;
-            case 1:
-              arg = arg.content[0];
-              break;
-            default:
-              return;
-          }
-        }
-        switch (arg.type) {
-          case "verbatim":
-          case "string":
-            return { type: "string", content: `${arg.content}${import_unicode2latex.combining.tounicode[node.content]}`, _renderInfo: {} };
-          case "macro":
-            if (arg.escapeToken && /^[A-Za-z]$/.test(arg.content) && !((_a = arg.args) == null ? void 0 : _a.length)) {
-              const command = `${arg.escapeToken}${arg.content}`;
-              if (!(command in import_unicode2latex.latex2unicode)) {
-                return { type: "string", content: `${arg.content}${import_unicode2latex.combining.tounicode[node.content]}`, _renderInfo: {} };
-              }
-            }
-            return;
-          default:
-            return;
-        }
-      }
-      let latex = `${node.escapeToken}${node.content}`;
-      latex += (node.args || []).map((arg) => (0, import_unified_latex_util_print_raw.printRaw)(this.argtogroup(arg))).join("");
-      if (latex in import_unicode2latex.latex2unicode) return { type: "string", content: latex2unicode(latex, node), _renderInfo: {} };
-    });
-    switch (mode) {
-      case "creatorlist":
-        entry.fields[field] = this.split(ast, /^and$/i, /(^& | & | &$)/).map((cr) => this.parseCreator(cr)).filter((cr) => Object.keys(cr).length);
-        break;
-      case "literallist":
-        entry.fields[field] = this.split(ast, /^and$/i, /(^& | & | &$)/).map((elt) => this.stringify(elt, { mode: "literal" }).trim());
-        break;
-      default:
-        entry.fields[field] = this.stringField(
-          field,
-          this.stringify(ast, { mode }),
-          mode,
-          !!(this.options.sentenceCase && this.options.sentenceCase.guess)
-          // && (!caseProtection.present || caseProtection.intuitive > 0)
-        );
-        break;
-    }
-    entry.fields[field] = JSON.parse(JSON.stringify(entry.fields[field], (k, v) => typeof v === "string" ? this.restoreMarkup(v) : v));
-  }
-  reset(options = {}) {
-    if (options.sentenceCase === false) {
-      options = {
-        ...options,
-        english: false,
-        sentenceCase: {
-          guess: false,
-          subSentence: false,
-          preserveQuoted: false
-        }
-      };
-    }
-    this.options = (0, import_merge.merge)(options, {
-      caseProtection: "as-needed",
-      applyCrossRef: options.applyCrossRef ?? true,
-      fieldMode: {},
-      english: English,
-      sentenceCase: {
-        guess: true,
-        preserveQuoted: true
-      }
-    });
-    if (this.options.caseProtection === true) this.options.caseProtection = "as-needed";
-    if (this.options.verbatimFields) this.options.verbatimFields = this.options.verbatimFields.map((f) => typeof f === "string" ? f.toLowerCase() : new RegExp(f.source, f.flags + (f.flags.includes("i") ? "" : "i")));
-    if (typeof this.options.english === "boolean") this.options.english = this.options.english ? English : [];
-    this.options.english = this.options.english.map((langid) => langid.toLowerCase());
-    this.fieldMode = Object.entries(FieldMode).reduce((acc, [mode, test]) => {
-      const strings = test.filter((fieldname_or_regex) => typeof fieldname_or_regex === "string" && !this.options.fieldMode[fieldname_or_regex]);
-      const regexes = test.filter((fieldname_or_regex) => typeof fieldname_or_regex !== "string");
-      acc[mode] = [...strings, ...regexes];
-      return acc;
-    }, {});
-    for (const [field, mode] of Object.entries(this.options.fieldMode)) {
-      this.fieldMode[mode].unshift(field);
-    }
-    if (!this.options.removeOuterBraces) {
-      this.options.removeOuterBraces = [
-        ...FieldAction.removeOuterBraces,
-        ...this.fieldMode.title,
-        ...this.fieldMode.verbatim
-      ].filter((field) => typeof field === "string");
-    }
-    if (options.unsupported !== void 0 && !["tex", "text", "ignore", "throw"].includes(options.unsupported)) {
-      throw new TypeError("unsupported must be tex, text, ignore, or throw");
-    }
-    this.bib = {
-      errors: [],
-      entries: [],
-      comments: [],
-      strings: {},
-      preambles: [],
-      jabref: new JabRef.JabRefMetadata()
-    };
-  }
-  reparse(verbatim) {
-    let langid = (verbatim.fields.langid || verbatim.fields.hyphenation || "").toLowerCase();
-    if (!langid && this.options.languageAsLangid && verbatim.fields.language) langid = verbatim.fields.language.toLowerCase();
-    this.english = this.options.english.includes(langid);
-    const entry = this.current = {
-      type: verbatim.type,
-      key: verbatim.key,
-      fields: {},
-      mode: {},
-      input: verbatim.input
-    };
-    let keywords = [];
-    try {
-      for (let [field, value] of Object.entries(verbatim.fields)) {
-        if (!value.trim()) continue;
-        if (field.match(/^keywords([+]duplicate-\d+)?$/)) field = "keywords";
-        this.field(entry, field, value);
-        if (field === "keywords") {
-          keywords = [...keywords, ...entry.fields.keywords.split(/\s*[,;]\s*/)].map((k) => k.trim()).filter((k) => k);
-          delete entry.fields.keywords;
-        }
-        if (!this.options.raw && typeof entry.fields[field] === "string") {
-          entry.fields[field] = entry.fields[field].trim();
-          if (field === "month") entry.fields[field] = Month[entry.fields[field].toLowerCase()] || entry.fields[field];
-        }
-      }
-      if (keywords.length) {
-        entry.fields.keywords = keywords;
-        entry.mode.keywords = "verbatimlist";
-      }
-      this.bib.entries.push(entry);
-    } catch (err) {
-      if (err instanceof UnsupportedError) throw err;
-      this.bib.errors.push({ error: `${err.message}
-${entry.input}`, input: entry.input });
-    }
-  }
-  content(tex) {
-    const entry = { key: "", type: "", fields: {}, mode: {}, input: tex };
-    const english = this.english;
-    this.english = false;
-    this.field(entry, "tex", tex);
-    this.english = english;
-    return entry.fields.tex;
-  }
-  prep(base) {
-    for (const preamble of base.preambles) {
-      try {
-        this.content(preamble);
-      } catch (err) {
-        if (err instanceof UnsupportedError) throw err;
-      }
-    }
-    for (const [k, v] of Object.entries(base.strings)) {
-      this.bib.strings[k] = this.content(v);
-    }
-  }
-  finalize(base) {
-    var _a;
-    if (this.options.applyCrossRef) {
-      const entries = {};
-      for (const entry of this.bib.entries) {
-        if (entry.key) entries[entry.key.toUpperCase()] = entry;
-      }
-      const order = [];
-      for (const entry of this.bib.entries) {
-        if (!entry.key || typeof entry.fields.crossref !== "string") continue;
-        const crossref = entry.fields.crossref.toUpperCase();
-        if (!entries[crossref]) continue;
-        const key = entry.key.toUpperCase();
-        if (!order.includes(crossref)) order.unshift(crossref);
-        if (!order.includes(key)) order.push(key);
-      }
-      for (const key of order) {
-        const child = entries[key.toUpperCase()];
-        const parent = entries[(_a = child.fields.crossref) == null ? void 0 : _a.toUpperCase()];
-        if (!parent) continue;
-        for (const mappings of [import_crossref.crossref[child.type], import_crossref.crossref["*"]].filter((m) => m)) {
-          for (const mapping of [mappings[parent.type], mappings["*"]].filter((m) => m)) {
-            for (const [childfield, parentfield] of Object.entries(mapping)) {
-              if (!child.fields[childfield] && parent.fields[parentfield]) {
-                child.fields[childfield] = parent.fields[parentfield];
-                child.crossref ??= {};
-                child.crossref[childfield] = { parent: parent.key, field: parentfield };
-              }
-            }
-            for (const field of import_fields.allowed[child.type] || []) {
-              if (import_fields.noCrossRef.includes(field)) continue;
-              if (!child.fields[field] && parent.fields[field]) {
-                child.fields[field] = parent.fields[field];
-                child.crossref ??= {};
-                child.crossref[field] = { parent: parent.key, field };
-              }
-            }
-          }
-        }
-      }
-    }
-    const { comments, jabref } = JabRef.parse(base.comments);
-    this.bib.comments = comments;
-    this.bib.jabref = jabref;
-    this.bib.preambles = base.preambles;
-    this.bib.errors = [...base.errors, ...this.bib.errors];
-  }
-  parse(input, options = {}) {
-    this.reset(options);
-    const base = bibtex.parse(input, { strings: options.strings });
-    this.prep(base);
-    for (const entry of base.entries) {
-      this.reparse(entry);
-    }
-    this.finalize(base);
-    return this.bib;
-  }
-  async parseAsync(input, options = {}) {
-    this.reset(options);
-    const base = await bibtex.promises.parse(input, { strings: options.strings });
-    this.prep(base);
-    let n = 1;
-    for (const entry of base.entries) {
-      this.reparse(entry);
-      if (n++ % 1e3 === 0) await (0, import_yield.playnice)();
-    }
-    this.finalize(base);
-    return this.bib;
-  }
-}
-function parse2(input, options = {}) {
-  const parser = new BibTeXParser();
-  return parser.parse(input, options);
-}
-async function parseAsync(input, options = {}) {
-  const parser = new BibTeXParser();
-  return await parser.parseAsync(input, options);
-}
-//# sourceMappingURL=index.js.map