bibtex-tidy.js

/**
 * bibtex-tidy v1.14.0
 * https://github.com/FlamingTempura/bibtex-tidy
 *
 * DO NOT EDIT THIS FILE. This file is automatically generated
 * using `npm run build`. Edit files in './src' then rebuild.
 **/

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  tidy: () => tidy
});
module.exports = __toCommonJS(index_exports);

// src/parsers/latexParser.ts
var BlockNode = class _BlockNode {
  constructor(kind, parent, children = []) {
    this.kind = kind;
    this.parent = parent;
    this.children = children;
    this.type = "block";
    if (parent instanceof _BlockNode) {
      parent.children.push(this);
    } else if (parent instanceof CommandNode) {
      parent.args.push(this);
    }
  }
  static {
    __name(this, "BlockNode");
  }
  renderAsText() {
    return this.children.map((child) => child.renderAsText()).join("");
  }
};
var TextNode = class {
  constructor(parent, text = "") {
    this.parent = parent;
    this.text = text;
    this.type = "text";
    parent.children.push(this);
  }
  static {
    __name(this, "TextNode");
  }
  renderAsText() {
    return this.text.replace(/"/g, "");
  }
};
var CommandNode = class {
  constructor(parent, command = "", args = []) {
    this.parent = parent;
    this.command = command;
    this.args = args;
    this.type = "command";
    parent.children.push(this);
  }
  static {
    __name(this, "CommandNode");
  }
  renderAsText() {
    return this.args.map((arg) => arg.renderAsText()).join("");
  }
};
function parseLaTeX(input) {
  const rootNode = new BlockNode("root");
  let node = rootNode;
  for (let i = 0; i < input.length; i++) {
    const char = input[i];
    if (!char) break;
    switch (node.type) {
      case "block": {
        if (char === "\\") {
          node = new CommandNode(node);
        } else if (char === "{") {
          node = new BlockNode("curly", node);
        } else if ((char === "}" && node.kind === "curly" || char === "]" && node.kind === "square") && node.parent) {
          node = node.parent;
        } else {
          node = new TextNode(node, char);
        }
        break;
      }
      case "text": {
        if (char === "\\" || char === "{") {
          node = node.parent;
          i--;
        } else if (char === "}" && node.parent.kind === "curly" || char === "]" && node.parent.kind === "square") {
          node = node.parent;
          i--;
        } else {
          node.text += char;
        }
        break;
      }
      case "command": {
        if (char === "{") {
          node = new BlockNode("curly", node);
        } else if (char === "[") {
          node = new BlockNode("square", node);
        } else if (char === "}" && node.parent.kind === "curly" || char === "]" && node.parent.kind === "square" || /\s/.test(char) || node.args.length > 0) {
          node = node.parent;
          i--;
        } else {
          node.command += char;
        }
      }
    }
  }
  return rootNode;
}
__name(parseLaTeX, "parseLaTeX");
function stringifyLaTeX(ast) {
  return stringifyBlock(ast);
}
__name(stringifyLaTeX, "stringifyLaTeX");
function stringifyBlock(block) {
  const content = block.children.map((node) => {
    switch (node.type) {
      case "block":
        return stringifyBlock(node);
      case "command":
        return stringifyCommand(node);
      case "text":
        return node.text;
    }
  }).join("");
  switch (block.kind) {
    case "root":
      return content;
    case "curly":
      return `{${content}}`;
    case "square":
      return `[${content}]`;
  }
}
__name(stringifyBlock, "stringifyBlock");
function stringifyCommand(node) {
  return `\\${node.command}${node.args.map(stringifyBlock).join("")}`;
}
__name(stringifyCommand, "stringifyCommand");
function flattenLaTeX(block) {
  const newBlock = new BlockNode(block.kind);
  for (const child of block.children) {
    if (child.type === "block" && child.kind === "curly" && child.children.every((child2) => child2.type !== "command")) {
      const newChild = flattenLaTeX(child);
      newBlock.children.push(...newChild.children);
    } else {
      newBlock.children.push(child);
    }
  }
  return newBlock;
}
__name(flattenLaTeX, "flattenLaTeX");

// src/transforms/encloseBraces.ts
function createEncloseBracesTransform(fields) {
  const set = new Set(fields.map((f) => f.toLocaleLowerCase()));
  return {
    name: "enclose-braces",
    dependencies: ["prefer-curly"],
    apply: /* @__PURE__ */ __name((ast) => {
      for (const field of ast.fields()) {
        if (set.has(field.name.toLocaleLowerCase())) {
          for (const node of field.value.concat) {
            if (node.type === "braced") {
              node.value = doubleEnclose(node.value);
            }
          }
        }
      }
      return void 0;
    }, "apply")
  };
}
__name(createEncloseBracesTransform, "createEncloseBracesTransform");
function doubleEnclose(str) {
  const latex = parseLaTeX(str);
  const alreadyDoubleEnclosed = latex.children.length === 1 && latex.children[0]?.type === "block" && latex.children[0]?.kind === "curly" && latex.children[0].children.length === 1 && latex.children[0].children[0]?.type === "block" && latex.children[0].children[0]?.kind === "curly";
  const result = stringifyLaTeX(latex);
  return alreadyDoubleEnclosed ? result : `{${result}}`;
}
__name(doubleEnclose, "doubleEnclose");

// src/format.ts
function formatBibtex(ast) {
  const bibtex = ast.children.map((child) => formatNode(child)).join("").trimEnd();
  return `${bibtex}
`;
}
__name(formatBibtex, "formatBibtex");
function formatNode(child) {
  if (child.type === "text") {
    return `${child.whitespacePrefix}${child.text}`;
  }
  if (!child.block) throw new Error("FATAL!");
  switch (child.block.type) {
    case "preamble":
    case "string":
    case "comment":
      return `${child.whitespacePrefix}${child.block.raw}`;
    case "entry":
      return `${child.whitespacePrefix}${formatEntry(child.command, child.block)}`;
  }
}
__name(formatNode, "formatNode");
function formatEntry(entryType, entry) {
  let bibtex = `@${entryType}{`;
  if (entry.key) bibtex += `${entry.key},`;
  for (const field of entry.fields) {
    bibtex += `${field.whitespacePrefix}${field.name}`;
    const value = formatValue(field);
    if (value) {
      bibtex += `${field.value.whitespacePrefix}= ${value}`;
    }
    if (field.hasComma) bibtex += ",";
  }
  bibtex += "\n}";
  return bibtex;
}
__name(formatEntry, "formatEntry");
function formatValue(field) {
  return field.value.concat.map(({ type, value }) => {
    switch (type) {
      case "literal":
        return value;
      case "braced":
        return doubleEnclose(value);
      case "quoted":
        return `"${value}"`;
    }
  }).join(" # ");
}
__name(formatValue, "formatValue");

// src/optionDefinitions.ts
var DEFAULT_MERGE_CHECK = ["doi", "citation", "abstract"];
var DEFAULT_ALIGN = 14;
var DEFAULT_SPACE = 2;
var DEFAULT_WRAP = 80;
var DEFAULT_FIELD_SORT = [
  "title",
  "shorttitle",
  "author",
  "year",
  "month",
  "day",
  "journal",
  "booktitle",
  "location",
  "on",
  "publisher",
  "address",
  "series",
  "volume",
  "number",
  "pages",
  "doi",
  "isbn",
  "issn",
  "url",
  "urldate",
  "copyright",
  "category",
  "note",
  "metadata"
];
var DEFAULT_SORT = ["key"];
var DEFAULT_KEY_TEMPLATE = "[auth:required:lower][year:required][veryshorttitle:lower][duplicateNumber]";
var optionDefinitions = [
  {
    key: "help",
    cli: { "--help": true, "-h": true },
    title: "Help",
    description: ["Show help"],
    type: "boolean"
  },
  {
    key: "v2",
    cli: { "--v2": true },
    title: "Enable planned v2 CLI changes",
    description: [
      "Input files will no longer be modified by default. Instead, you will need to specify `--modify`/`-m` option to overwrite the file, or `--output`/`-o` to output to a different file."
    ],
    type: "string",
    defaultValue: void 0
  },
  {
    key: "outputPath",
    cli: { "--output": /* @__PURE__ */ __name((args) => args[0], "--output"), "-o": /* @__PURE__ */ __name((args) => args[0], "-o") },
    title: "Output path",
    description: [
      "Write output to specified path. When omitted (and -m/--modify is not used), the result will be printed to stdout."
    ],
    type: "string",
    defaultValue: void 0
  },
  {
    key: "modify",
    cli: { "--modify": true, "-m": true, "--no-modify": false },
    title: "Modify input files",
    description: [
      "Overwrite the original input files with the tidied result. This is enabled by default but will be disabled by default in v2. For v1, use --no-modify to output to stdout instead of overwriting the input files."
    ],
    type: "boolean",
    defaultValue: true
    // TODO: In v2, switch this to false
  },
  {
    key: "omit",
    cli: {
      "--omit": /* @__PURE__ */ __name((args) => {
        if (args.length === 0) {
          console.error("Expected a omit list");
          process.exit(1);
        }
        return args;
      }, "--omit")
    },
    toCLI: /* @__PURE__ */ __name((val) => Array.isArray(val) && val.length > 0 ? `--omit=${val.join(",")}` : void 0, "toCLI"),
    title: "Remove fields",
    description: ["Remove specified fields from bibliography entries."],
    examples: ["--omit=id,name"],
    type: "string[]",
    defaultValue: []
  },
  {
    key: "curly",
    cli: { "--curly": true, "--no-curly": false },
    toCLI: /* @__PURE__ */ __name((val) => val ? "--curly" : void 0, "toCLI"),
    title: "Enclose values in braces",
    description: [
      'Enclose all property values in braces. Quoted values will be converted to braces. For example, "Journal of Tea" will become {Journal of Tea}.'
    ],
    type: "boolean",
    defaultValue: false
  },
  {
    key: "numeric",
    cli: { "--numeric": true, "--no-numeric": false },
    toCLI: /* @__PURE__ */ __name((val) => val ? "--numeric" : void 0, "toCLI"),
    title: "Use numeric values where possible",
    description: [
      "Strip quotes and braces from numeric/month values. For example, {1998} will become 1998."
    ],
    type: "boolean",
    defaultValue: false
  },
  {
    key: "months",
    cli: { "--months": true },
    toCLI: /* @__PURE__ */ __name((val) => val ? "--months" : void 0, "toCLI"),
    title: "Abbreviate months",
    description: [
      "Convert all months to three letter abbreviations (jan, feb, etc)."
    ],
    type: "boolean",
    defaultValue: false
  },
  {
    key: "space",
    cli: {
      "--space": /* @__PURE__ */ __name((args) => args.length > 0 ? Number(args[0]) : true, "--space")
    },
    toCLI: /* @__PURE__ */ __name((val, opt) => {
      if (opt.tab) return void 0;
      if (typeof val === "number" && val !== DEFAULT_SPACE)
        return `--space=${val}`;
      if (val && val !== DEFAULT_SPACE) return "--space";
      return void 0;
    }, "toCLI"),
    title: "Indent with spaces",
    description: [
      "Indent all fields with the specified number of spaces. Ignored if tab is set."
    ],
    examples: ["--space=2 (default)", "--space=4"],
    type: "boolean | number",
    convertBoolean: { true: DEFAULT_SPACE, false: void 0 },
    defaultValue: DEFAULT_SPACE
  },
  {
    key: "tab",
    cli: { "--tab": true, "--no-tab": false },
    toCLI: /* @__PURE__ */ __name((val) => val ? "--tab" : void 0, "toCLI"),
    title: "Indent with tabs",
    description: ["Indent all fields with a tab."],
    type: "boolean",
    defaultValue: false
  },
  {
    key: "align",
    cli: {
      "--align": /* @__PURE__ */ __name((args) => Number(args[0]), "--align"),
      "--no-align": false
    },
    toCLI: /* @__PURE__ */ __name((val) => {
      if (val === false || val === 1 || val === 0) return "--no-align";
      if (typeof val === "number" && val !== DEFAULT_ALIGN)
        return `--align=${val}`;
      return void 0;
    }, "toCLI"),
    title: "Align values",
    description: [
      "Insert whitespace between fields and values so that values are visually aligned."
    ],
    examples: ["--align=14 (default)"],
    type: "boolean | number",
    convertBoolean: { true: DEFAULT_ALIGN, false: 1 },
    defaultValue: DEFAULT_ALIGN
  },
  {
    key: "blankLines",
    cli: { "--blank-lines": true, "--no-blank-lines": false },
    toCLI: /* @__PURE__ */ __name((val) => val ? "--blank-lines" : void 0, "toCLI"),
    title: "Insert blank lines",
    description: ["Insert an empty line between each entry."],
    type: "boolean"
  },
  {
    key: "sort",
    cli: {
      "--sort": /* @__PURE__ */ __name((args) => args.length > 0 ? args : true, "--sort"),
      "--no-sort": false
    },
    toCLI: /* @__PURE__ */ __name((val) => {
      if (Array.isArray(val) && val.length > 0)
        return `--sort=${val.join(",")}`;
      if (val === true) return "--sort";
      return void 0;
    }, "toCLI"),
    title: "Sort bibliography entries",
    description: [
      "Sort entries by the specified field names (citation key is used if no fields are specified). For descending order, prefix the field with a dash (-).",
      "Multiple fields may be specified to sort everything by first field, then by the second field whenever the first field for entries are equal, etc.",
      "The following additional fields are also permitted: key (entry citation key), type (sorts by the type of entry, e.g. article), and special (ensures that @string, @preamble, @set, and @xdata entries are first). "
    ],
    examples: [
      "--sort (sort by citation key)",
      "--sort=-year,name (sort year descending then name ascending)",
      "--sort=name,year"
    ],
    type: "boolean | string[]",
    convertBoolean: { true: DEFAULT_SORT, false: void 0 }
  },
  {
    key: "duplicates",
    cli: {
      "--duplicates": /* @__PURE__ */ __name((args) => {
        if (args.length === 0) return true;
        for (const i of args) {
          if (i !== "doi" && i !== "key" && i !== "abstract" && i !== "citation") {
            console.error(`Invalid key for merge option: "${i}"`);
            process.exit(1);
          }
        }
        return args;
      }, "--duplicates")
    },
    toCLI: /* @__PURE__ */ __name((val) => {
      if (Array.isArray(val) && val.length > 0)
        return `--duplicates=${val.join(",")}`;
      if (val === true) return "--duplicates";
      return void 0;
    }, "toCLI"),
    title: "Check for duplicates",
    description: [
      "Warn if duplicates are found, which are entries where DOI, abstract, or author and title are the same."
    ],
    examples: [
      "--duplicates doi (same DOIs)",
      "--duplicates key (same IDs)",
      "--duplicates abstract (similar abstracts)",
      "--duplicates citation (similar author and titles)",
      "--duplicates doi, key (identical DOI or keys)",
      "--duplicates (same DOI, key, abstract, or citation)"
    ],
    type: "boolean | ('doi' | 'key' | 'abstract' | 'citation')[]",
    convertBoolean: { true: DEFAULT_MERGE_CHECK, false: void 0 },
    defaultValue: /* @__PURE__ */ __name((options) => options.merge ? DEFAULT_MERGE_CHECK : void 0, "defaultValue")
  },
  {
    key: "merge",
    cli: {
      "--merge": /* @__PURE__ */ __name((args) => {
        if (args.length === 0) return true;
        if (args[0] !== "first" && args[0] !== "last" && args[0] !== "combine" && args[0] !== "overwrite") {
          console.error(`Invalid merge strategy: "${args[0]}"`);
          process.exit(1);
        }
        return args[0];
      }, "--merge"),
      "--no-merge": false
    },
    toCLI: /* @__PURE__ */ __name((val) => {
      if (typeof val === "string") return `--merge=${val}`;
      if (val) return "--merge";
      return void 0;
    }, "toCLI"),
    title: "Merge duplicate entries",
    description: [
      "Merge duplicates entries. Use the duplicates option to determine how duplicates are identified. There are different ways to merge:",
      "- first: only keep the original entry",
      "- last: only keep the last found duplicate",
      "- combine: keep original entry and merge in fields of duplicates if they do not already exist",
      "- overwrite: keep original entry and merge in fields of duplicates, overwriting existing fields if they exist"
    ],
    type: "boolean | 'first' | 'last' | 'combine' | 'overwrite'",
    convertBoolean: { true: "combine", false: void 0 }
  },
  {
    key: "stripEnclosingBraces",
    cli: { "--strip-enclosing-braces": true },
    toCLI: /* @__PURE__ */ __name((val) => val ? "--strip-enclosing-braces" : void 0, "toCLI"),
    title: "Strip double-braced values",
    description: [
      "Where an entire value is enclosed in double braces, remove the extra braces. For example, {{Journal of Tea}} will become {Journal of Tea}."
    ],
    type: "boolean",
    defaultValue: false
  },
  {
    key: "dropAllCaps",
    cli: { "--drop-all-caps": true },
    toCLI: /* @__PURE__ */ __name((val) => val ? "--drop-all-caps" : void 0, "toCLI"),
    title: "Drop all caps",
    description: [
      "Where values are all caps, make them title case. For example, {JOURNAL OF TEA} will become {Journal of Tea}. Roman numerals will be left unchanged."
    ],
    type: "boolean",
    defaultValue: false
  },
  {
    key: "escape",
    cli: { "--escape": true, "--no-escape": false },
    toCLI: /* @__PURE__ */ __name((val) => val === false ? "--no-escape" : void 0, "toCLI"),
    title: "Escape special characters",
    description: [
      "Escape special characters, such as umlaut. This ensures correct typesetting with latex. Enabled by default."
    ],
    type: "boolean",
    defaultValue: true
  },
  {
    key: "sortFields",
    cli: { "--sort-fields": /* @__PURE__ */ __name((args) => args.length > 0 ? args : true, "--sort-fields") },
    toCLI: /* @__PURE__ */ __name((val) => {
      if (Array.isArray(val) && val.length > 0) {
        if (JSON.stringify(val) === JSON.stringify(DEFAULT_FIELD_SORT)) {
          return "--sort-fields";
        }
        return `--sort-fields=${val.join(",")}`;
      }
      if (val === true) return "--sort-fields";
      return void 0;
    }, "toCLI"),
    title: "Sort fields",
    description: [
      "Sort the fields within entries.",
      "If no fields are specified fields will be sorted by: title, shorttitle, author, year, month, day, journal, booktitle, location, on, publisher, address, series, volume, number, pages, doi, isbn, issn, url, urldate, copyright, category, note, metadata"
    ],
    examples: ["--sort-fields=name,author"],
    type: "boolean | string[]",
    convertBoolean: { true: DEFAULT_FIELD_SORT, false: void 0 },
    defaultValue: void 0
  },
  {
    key: "sortProperties",
    cli: { "--sort-properties": /* @__PURE__ */ __name((args) => args.length > 0 ? args : true, "--sort-properties") },
    title: "Sort properties",
    description: ["Alias of sort fields (legacy)"],
    type: "boolean | string[]",
    deprecated: true
  },
  {
    key: "stripComments",
    cli: { "--strip-comments": true, "--no-strip-comments": false },
    toCLI: /* @__PURE__ */ __name((val) => val ? "--strip-comments" : void 0, "toCLI"),
    title: "Remove comments",
    description: ["Remove all comments from the bibtex source."],
    type: "boolean",
    defaultValue: false
  },
  {
    key: "trailingCommas",
    cli: { "--trailing-commas": true, "--no-trailing-commas": true },
    toCLI: /* @__PURE__ */ __name((val) => val ? "--trailing-commas" : void 0, "toCLI"),
    title: "Trailing commas",
    description: ["End the last key value pair in each entry with a comma."],
    type: "boolean",
    defaultValue: false
  },
  {
    key: "encodeUrls",
    cli: { "--encode-urls": true, "--no-encode-urls": true },
    toCLI: /* @__PURE__ */ __name((val) => val ? "--encode-urls" : void 0, "toCLI"),
    title: "Encode URLs",
    description: [
      "Replace invalid URL characters with percent encoded values."
    ],
    type: "boolean",
    defaultValue: false
  },
  {
    key: "tidyComments",
    cli: { "--tidy-comments": true, "--no-tidy-comments": false },
    toCLI: /* @__PURE__ */ __name((val) => val === false ? "--no-tidy-comments" : void 0, "toCLI"),
    title: "Tidy comments",
    description: ["Remove whitespace surrounding comments."],
    type: "boolean",
    defaultValue: true
  },
  {
    key: "removeEmptyFields",
    cli: { "--remove-empty-fields": true, "--no-remove-empty-fields": false },
    toCLI: /* @__PURE__ */ __name((val) => val ? "--remove-empty-fields" : void 0, "toCLI"),
    title: "Remove empty fields",
    description: ["Remove any fields that have empty values."],
    type: "boolean",
    defaultValue: false
  },
  {
    key: "removeDuplicateFields",
    cli: {
      "--remove-dupe-fields": true,
      "--no-remove-dupe-fields": false
    },
    toCLI: /* @__PURE__ */ __name((val) => val === false ? "--no-remove-dupe-fields" : void 0, "toCLI"),
    title: "Remove duplicate fields",
    description: [
      "Only allow one of each field in each entry. Enabled by default."
    ],
    type: "boolean",
    defaultValue: true
  },
  {
    key: "generateKeys",
    cli: { "--generate-keys": /* @__PURE__ */ __name((args) => args.length > 0 ? args : true, "--generate-keys") },
    toCLI: /* @__PURE__ */ __name((val) => {
      if (val === true || val === DEFAULT_KEY_TEMPLATE)
        return "--generate-keys";
      if (typeof val === "string")
        return `--generate-keys="${val.replace(/"/g, '\\"')}"`;
      return void 0;
    }, "toCLI"),
    title: "Generate citation keys [Experimental]",
    description: [
      "For all entries replace the key with a new key of the form <author><year><title>. A JabRef citation pattern can be provided. This is an experimental option that may change without warning."
    ],
    type: "boolean | string",
    convertBoolean: {
      true: DEFAULT_KEY_TEMPLATE,
      false: void 0
    },
    defaultValue: void 0
  },
  {
    key: "maxAuthors",
    cli: { "--max-authors": /* @__PURE__ */ __name((args) => Number(args[0]), "--max-authors") },
    toCLI: /* @__PURE__ */ __name((val) => val ? `--max-authors=${val}` : void 0, "toCLI"),
    title: "Maximum authors",
    description: [
      'Truncate authors if above a given number into "and others".'
    ],
    type: "number"
  },
  {
    key: "lowercase",
    cli: { "--no-lowercase": false },
    toCLI: /* @__PURE__ */ __name((val) => val === false ? "--no-lowercase" : void 0, "toCLI"),
    title: "Lowercase fields",
    description: ["Lowercase field names and entry type. Enabled by default."],
    type: "boolean",
    defaultValue: true
  },
  {
    key: "enclosingBraces",
    cli: {
      "--enclosing-braces": /* @__PURE__ */ __name((args) => args.length > 0 ? args : true, "--enclosing-braces")
    },
    toCLI: /* @__PURE__ */ __name((val) => {
      if (Array.isArray(val) && val.length > 0)
        return `--enclosing-braces=${val.join(",")}`;
      if (val === true) return "--enclosing-braces";
      return void 0;
    }, "toCLI"),
    title: "Enclose values in double braces",
    description: [
      "Enclose the given fields in double braces, such that case is preserved during BibTeX compilation."
    ],
    examples: [
      "--enclosing-braces=title,journal (output title and journal fields will be of the form {{This is a title}})",
      "--enclosing-braces (equivalent to ---enclosing-braces=title)"
    ],
    type: "boolean | string[]",
    convertBoolean: { true: ["title"], false: void 0 }
  },
  {
    key: "removeBraces",
    cli: {
      "--remove-braces": /* @__PURE__ */ __name((args) => args.length > 0 ? args : true, "--remove-braces")
    },
    toCLI: /* @__PURE__ */ __name((val) => {
      if (Array.isArray(val) && val.length > 0)
        return `--remove-braces=${val.join(",")}`;
      if (val === true) return "--remove-braces";
      return void 0;
    }, "toCLI"),
    title: "Remove braces",
    description: [
      "Remove any curly braces within the value, unless they are part of a command."
    ],
    examples: [
      "--remove-braces=title,journal",
      "--remove-braces (equivalent to ---remove-braces=title)"
    ],
    type: "boolean | string[]",
    convertBoolean: { true: ["title"], false: void 0 }
  },
  {
    key: "wrap",
    cli: {
      "--wrap": /* @__PURE__ */ __name((args) => args.length > 0 ? Number(args[0]) : true, "--wrap"),
      "--no-wrap": false
    },
    toCLI: /* @__PURE__ */ __name((val) => val ? `--wrap=${val}` : void 0, "toCLI"),
    title: "Wrap values",
    description: ["Wrap long values at the given column"],
    examples: ["--wrap (80 by default)", "--wrap=82"],
    type: "boolean | number",
    convertBoolean: { true: DEFAULT_WRAP, false: void 0 }
  },
  {
    key: "version",
    cli: { "--version": true, "-v": true },
    title: "Version",
    description: ["Show bibtex-tidy version."],
    type: "boolean"
  },
  {
    key: "quiet",
    cli: { "--quiet": true },
    title: "Quiet",
    description: ["Suppress logs on stdout."],
    type: "boolean"
  },
  {
    key: "backup",
    cli: { "--backup": true, "--no-backup": false },
    title: "Backup",
    description: [
      "Make a backup <filename>.original. Enabled by default (unless --modify is explicitly provided or outputting to a different file/stdio). Deprecated but provided for backward compatibility."
    ],
    type: "boolean",
    defaultValue: true,
    deprecated: true
  }
];

// src/optionUtils.ts
function normalizeOptions(options) {
  return Object.fromEntries(
    optionDefinitions.map((def) => {
      const key = def.key;
      const value = options[key];
      if (def.convertBoolean && typeof value === "boolean") {
        return [
          key,
          value ? def.convertBoolean.true : def.convertBoolean.false
        ];
      }
      if (typeof value === "undefined" && def.defaultValue !== void 0) {
        if (typeof def.defaultValue === "function") {
          return [key, def.defaultValue(options)];
        }
        return [key, def.defaultValue];
      }
      return [key, value];
    })
  );
}
__name(normalizeOptions, "normalizeOptions");

// src/ASTProxy.ts
var ASTProxy = class {
  constructor(ast) {
    this.ast = ast;
    this.fieldLookup = /* @__PURE__ */ new Map();
    this.renderValueLookup = /* @__PURE__ */ new Map();
  }
  static {
    __name(this, "ASTProxy");
  }
  root() {
    return this.ast;
  }
  fields() {
    return this.entries().flatMap((entry) => entry.fields);
  }
  entries() {
    return this.ast.children.filter((node) => node.type === "block").map((block) => block.block).filter((entry) => entry?.type === "entry");
  }
  invalidateField(field) {
    this.renderValueLookup.delete(field);
  }
  lookupField(entry, fieldLc) {
    let fieldNode = this.fieldLookup.get(entry)?.get(fieldLc);
    if (fieldNode === void 0) {
      fieldNode = entry.fields.find(
        (field) => field.name.toLocaleLowerCase() === fieldLc
      );
    }
    return fieldNode;
  }
  lookupRenderedEntryValue(node, fieldName) {
    const field = node.type === "entry" ? this.lookupField(node, (fieldName ?? "").toLocaleLowerCase()) : node;
    if (!field) {
      return "";
    }
    let value = this.renderValueLookup.get(field);
    if (value === void 0) {
      const entryValue = formatValue(field) ?? "";
      value = parseLaTeX(entryValue).renderAsText();
      this.renderValueLookup.set(field, value);
    }
    return value;
  }
  lookupRenderedEntryValues(entry) {
    const values = /* @__PURE__ */ new Map();
    for (const field of entry.fields) {
      values.set(field.name, this.lookupRenderedEntryValue(field));
    }
    return values;
  }
};

// src/debug.ts
function logAST(node, depth = 0) {
  const indent = "  ".repeat(depth);
  let log = `
${indent}${node.type} ws="${"whitespacePrefix" in node ? node.whitespacePrefix.replace(/\n/g, "\\n") : ""}"`;
  switch (node.type) {
    case "root":
      for (const child of node.children) {
        log += logAST(child, depth + 1);
      }
      break;
    case "block":
      log += ` command="${node.command}"`;
      if (node.block) {
        log += logAST(node.block, depth + 1);
      }
      break;
    case "concat":
      for (const value of node.concat) {
        log += logAST(value, depth + 1);
      }
      break;
    case "entry":
      log += ` key="${node.key}"`;
      for (const field of node.fields) {
        log += logAST(field, depth + 1);
      }
      break;
    case "field":
      log += ` name="${node.name}"`;
      log += logAST(node.value, depth + 1);
      break;
    case "text":
      log += ` text="${node.text.replace(/\n/g, "\\n")}"`;
      break;
    case "braced":
    case "quoted":
    case "comment":
    case "preamble":
    case "string":
    case "literal":
      break;
  }
  return log;
}
__name(logAST, "logAST");

// src/parsers/bibtexParser.ts
var RootNode = class {
  constructor(children = []) {
    this.children = children;
    this.type = "root";
  }
  static {
    __name(this, "RootNode");
  }
};
var TextNode2 = class {
  constructor(parent, text, whitespacePrefix) {
    this.parent = parent;
    this.text = text;
    this.whitespacePrefix = whitespacePrefix;
    this.type = "text";
    parent.children.push(this);
  }
  static {
    __name(this, "TextNode");
  }
};
var BlockNode2 = class {
  constructor(parent, whitespacePrefix) {
    this.parent = parent;
    this.whitespacePrefix = whitespacePrefix;
    this.type = "block";
    this.command = "";
    parent.children.push(this);
  }
  static {
    __name(this, "BlockNode");
  }
};
var CommentNode = class {
  constructor(parent, raw, braces, parens) {
    this.parent = parent;
    this.raw = raw;
    this.braces = braces;
    this.parens = parens;
    this.type = "comment";
    parent.block = this;
  }
  static {
    __name(this, "CommentNode");
  }
};
var PreambleNode = class {
  constructor(parent, raw, braces, parens) {
    this.parent = parent;
    this.raw = raw;
    this.braces = braces;
    this.parens = parens;
    this.type = "preamble";
    parent.block = this;
  }
  static {
    __name(this, "PreambleNode");
  }
};
var StringNode = class {
  constructor(parent, raw, braces, parens) {
    this.parent = parent;
    this.raw = raw;
    this.braces = braces;
    this.parens = parens;
    this.type = "string";
    parent.block = this;
  }
  static {
    __name(this, "StringNode");
  }
};
var EntryNode = class {
  constructor(parent, wrapType) {
    this.parent = parent;
    this.wrapType = wrapType;
    this.type = "entry";
    parent.block = this;
    this.fields = [];
  }
  static {
    __name(this, "EntryNode");
  }
};
var FieldNode = class {
  // not filled in during parsing
  constructor(parent, name = "", whitespacePrefix = "") {
    this.parent = parent;
    this.name = name;
    this.whitespacePrefix = whitespacePrefix;
    this.type = "field";
    this.hasComma = false;
    this.value = new ConcatNode(this);
  }
  static {
    __name(this, "FieldNode");
  }
};
var ConcatNode = class {
  // not filled in during parsing
  constructor(parent) {
    this.parent = parent;
    this.type = "concat";
    this.canConsumeValue = true;
    this.whitespacePrefix = "";
    this.concat = [];
  }
  static {
    __name(this, "ConcatNode");
  }
};
var LiteralNode = class {
  constructor(parent, value) {
    this.parent = parent;
    this.value = value;
    this.type = "literal";
  }
  static {
    __name(this, "LiteralNode");
  }
};
function createLiteralNode(parent, value) {
  const node = new LiteralNode(parent, value);
  parent.concat.push(node);
  return node;
}
__name(createLiteralNode, "createLiteralNode");
var BracedNode = class {
  constructor(parent) {
    this.parent = parent;
    this.type = "braced";
    this.value = "";
    /** Used to count opening and closing braces */
    this.depth = 0;
  }
  static {
    __name(this, "BracedNode");
  }
};
function createBracedNode(parent) {
  const node = new BracedNode(parent);
  parent.concat.push(node);
  return node;
}
__name(createBracedNode, "createBracedNode");
var QuotedNode = class {
  constructor(parent) {
    this.parent = parent;
    this.type = "quoted";
    this.value = "";
    /** Used to count opening and closing braces */
    this.depth = 0;
  }
  static {
    __name(this, "QuotedNode");
  }
};
function createQuotedNode(parent) {
  const node = new QuotedNode(parent);
  parent.concat.push(node);
  return node;
}
__name(createQuotedNode, "createQuotedNode");
function parseBibTeX(input) {
  const rootNode = new RootNode();
  let node = rootNode;
  let line = 1;
  let column = 0;
  let whitespace = "";
  const flushWhitespace = /* @__PURE__ */ __name(() => {
    const ws = whitespace;
    whitespace = "";
    return ws;
  }, "flushWhitespace");
  for (let i = 0; i < input.length; i++) {
    const char = input[i] ?? "";
    const prev = input[i - 1] ?? "";
    if (char === "\n") {
      line++;
      column = 0;
    }
    column++;
    switch (node.type) {
      case "root": {
        if (char === "@") {
          node = new BlockNode2(node, flushWhitespace());
        } else if (isWhitespace(char)) {
          whitespace += char;
        } else {
          node = new TextNode2(node, char, flushWhitespace());
        }
        break;
      }
      case "text": {
        if (char === "@" && /[\s\r\n}]/.test(prev)) {
          node = new BlockNode2(node.parent, "");
        } else {
          node.text += char;
        }
        break;
      }
      case "block": {
        if (char === "@") {
          const prevNode = node.parent.children[node.parent.children.length - 2];
          if (prevNode?.type === "text") {
            prevNode.text += `@${node.command}`;
          } else {
            node.parent.children.pop();
            new TextNode2(
              node.parent,
              `@${node.command}`,
              node.whitespacePrefix
            );
            node.parent.children.push(node);
          }
          node.command = "";
        } else if (char === "{" || char === "(") {
          const commandTrimmed = node.command.trim();
          if (commandTrimmed === "" || /\s/.test(commandTrimmed)) {
            node.parent.children.pop();
            node = new TextNode2(
              node.parent,
              `@${node.command}${char}`,
              node.whitespacePrefix
            );
          } else {
            node.command = commandTrimmed;
            const command = node.command.toLowerCase();
            const [braces, parens] = char === "{" ? [1, 0] : [0, 1];
            const raw = `@${command}${char}`;
            switch (command) {
              case "string":
                node = new StringNode(node, raw, braces, parens);
                break;
              case "preamble":
                node = new PreambleNode(node, raw, braces, parens);
                break;
              case "comment":
                node = new CommentNode(node, raw, braces, parens);
                break;
              default:
                node = new EntryNode(node, char);
                break;
            }
          }
        } else if (char.match(/[=#,})[\]]/)) {
          node.parent.children.pop();
          node = new TextNode2(
            node.parent,
            `@${node.command}${char}`,
            flushWhitespace()
          );
        } else {
          node.command += char;
        }
        break;
      }
      case "comment":
      case "string":
      case "preamble":
        if (char === "{") {
          node.braces++;
        } else if (char === "}") {
          node.braces--;
        } else if (char === "(") {
          node.parens++;
        } else if (char === ")") {
          node.parens--;
        }
        node.raw += char;
        if (node.braces === 0 && node.parens === 0) {
          node = node.parent.parent;
        }
        break;
      case "entry": {
        if (isWhitespace(char)) {
          if (!node.key) {
          } else {
            node.keyEnded = true;
          }
        } else if (char === ",") {
          node = new FieldNode(node);
        } else if (node.wrapType === "{" && char === "}" || node.wrapType === "(" && char === ")") {
          node = node.parent.parent;
        } else if (char === "=" && node.key && isValidFieldName(node.key)) {
          const field = new FieldNode(node, node.key);
          node.fields.push(field);
          node.key = void 0;
          node = field.value;
        } else if (node.keyEnded) {
          throw new BibTeXSyntaxError(
            input,
            node,
            i,
            line,
            column,
            "The entry key cannot contain whitespace"
          );
        } else if (!isValidKeyCharacter(char)) {
          throw new BibTeXSyntaxError(
            input,
            node,
            i,
            line,
            column,
            `The entry key cannot contain the character (${char})`
          );
        } else {
          node.key = (node.key ?? "") + char;
        }
        break;
      }
      case "field": {
        if (char === "}" || char === ")") {
          node.name = node.name.trim();
          node = node.parent.parent.parent;
        } else if (char === "=") {
          node.name = node.name.trim();
          node = node.value;
        } else if (char === ",") {
          node.name = node.name.trim();
          node = new FieldNode(node.parent);
        } else if (!isValidFieldName(char)) {
          throw new BibTeXSyntaxError(input, node, i, line, column);
        } else if (!node.name) {
          if (!isWhitespace(char)) {
            node.parent.fields.push(node);
            node.name = char;
          } else {
            node.whitespacePrefix += char;
          }
        } else {
          node.name += char;
        }
        break;
      }
      case "concat": {
        if (isWhitespace(char)) {
          break;
        }
        if (node.canConsumeValue) {
          if (/[#=,}()[\]]/.test(char)) {
            throw new BibTeXSyntaxError(input, node, i, line, column);
          }
          node.canConsumeValue = false;
          if (char === "{") {
            node = createBracedNode(node);
          } else if (char === '"') {
            node = createQuotedNode(node);
          } else {
            node = createLiteralNode(node, char);
          }
        } else {
          if (char === ",") {
            node = new FieldNode(node.parent.parent);
          } else if (char === "}" || char === ")") {
            node = node.parent.parent.parent.parent;
          } else if (char === "#") {
            node.canConsumeValue = true;
          } else {
            throw new BibTeXSyntaxError(input, node, i, line, column);
          }
        }
        break;
      }
      case "literal":
        if (isWhitespace(char)) {
          node = node.parent;
        } else if (char === ",") {
          node = new FieldNode(node.parent.parent.parent);
        } else if (char === "}") {
          node = node.parent.parent.parent.parent.parent;
        } else if (char === "#") {
          node = node.parent;
          node.canConsumeValue = true;
        } else {
          node.value += char;
        }
        break;
      // Values may be enclosed in curly braces. Curly braces may be used within
      // the value but they must be balanced.
      case "braced":
        if (char === "}" && node.depth === 0) {
          node = node.parent;
          break;
        }
        if (char === "{") {
          node.depth++;
        } else if (char === "}") {
          node.depth--;
        }
        node.value += char;
        break;
      // Values may be enclosed in double quotes. Curly braces may be used
      // within quoted values but they must be balanced.
      //
      // To escape a double quote, surround it with braces `{"}`.
      // https://web.archive.org/web/20210422110817/https://maverick.inria.fr/~Xavier.Decoret/resources/xdkbibtex/bibtex_summary.html
      case "quoted":
        if (char === '"' && node.depth === 0) {
          node = node.parent;
          break;
        }
        if (char === "{") {
          node.depth++;
        } else if (char === "}") {
          node.depth--;
          if (node.depth < 0) {
            throw new BibTeXSyntaxError(input, node, i, line, column);
          }
        }
        node.value += char;
        break;
    }
  }
  return rootNode;
}
__name(parseBibTeX, "parseBibTeX");
function isWhitespace(string) {
  return /^\s*$/.test(string);
}
__name(isWhitespace, "isWhitespace");
function isValidKeyCharacter(char) {
  return !/[#%{}~$,]/.test(char);
}
__name(isValidKeyCharacter, "isValidKeyCharacter");
function isValidFieldName(char) {
  return !/[=,{}()[\]]/.test(char);
}
__name(isValidFieldName, "isValidFieldName");
var BibTeXSyntaxError = class extends Error {
  constructor(input, node, pos, line, column, hint) {
    super(
      `Line ${line}:${column}: Syntax Error in ${node.type} (${hint})
${input.slice(Math.max(0, pos - 20), pos)}>>${input[pos]}<<${input.slice(pos + 1, pos + 20)}`
    );
    this.node = node;
    this.line = line;
    this.column = column;
    this.hint = hint;
    this.name = "Syntax Error";
    this.char = input[pos] ?? "";
  }
  static {
    __name(this, "BibTeXSyntaxError");
  }
};

// src/transforms/abbreviateMonths.ts
var monthAliases = {
  jan: ["1", "jan", "january"],
  feb: ["2", "feb", "february"],
  mar: ["3", "mar", "march"],
  apr: ["4", "apr", "may"],
  may: ["5", "may", "april"],
  jun: ["6", "jun", "june"],
  jul: ["7", "jul", "july"],
  aug: ["8", "aug", "august"],
  sep: ["9", "sep", "september"],
  oct: ["10", "oct", "october"],
  nov: ["11", "nov", "november"],
  dec: ["12", "dec", "december"]
};
function createAbbreviateMonthsTransform() {
  const months = new Map(
    Object.entries(monthAliases).flatMap(
      ([abbr, aliases]) => aliases.map((alias) => [alias, abbr])
    )
  );
  return {
    name: "abbreviate-months",
    apply: /* @__PURE__ */ __name((astProxy) => {
      for (const field of astProxy.fields()) {
        if (field.name.toLowerCase() === "month") {
          abbreviateMonthInField(astProxy, field, months);
        }
      }
      return void 0;
    }, "apply")
  };
}
__name(createAbbreviateMonthsTransform, "createAbbreviateMonthsTransform");
function abbreviateMonthInField(astProxy, field, months) {
  field.value.concat = field.value.concat.map((node) => {
    const abbr = abbreviateMonth(node.value, months);
    return abbr ? new LiteralNode(node.parent, abbr) : node;
  });
  astProxy.invalidateField(field);
}
__name(abbreviateMonthInField, "abbreviateMonthInField");
function abbreviateMonth(month, months) {
  return months.get(month.toLowerCase());
}
__name(abbreviateMonth, "abbreviateMonth");

// src/transforms/alignValues.ts
function createAlignValuesTransform(column) {
  return {
    name: "align-values",
    apply: /* @__PURE__ */ __name((astProxy) => {
      const fields = astProxy.fields();
      for (const field of fields) {
        const gap = Math.max(column - field.name.length, 1);
        field.value.whitespacePrefix = " ".repeat(gap);
      }
      return void 0;
    }, "apply")
  };
}
__name(createAlignValuesTransform, "createAlignValuesTransform");

// src/transforms/blankLines.ts
function createBlankLinesTransform() {
  return {
    name: "blank-lines",
    apply: /* @__PURE__ */ __name((astProxy) => {
      const children = astProxy.root().children;
      let prev;
      for (const child of children) {
        if (prev && !isComment(prev)) {
          child.whitespacePrefix = "\n\n";
        }
        prev = child;
      }
      return void 0;
    }, "apply")
  };
}
__name(createBlankLinesTransform, "createBlankLinesTransform");
function isComment(node) {
  return node.type === "text" || node.block?.type === "comment";
}
__name(isComment, "isComment");

// src/transforms/dropAllCaps.ts
function createDropAllCapsTransform() {
  return {
    name: "drop-all-caps",
    apply: /* @__PURE__ */ __name((astProxy) => {
      for (const field of astProxy.fields()) {
        dropAllCapsInField(astProxy, field);
      }
      return void 0;
    }, "apply")
  };
}
__name(createDropAllCapsTransform, "createDropAllCapsTransform");
function dropAllCapsInField(astProxy, field) {
  if (!astProxy.lookupRenderedEntryValue(field).match(/[a-z]/)) {
    console.log(astProxy.lookupRenderedEntryValue(field));
    for (const node of field.value.concat) {
      node.value = titleCase(node.value);
    }
    astProxy.invalidateField(field);
  }
}
__name(dropAllCapsInField, "dropAllCapsInField");
function titleCase(str) {
  return str.replace(/(\w)(\S*)/g, (_, first, rest) => {
    const word = first + rest;
    if (isRomanNumeral(word)) return word;
    return first.toLocaleUpperCase() + rest.toLocaleLowerCase();
  });
}
__name(titleCase, "titleCase");
function isRomanNumeral(str) {
  return /^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$/.test(str);
}
__name(isRomanNumeral, "isRomanNumeral");

// src/transforms/encodeUrls.ts
function createEncodeUrlsTransform() {
  return {
    name: "encode-urls",
    apply: /* @__PURE__ */ __name((ast) => {
      for (const field of ast.fields()) {
        if (field.name.toLocaleLowerCase() === "url") {
          for (const entry of field.value.concat) {
            entry.value = encodeUrl(entry.value);
          }
          ast.invalidateField(field);
        }
      }
      return void 0;
    }, "apply")
  };
}
__name(createEncodeUrlsTransform, "createEncodeUrlsTransform");
function encodeUrl(url) {
  return url.replace(/\\?_/g, "\\%5F");
}
__name(encodeUrl, "encodeUrl");

// src/unicode.ts
var specialCharacters = /* @__PURE__ */ new Map([
  ["0023", "\\#"],
  ["0024", "\\$"],
  ["0025", "\\%"],
  ["0026", "\\&"],
  ["0027", "'"],
  ["0040", "\\@"],
  ["002a", "\\textasteriskcentered"],
  ["005f", "\\_"],
  ["007c", "\\vert{}"],
  ["00a0", "~"],
  ["00a1", "\\textexclamdown{}"],
  ["00a2", "\\textcent{}"],
  ["00a3", "\\textsterling{}"],
  ["00a4", "\\textcurrency{}"],
  ["00a5", "\\textyen{}"],
  ["00a6", "\\textbrokenbar{}"],
  ["00a7", "\\textsection{}"],
  ["00a8", "\\textasciidieresis{}"],
  ["00a9", "\\textcopyright{}"],
  ["00aa", "\\textordfeminine{}"],
  ["00ab", "\\guillemotleft{}"],
  ["00ac", "\\lnot{}"],
  ["00ad", "\\-"],
  ["00ae", "\\textregistered{}"],
  ["00af", "\\textasciimacron{}"],
  ["00b0", "\\textdegree{}"],
  ["00b1", "\\pm{}"],
  ["00b2", "\\ensuremath{^2}"],
  ["00b3", "\\ensuremath{^3}"],
  ["00b4", "\\textasciiacute{}"],
  ["00b5", "\\mathrm{\\mu}"],
  ["00b6", "\\textparagraph{}"],
  ["00b7", "\\cdot{}"],
  ["00b8", "\\c{}"],
  ["00b9", "\\ensuremath{^1}"],
  ["00ba", "\\textordmasculine{}"],
  ["00bb", "\\guillemotright{}"],
  ["00bc", "\\textonequarter{}"],
  ["00bd", "\\textonehalf{}"],
  ["00be", "\\textthreequarters{}"],
  ["00bf", "\\textquestiondown{}"],
  ["00c0", "\\`{A}"],
  ["00c1", "\\'{A}"],
  ["00c2", "\\^{A}"],
  ["00c3", "\\~{A}"],
  ["00c4", '\\"{A}'],
  ["00c5", "\\AA{}"],
  ["00c6", "\\AE{}"],
  ["00c7", "\\c{C}"],
  ["00c8", "\\`{E}"],
  ["00c9", "\\'{E}"],
  ["00ca", "\\^{E}"],
  ["00cb", '\\"{E}'],
  ["00cc", "\\`{I}"],
  ["00cd", "\\'{I}"],
  ["00ce", "\\^{I}"],
  ["00cf", '\\"{I}'],
  ["00d0", "\\DH{}"],
  ["00d1", "\\~{N}"],
  ["00d2", "\\`{O}"],
  ["00d3", "\\'{O}"],
  ["00d4", "\\^{O}"],
  ["00d5", "\\~{O}"],
  ["00d6", '\\"{O}'],
  ["00d7", "\\texttimes{}"],
  ["00d8", "\\O{}"],
  ["00d9", "\\`{U}"],
  ["00da", "\\'{U}"],
  ["00db", "\\^{U}"],
  ["00dc", '\\"{U}'],
  ["00dd", "\\'{Y}"],
  ["00de", "\\TH{}"],
  ["00df", "\\ss{}"],
  ["00e0", "\\`{a}"],
  ["00e1", "\\'{a}"],
  ["00e2", "\\^{a}"],
  ["00e3", "\\~{a}"],
  ["00e4", '\\"{a}'],
  ["00e5", "\\aa{}"],
  ["00e6", "\\ae{}"],
  ["00e7", "\\c{c}"],
  ["00e8", "\\`{e}"],
  ["00e9", "\\'{e}"],
  ["00ea", "\\^{e}"],
  ["00eb", '\\"{e}'],
  ["00ec", "\\`{\\i}"],
  ["00ed", "\\'{\\i}"],
  ["00ee", "\\^{\\i}"],
  ["00ef", '\\"{\\i}'],
  ["00f0", "\\dh{}"],
  ["00f1", "\\~{n}"],
  ["00f2", "\\`{o}"],
  ["00f3", "\\'{o}"],
  ["00f4", "\\^{o}"],
  ["00f5", "\\~{o}"],
  ["00f6", '\\"{o}'],
  ["00f7", "\\div{}"],
  ["00f8", "\\o{}"],
  ["00f9", "\\`{u}"],
  ["00fa", "\\'{u}"],
  ["00fb", "\\^{u}"],
  ["00fc", '\\"{u}'],
  ["00fd", "\\'{y}"],
  ["00fe", "\\th{}"],
  ["00ff", '\\"{y}'],
  ["0100", "\\={A}"],
  ["0101", "\\={a}"],
  ["0102", "\\u{A}"],
  ["0103", "\\u{a}"],
  ["0104", "\\k{A}"],
  ["0105", "\\k{a}"],
  ["0106", "\\'{C}"],
  ["0107", "\\'{c}"],
  ["0108", "\\^{C}"],
  ["0109", "\\^{c}"],
  ["010a", "\\.{C}"],
  ["010b", "\\.{c}"],
  ["010c", "\\v{C}"],
  ["010d", "\\v{c}"],
  ["010e", "\\v{D}"],
  ["010f", "\\v{d}"],
  ["0110", "\\DJ{}"],
  ["0111", "\\dj{}"],
  ["0112", "\\={E}"],
  ["0113", "\\={e}"],
  ["0114", "\\u{E}"],
  ["0115", "\\u{e}"],
  ["0116", "\\.{E}"],
  ["0117", "\\.{e}"],
  ["0118", "\\k{E}"],
  ["0119", "\\k{e}"],
  ["011a", "\\v{E}"],
  ["011b", "\\v{e}"],
  ["011c", "\\^{G}"],
  ["011d", "\\^{g}"],
  ["011e", "\\u{G}"],
  ["011f", "\\u{g}"],
  ["0120", "\\.{G}"],
  ["0121", "\\.{g}"],
  ["0122", "\\c{G}"],
  ["0123", "\\c{g}"],
  ["0124", "\\^{H}"],
  ["0125", "\\^{h}"],
  ["0126", "{\\fontencoding{LELA}\\selectfont\\char40}"],
  ["0127", "\\Elzxh{}"],
  ["0128", "\\~{I}"],
  ["0129", "\\~{\\i}"],
  ["012a", "\\={I}"],
  ["012b", "\\={\\i}"],
  ["012c", "\\u{I}"],
  ["012d", "\\u{\\i}"],
  ["012e", "\\k{I}"],
  ["012f", "\\k{i}"],
  ["0130", "\\.{I}"],
  ["0131", "\\i{}"],
  ["0132", "IJ"],
  ["0133", "ij"],
  ["0134", "\\^{J}"],
  ["0135", "\\^{\\j}"],
  ["0136", "\\c{K}"],
  ["0137", "\\c{k}"],
  ["0138", "{\\fontencoding{LELA}\\selectfont\\char91}"],
  ["0139", "\\'{L}"],
  ["013a", "\\'{l}"],
  ["013b", "\\c{L}"],
  ["013c", "\\c{l}"],
  ["013d", "\\v{L}"],
  ["013e", "\\v{l}"],
  ["013f", "{\\fontencoding{LELA}\\selectfont\\char201}"],
  ["0140", "{\\fontencoding{LELA}\\selectfont\\char202}"],
  ["0141", "\\L{}"],
  ["0142", "\\l{}"],
  ["0143", "\\'{N}"],
  ["0144", "\\'{n}"],
  ["0145", "\\c{N}"],
  ["0146", "\\c{n}"],
  ["0147", "\\v{N}"],
  ["0148", "\\v{n}"],
  ["0149", "'n"],
  ["014a", "\\NG{}"],
  ["014b", "\\ng{}"],
  ["014c", "\\={O}"],
  ["014d", "\\={o}"],
  ["014e", "\\u{O}"],
  ["014f", "\\u{o}"],
  ["0150", "\\H{O}"],
  ["0151", "\\H{o}"],
  ["0152", "\\OE{}"],
  ["0153", "\\oe{}"],
  ["0154", "\\'{R}"],
  ["0155", "\\'{r}"],
  ["0156", "\\c{R}"],
  ["0157", "\\c{r}"],
  ["0158", "\\v{R}"],
  ["0159", "\\v{r}"],
  ["015a", "\\'{S}"],
  ["015b", "\\'{s}"],
  ["015c", "\\^{S}"],
  ["015d", "\\^{s}"],
  ["015e", "\\c{S}"],
  ["015f", "\\c{s}"],
  ["0160", "\\v{S}"],
  ["0161", "\\v{s}"],
  ["0162", "\\c{T}"],
  ["0163", "\\c{t}"],
  ["0164", "\\v{T}"],
  ["0165", "\\v{t}"],
  ["0166", "{\\fontencoding{LELA}\\selectfont\\char47}"],
  ["0167", "{\\fontencoding{LELA}\\selectfont\\char63}"],
  ["0168", "\\~{U}"],
  ["0169", "\\~{u}"],
  ["016a", "\\={U}"],
  ["016b", "\\={u}"],
  ["016c", "\\u{U}"],
  ["016d", "\\u{u}"],
  ["016e", "\\r{U}"],
  ["016f", "\\r{u}"],
  ["0170", "\\H{U}"],
  ["0171", "\\H{u}"],
  ["0172", "\\k{U}"],
  ["0173", "\\k{u}"],
  ["0174", "\\^{W}"],
  ["0175", "\\^{w}"],
  ["0176", "\\^{Y}"],
  ["0177", "\\^{y}"],
  ["0178", '\\"{Y}'],
  ["0179", "\\'{Z}"],
  ["017a", "\\'{z}"],
  ["017b", "\\.{Z}"],
  ["017c", "\\.{z}"],
  ["017d", "\\v{Z}"],
  ["017e", "\\v{z}"],
  ["0195", "\\texthvlig{}"],
  ["019e", "\\textnrleg{}"],
  ["01aa", "\\eth{}"],
  ["01ba", "{\\fontencoding{LELA}\\selectfont\\char195}"],
  ["01c2", "\\textdoublepipe{}"],
  ["01f5", "\\'{g}"],
  ["0250", "\\Elztrna{}"],
  ["0252", "\\Elztrnsa{}"],
  ["0254", "\\Elzopeno{}"],
  ["0256", "\\Elzrtld{}"],
  ["0258", "{\\fontencoding{LEIP}\\selectfont\\char61}"],
  ["0259", "\\Elzschwa{}"],
  ["025b", "\\varepsilon{}"],
  ["0263", "\\Elzpgamma{}"],
  ["0264", "\\Elzpbgam{}"],
  ["0265", "\\Elztrnh{}"],
  ["026c", "\\Elzbtdl{}"],
  ["026d", "\\Elzrtll{}"],
  ["026f", "\\Elztrnm{}"],
  ["0270", "\\Elztrnmlr{}"],
  ["0271", "\\Elzltlmr{}"],
  ["0272", "\\Elzltln{}"],
  ["0273", "\\Elzrtln{}"],
  ["0277", "\\Elzclomeg{}"],
  ["0278", "\\textphi{}"],
  ["0279", "\\Elztrnr{}"],
  ["027a", "\\Elztrnrl{}"],
  ["027b", "\\Elzrttrnr{}"],
  ["027c", "\\Elzrl{}"],
  ["027d", "\\Elzrtlr{}"],
  ["027e", "\\Elzfhr{}"],
  ["027f", "{\\fontencoding{LEIP}\\selectfont\\char202}"],
  ["0282", "\\Elzrtls{}"],
  ["0283", "\\Elzesh{}"],
  ["0287", "\\Elztrnt{}"],
  ["0288", "\\Elzrtlt{}"],
  ["028a", "\\Elzpupsil{}"],
  ["028b", "\\Elzpscrv{}"],
  ["028c", "\\Elzinvv{}"],
  ["028d", "\\Elzinvw{}"],
  ["028e", "\\Elztrny{}"],
  ["0290", "\\Elzrtlz{}"],
  ["0292", "\\Elzyogh{}"],
  ["0294", "\\Elzglst{}"],
  ["0295", "\\Elzreglst{}"],
  ["0296", "\\Elzinglst{}"],
  ["029e", "\\textturnk{}"],
  ["02a4", "\\Elzdyogh{}"],
  ["02a7", "\\Elztesh{}"],
  ["02c7", "\\textasciicaron{}"],
  ["02c8", "\\Elzverts{}"],
  ["02cc", "\\Elzverti{}"],
  ["02d0", "\\Elzlmrk{}"],
  ["02d1", "\\Elzhlmrk{}"],
  ["02d2", "\\Elzsbrhr{}"],
  ["02d3", "\\Elzsblhr{}"],
  ["02d4", "\\Elzrais{}"],
  ["02d5", "\\Elzlow{}"],
  ["02d8", "\\textasciibreve{}"],
  ["02d9", "\\textperiodcentered{}"],
  ["02da", "\\r{}"],
  ["02db", "\\k{}"],
  ["02dc", "\\texttildelow{}"],
  ["02dd", "\\H{}"],
  ["02e5", "\\tone{55}"],
  ["02e6", "\\tone{44}"],
  ["02e7", "\\tone{33}"],
  ["02e8", "\\tone{22}"],
  ["02e9", "\\tone{11}"],
  ["0300", "\\`"],
  ["0301", "\\'"],
  ["0302", "\\^"],
  ["0303", "\\~"],
  ["0304", "\\="],
  ["0306", "\\u"],
  ["0307", "\\."],
  ["0308", '\\"'],
  ["030a", "\\r"],
  ["030b", "\\H"],
  ["030c", "\\v"],
  ["030f", "\\cyrchar\\C"],
  ["0311", "{\\fontencoding{LECO}\\selectfont\\char177}"],
  ["0318", "{\\fontencoding{LECO}\\selectfont\\char184}"],
  ["0319", "{\\fontencoding{LECO}\\selectfont\\char185}"],
  ["0321", "\\Elzpalh{}"],
  ["0322", "\\Elzrh{}"],
  ["0327", "\\c"],
  ["0328", "\\k"],
  ["032a", "\\Elzsbbrg{}"],
  ["032b", "{\\fontencoding{LECO}\\selectfont\\char203}"],
  ["032f", "{\\fontencoding{LECO}\\selectfont\\char207}"],
  ["0335", "\\Elzxl{}"],
  ["0336", "\\Elzbar{}"],
  ["0337", "{\\fontencoding{LECO}\\selectfont\\char215}"],
  ["0338", "{\\fontencoding{LECO}\\selectfont\\char216}"],
  ["033a", "{\\fontencoding{LECO}\\selectfont\\char218}"],
  ["033b", "{\\fontencoding{LECO}\\selectfont\\char219}"],
  ["033c", "{\\fontencoding{LECO}\\selectfont\\char220}"],
  ["033d", "{\\fontencoding{LECO}\\selectfont\\char221}"],
  ["0361", "{\\fontencoding{LECO}\\selectfont\\char225}"],
  ["0386", "\\'{A}"],
  ["0388", "\\'{E}"],
  ["0389", "\\'{H}"],
  ["038a", "\\'{}{I}"],
  ["038c", "\\'{}O"],
  ["038e", "\\mathrm{'Y}"],
  ["038f", "\\mathrm{'\\Omega}"],
  ["0390", "\\acute{\\ddot{\\iota}}"],
  ["0391", "\\ensuremath{\\Alpha}"],
  ["0392", "\\ensuremath{\\Beta}"],
  ["0393", "\\ensuremath{\\Gamma}"],
  ["0394", "\\ensuremath{\\Delta}"],
  ["0395", "\\ensuremath{\\Epsilon}"],
  ["0396", "\\ensuremath{\\Zeta}"],
  ["0397", "\\ensuremath{\\Eta}"],
  ["0398", "\\ensuremath{\\Theta}"],
  ["0399", "\\ensuremath{\\Iota}"],
  ["039a", "\\ensuremath{\\Kappa}"],
  ["039b", "\\ensuremath{\\Lambda}"],
  ["039e", "\\ensuremath{\\Xi}"],
  ["03a0", "\\ensuremath{\\Pi}"],
  ["03a1", "\\ensuremath{\\Rho}"],
  ["03a3", "\\ensuremath{\\Sigma}"],
  ["03a4", "\\ensuremath{\\Tau}"],
  ["03a5", "\\ensuremath{\\Upsilon}"],
  ["03a6", "\\ensuremath{\\Phi}"],
  ["03a7", "\\ensuremath{\\Chi}"],
  ["03a8", "\\ensuremath{\\Psi}"],
  ["03a9", "\\ensuremath{\\Omega}"],
  ["03aa", "\\mathrm{\\ddot{I}}"],
  ["03ab", "\\mathrm{\\ddot{Y}}"],
  ["03ac", "\\'{$\\alpha$}"],
  ["03ad", "\\acute{\\epsilon}"],
  ["03ae", "\\acute{\\eta}"],
  ["03af", "\\acute{\\iota}"],
  ["03b0", "\\acute{\\ddot{\\upsilon}}"],
  ["03b1", "\\ensuremath{\\alpha}"],
  ["03b2", "\\ensuremath{\\beta}"],
  ["03b3", "\\ensuremath{\\gamma}"],
  ["03b4", "\\ensuremath{\\delta}"],
  ["03b5", "\\ensuremath{\\epsilon}"],
  ["03b6", "\\ensuremath{\\zeta}"],
  ["03b7", "\\ensuremath{\\eta}"],
  ["03b8", "\\texttheta{}"],
  ["03b9", "\\ensuremath{\\iota}"],
  ["03ba", "\\ensuremath{\\kappa}"],
  ["03bb", "\\ensuremath{\\lambda}"],
  ["03bc", "\\ensuremath{\\mu}"],
  ["03bd", "\\ensuremath{\\nu}"],
  ["03be", "\\ensuremath{\\xi}"],
  ["03c0", "\\ensuremath{\\pi}"],
  ["03c1", "\\ensuremath{\\rho}"],
  ["03c2", "\\ensuremath{\\varsigma}"],
  ["03c3", "\\ensuremath{\\sigma}"],
  ["03c4", "\\ensuremath{\\tau}"],
  ["03c5", "\\ensuremath{\\upsilon}"],
  ["03c6", "\\ensuremath{\\varphi}"],
  ["03c7", "\\ensuremath{\\chi}"],
  ["03c8", "\\ensuremath{\\psi}"],
  ["03c9", "\\ensuremath{\\omega}"],
  ["03ca", "\\ensuremath{\\ddot{\\iota}}"],
  ["03cb", "\\ensuremath{\\ddot{\\upsilon}}"],
  ["03cc", "\\'{o}"],
  ["03cd", "\\acute{\\upsilon}"],
  ["03ce", "\\acute{\\omega}"],
  ["03d0", "\\Pisymbol{ppi022}{87}"],
  ["03d1", "\\textvartheta{}"],
  ["03d2", "\\ensuremath{\\Upsilon}"],
  ["03d5", "\\ensuremath{\\phi}"],
  ["03d6", "\\ensuremath{\\varpi}"],
  ["03da", "\\Stigma{}"],
  ["03dc", "\\Digamma{}"],
  ["03dd", "\\digamma{}"],
  ["03de", "\\Koppa{}"],
  ["03e0", "\\Sampi{}"],
  ["03f0", "\\varkappa{}"],
  ["03f1", "\\varrho{}"],
  ["03f4", "\\textTheta{}"],
  ["03f6", "\\backepsilon{}"],
  ["0401", "\\cyrchar\\CYRYO{}"],
  ["0402", "\\cyrchar\\CYRDJE{}"],
  ["0403", "\\cyrchar{\\'\\CYRG}"],
  ["0404", "\\cyrchar\\CYRIE{}"],
  ["0405", "\\cyrchar\\CYRDZE{}"],
  ["0406", "\\cyrchar\\CYRII{}"],
  ["0407", "\\cyrchar\\CYRYI{}"],
  ["0408", "\\cyrchar\\CYRJE{}"],
  ["0409", "\\cyrchar\\CYRLJE{}"],
  ["040a", "\\cyrchar\\CYRNJE{}"],
  ["040b", "\\cyrchar\\CYRTSHE{}"],
  ["040c", "\\cyrchar{\\'\\CYRK}"],
  ["040e", "\\cyrchar\\CYRUSHRT{}"],
  ["040f", "\\cyrchar\\CYRDZHE{}"],
  ["0410", "\\cyrchar\\CYRA{}"],
  ["0411", "\\cyrchar\\CYRB{}"],
  ["0412", "\\cyrchar\\CYRV{}"],
  ["0413", "\\cyrchar\\CYRG{}"],
  ["0414", "\\cyrchar\\CYRD{}"],
  ["0415", "\\cyrchar\\CYRE{}"],
  ["0416", "\\cyrchar\\CYRZH{}"],
  ["0417", "\\cyrchar\\CYRZ{}"],
  ["0418", "\\cyrchar\\CYRI{}"],
  ["0419", "\\cyrchar\\CYRISHRT{}"],
  ["041a", "\\cyrchar\\CYRK{}"],
  ["041b", "\\cyrchar\\CYRL{}"],
  ["041c", "\\cyrchar\\CYRM{}"],
  ["041d", "\\cyrchar\\CYRN{}"],
  ["041e", "\\cyrchar\\CYRO{}"],
  ["041f", "\\cyrchar\\CYRP{}"],
  ["0420", "\\cyrchar\\CYRR{}"],
  ["0421", "\\cyrchar\\CYRS{}"],
  ["0422", "\\cyrchar\\CYRT{}"],
  ["0423", "\\cyrchar\\CYRU{}"],
  ["0424", "\\cyrchar\\CYRF{}"],
  ["0425", "\\cyrchar\\CYRH{}"],
  ["0426", "\\cyrchar\\CYRC{}"],
  ["0427", "\\cyrchar\\CYRCH{}"],
  ["0428", "\\cyrchar\\CYRSH{}"],
  ["0429", "\\cyrchar\\CYRSHCH{}"],
  ["042a", "\\cyrchar\\CYRHRDSN{}"],
  ["042b", "\\cyrchar\\CYRERY{}"],
  ["042c", "\\cyrchar\\CYRSFTSN{}"],
  ["042d", "\\cyrchar\\CYREREV{}"],
  ["042e", "\\cyrchar\\CYRYU{}"],
  ["042f", "\\cyrchar\\CYRYA{}"],
  ["0430", "\\cyrchar\\cyra{}"],
  ["0431", "\\cyrchar\\cyrb{}"],
  ["0432", "\\cyrchar\\cyrv{}"],
  ["0433", "\\cyrchar\\cyrg{}"],
  ["0434", "\\cyrchar\\cyrd{}"],
  ["0435", "\\cyrchar\\cyre{}"],
  ["0436", "\\cyrchar\\cyrzh{}"],
  ["0437", "\\cyrchar\\cyrz{}"],
  ["0438", "\\cyrchar\\cyri{}"],
  ["0439", "\\cyrchar\\cyrishrt{}"],
  ["043a", "\\cyrchar\\cyrk{}"],
  ["043b", "\\cyrchar\\cyrl{}"],
  ["043c", "\\cyrchar\\cyrm{}"],
  ["043d", "\\cyrchar\\cyrn{}"],
  ["043e", "\\cyrchar\\cyro{}"],
  ["043f", "\\cyrchar\\cyrp{}"],
  ["0440", "\\cyrchar\\cyrr{}"],
  ["0441", "\\cyrchar\\cyrs{}"],
  ["0442", "\\cyrchar\\cyrt{}"],
  ["0443", "\\cyrchar\\cyru{}"],
  ["0444", "\\cyrchar\\cyrf{}"],
  ["0445", "\\cyrchar\\cyrh{}"],
  ["0446", "\\cyrchar\\cyrc{}"],
  ["0447", "\\cyrchar\\cyrch{}"],
  ["0448", "\\cyrchar\\cyrsh{}"],
  ["0449", "\\cyrchar\\cyrshch{}"],
  ["044a", "\\cyrchar\\cyrhrdsn{}"],
  ["044b", "\\cyrchar\\cyrery{}"],
  ["044c", "\\cyrchar\\cyrsftsn{}"],
  ["044d", "\\cyrchar\\cyrerev{}"],
  ["044e", "\\cyrchar\\cyryu{}"],
  ["044f", "\\cyrchar\\cyrya{}"],
  ["0451", "\\cyrchar\\cyryo{}"],
  ["0452", "\\cyrchar\\cyrdje{}"],
  ["0453", "\\cyrchar{\\'\\cyrg}"],
  ["0454", "\\cyrchar\\cyrie{}"],
  ["0455", "\\cyrchar\\cyrdze{}"],
  ["0456", "\\cyrchar\\cyrii{}"],
  ["0457", "\\cyrchar\\cyryi{}"],
  ["0458", "\\cyrchar\\cyrje{}"],
  ["0459", "\\cyrchar\\cyrlje{}"],
  ["045a", "\\cyrchar\\cyrnje{}"],
  ["045b", "\\cyrchar\\cyrtshe{}"],
  ["045c", "\\cyrchar{\\'\\cyrk}"],
  ["045e", "\\cyrchar\\cyrushrt{}"],
  ["045f", "\\cyrchar\\cyrdzhe{}"],
  ["0460", "\\cyrchar\\CYROMEGA{}"],
  ["0461", "\\cyrchar\\cyromega{}"],
  ["0462", "\\cyrchar\\CYRYAT{}"],
  ["0464", "\\cyrchar\\CYRIOTE{}"],
  ["0465", "\\cyrchar\\cyriote{}"],
  ["0466", "\\cyrchar\\CYRLYUS{}"],
  ["0467", "\\cyrchar\\cyrlyus{}"],
  ["0468", "\\cyrchar\\CYRIOTLYUS{}"],
  ["0469", "\\cyrchar\\cyriotlyus{}"],
  ["046a", "\\cyrchar\\CYRBYUS{}"],
  ["046c", "\\cyrchar\\CYRIOTBYUS{}"],
  ["046d", "\\cyrchar\\cyriotbyus{}"],
  ["046e", "\\cyrchar\\CYRKSI{}"],
  ["046f", "\\cyrchar\\cyrksi{}"],
  ["0470", "\\cyrchar\\CYRPSI{}"],
  ["0471", "\\cyrchar\\cyrpsi{}"],
  ["0472", "\\cyrchar\\CYRFITA{}"],
  ["0474", "\\cyrchar\\CYRIZH{}"],
  ["0478", "\\cyrchar\\CYRUK{}"],
  ["0479", "\\cyrchar\\cyruk{}"],
  ["047a", "\\cyrchar\\CYROMEGARND{}"],
  ["047b", "\\cyrchar\\cyromegarnd{}"],
  ["047c", "\\cyrchar\\CYROMEGATITLO{}"],
  ["047d", "\\cyrchar\\cyromegatitlo{}"],
  ["047e", "\\cyrchar\\CYROT{}"],
  ["047f", "\\cyrchar\\cyrot{}"],
  ["0480", "\\cyrchar\\CYRKOPPA{}"],
  ["0481", "\\cyrchar\\cyrkoppa{}"],
  ["0482", "\\cyrchar\\cyrthousands{}"],
  ["0488", "\\cyrchar\\cyrhundredthousands{}"],
  ["0489", "\\cyrchar\\cyrmillions{}"],
  ["048c", "\\cyrchar\\CYRSEMISFTSN{}"],
  ["048d", "\\cyrchar\\cyrsemisftsn{}"],
  ["048e", "\\cyrchar\\CYRRTICK{}"],
  ["048f", "\\cyrchar\\cyrrtick{}"],
  ["0490", "\\cyrchar\\CYRGUP{}"],
  ["0491", "\\cyrchar\\cyrgup{}"],
  ["0492", "\\cyrchar\\CYRGHCRS{}"],
  ["0493", "\\cyrchar\\cyrghcrs{}"],
  ["0494", "\\cyrchar\\CYRGHK{}"],
  ["0495", "\\cyrchar\\cyrghk{}"],
  ["0496", "\\cyrchar\\CYRZHDSC{}"],
  ["0497", "\\cyrchar\\cyrzhdsc{}"],
  ["0498", "\\cyrchar\\CYRZDSC{}"],
  ["0499", "\\cyrchar\\cyrzdsc{}"],
  ["049a", "\\cyrchar\\CYRKDSC{}"],
  ["049b", "\\cyrchar\\cyrkdsc{}"],
  ["049c", "\\cyrchar\\CYRKVCRS{}"],
  ["049d", "\\cyrchar\\cyrkvcrs{}"],
  ["049e", "\\cyrchar\\CYRKHCRS{}"],
  ["049f", "\\cyrchar\\cyrkhcrs{}"],
  ["04a0", "\\cyrchar\\CYRKBEAK{}"],
  ["04a1", "\\cyrchar\\cyrkbeak{}"],
  ["04a2", "\\cyrchar\\CYRNDSC{}"],
  ["04a3", "\\cyrchar\\cyrndsc{}"],
  ["04a4", "\\cyrchar\\CYRNG{}"],
  ["04a5", "\\cyrchar\\cyrng{}"],
  ["04a6", "\\cyrchar\\CYRPHK{}"],
  ["04a7", "\\cyrchar\\cyrphk{}"],
  ["04a8", "\\cyrchar\\CYRABHHA{}"],
  ["04a9", "\\cyrchar\\cyrabhha{}"],
  ["04aa", "\\cyrchar\\CYRSDSC{}"],
  ["04ab", "\\cyrchar\\cyrsdsc{}"],
  ["04ac", "\\cyrchar\\CYRTDSC{}"],
  ["04ad", "\\cyrchar\\cyrtdsc{}"],
  ["04ae", "\\cyrchar\\CYRY{}"],
  ["04af", "\\cyrchar\\cyry{}"],
  ["04b0", "\\cyrchar\\CYRYHCRS{}"],
  ["04b1", "\\cyrchar\\cyryhcrs{}"],
  ["04b2", "\\cyrchar\\CYRHDSC{}"],
  ["04b3", "\\cyrchar\\cyrhdsc{}"],
  ["04b4", "\\cyrchar\\CYRTETSE{}"],
  ["04b5", "\\cyrchar\\cyrtetse{}"],
  ["04b6", "\\cyrchar\\CYRCHRDSC{}"],
  ["04b7", "\\cyrchar\\cyrchrdsc{}"],
  ["04b8", "\\cyrchar\\CYRCHVCRS{}"],
  ["04b9", "\\cyrchar\\cyrchvcrs{}"],
  ["04ba", "\\cyrchar\\CYRSHHA{}"],
  ["04bb", "\\cyrchar\\cyrshha{}"],
  ["04bc", "\\cyrchar\\CYRABHCH{}"],
  ["04bd", "\\cyrchar\\cyrabhch{}"],
  ["04be", "\\cyrchar\\CYRABHCHDSC{}"],
  ["04bf", "\\cyrchar\\cyrabhchdsc{}"],
  ["04c0", "\\cyrchar\\CYRpalochka{}"],
  ["04c3", "\\cyrchar\\CYRKHK{}"],
  ["04c4", "\\cyrchar\\cyrkhk{}"],
  ["04c7", "\\cyrchar\\CYRNHK{}"],
  ["04c8", "\\cyrchar\\cyrnhk{}"],
  ["04cb", "\\cyrchar\\CYRCHLDSC{}"],
  ["04cc", "\\cyrchar\\cyrchldsc{}"],
  ["04d4", "\\cyrchar\\CYRAE{}"],
  ["04d5", "\\cyrchar\\cyrae{}"],
  ["04d8", "\\cyrchar\\CYRSCHWA{}"],
  ["04d9", "\\cyrchar\\cyrschwa{}"],
  ["04e0", "\\cyrchar\\CYRABHDZE{}"],
  ["04e1", "\\cyrchar\\cyrabhdze{}"],
  ["04e8", "\\cyrchar\\CYROTLD{}"],
  ["04e9", "\\cyrchar\\cyrotld{}"],
  ["2002", "\\hspace{0.6em}"],
  ["2003", "\\hspace{1em}"],
  ["2004", "\\hspace{0.33em}"],
  ["2005", "\\hspace{0.25em}"],
  ["2006", "\\hspace{0.166em}"],
  ["2007", "\\hphantom{0}"],
  ["2008", "\\hphantom{,}"],
  ["2009", "\\hspace{0.167em}"],
  ["200a", "\\mkern1mu{}"],
  ["2010", "-"],
  ["2014", "--"],
  ["2015", "\\rule{1em}{1pt}"],
  ["2016", "\\Vert{}"],
  ["2018", "`"],
  ["2019", "'"],
  ["201b", "\\Elzreapos{}"],
  ["201c", "``"],
  ["201d", "''"],
  ["201e", ",,"],
  ["2020", "\\textdagger{}"],
  ["2021", "\\textdaggerdbl{}"],
  ["2022", "\\textbullet{}"],
  ["2025", ".."],
  ["2026", "\\ldots{}"],
  ["2030", "\\textperthousand{}"],
  ["2031", "\\textpertenthousand{}"],
  ["2032", "\\ensuremath{'}"],
  ["2033", "\\ensuremath{''}"],
  ["2034", "\\ensuremath{'''}"],
  ["2035", "\\backprime{}"],
  ["2039", "\\guilsinglleft{}"],
  ["203a", "\\guilsinglright{}"],
  ["2057", "''''"],
  ["205f", "\\mkern4mu{}"],
  ["2060", "\\nolinebreak{}"],
  ["20a7", "\\ensuremath{\\Elzpes}"],
  ["20ac", "\\mbox{\\texteuro}{}"],
  ["20db", "\\dddot{}"],
  ["20dc", "\\ddddot{}"],
  ["2102", "\\mathbb{C}"],
  ["210a", "\\mathscr{g}"],
  ["210b", "\\mathscr{H}"],
  ["210c", "\\mathfrak{H}"],
  ["210d", "\\mathbb{H}"],
  ["210f", "\\hslash{}"],
  ["2110", "\\mathscr{I}"],
  ["2111", "\\mathfrak{I}"],
  ["2112", "\\mathscr{L}"],
  ["2113", "\\mathscr{l}"],
  ["2115", "\\mathbb{N}"],
  ["2116", "\\cyrchar\\textnumero{}"],
  ["2118", "\\wp{}"],
  ["2119", "\\mathbb{P}"],
  ["211a", "\\mathbb{Q}"],
  ["211b", "\\mathscr{R}"],
  ["211c", "\\mathfrak{R}"],
  ["211d", "\\mathbb{R}"],
  ["211e", "\\Elzxrat{}"],
  ["2122", "\\texttrademark{}"],
  ["2124", "\\mathbb{Z}"],
  ["2126", "\\Omega{}"],
  ["2127", "\\mho{}"],
  ["2128", "\\mathfrak{Z}"],
  ["2129", "\\ElsevierGlyph{2129}"],
  ["212b", "\\AA{}"],
  ["212c", "\\mathscr{B}"],
  ["212d", "\\mathfrak{C}"],
  ["212f", "\\mathscr{e}"],
  ["2130", "\\mathscr{E}"],
  ["2131", "\\mathscr{F}"],
  ["2133", "\\mathscr{M}"],
  ["2134", "\\mathscr{o}"],
  ["2135", "\\aleph{}"],
  ["2136", "\\beth{}"],
  ["2137", "\\gimel{}"],
  ["2138", "\\daleth{}"],
  ["2153", "\\textfrac{1}{3}"],
  ["2154", "\\textfrac{2}{3}"],
  ["2155", "\\textfrac{1}{5}"],
  ["2156", "\\textfrac{2}{5}"],
  ["2157", "\\textfrac{3}{5}"],
  ["2158", "\\textfrac{4}{5}"],
  ["2159", "\\textfrac{1}{6}"],
  ["215a", "\\textfrac{5}{6}"],
  ["215b", "\\textfrac{1}{8}"],
  ["215c", "\\textfrac{3}{8}"],
  ["215d", "\\textfrac{5}{8}"],
  ["215e", "\\textfrac{7}{8}"],
  ["2190", "\\leftarrow{}"],
  ["2191", "\\uparrow{}"],
  ["2192", "\\rightarrow{}"],
  ["2193", "\\downarrow{}"],
  ["2194", "\\leftrightarrow{}"],
  ["2195", "\\updownarrow{}"],
  ["2196", "\\nwarrow{}"],
  ["2197", "\\nearrow{}"],
  ["2198", "\\searrow{}"],
  ["2199", "\\swarrow{}"],
  ["219a", "\\nleftarrow{}"],
  ["219b", "\\nrightarrow{}"],
  ["219c", "\\arrowwaveright{}"],
  ["219d", "\\arrowwaveright{}"],
  ["219e", "\\twoheadleftarrow{}"],
  ["21a0", "\\twoheadrightarrow{}"],
  ["21a2", "\\leftarrowtail{}"],
  ["21a3", "\\rightarrowtail{}"],
  ["21a6", "\\mapsto{}"],
  ["21a9", "\\hookleftarrow{}"],
  ["21aa", "\\hookrightarrow{}"],
  ["21ab", "\\looparrowleft{}"],
  ["21ac", "\\looparrowright{}"],
  ["21ad", "\\leftrightsquigarrow{}"],
  ["21ae", "\\nleftrightarrow{}"],
  ["21b0", "\\Lsh{}"],
  ["21b1", "\\Rsh{}"],
  ["21b3", "\\ElsevierGlyph{21B3}"],
  ["21b6", "\\curvearrowleft{}"],
  ["21b7", "\\curvearrowright{}"],
  ["21ba", "\\circlearrowleft{}"],
  ["21bb", "\\circlearrowright{}"],
  ["21bc", "\\leftharpoonup{}"],
  ["21bd", "\\leftharpoondown{}"],
  ["21be", "\\upharpoonright{}"],
  ["21bf", "\\upharpoonleft{}"],
  ["21c0", "\\rightharpoonup{}"],
  ["21c1", "\\rightharpoondown{}"],
  ["21c2", "\\downharpoonright{}"],
  ["21c3", "\\downharpoonleft{}"],
  ["21c4", "\\rightleftarrows{}"],
  ["21c5", "\\dblarrowupdown{}"],
  ["21c6", "\\leftrightarrows{}"],
  ["21c7", "\\leftleftarrows{}"],
  ["21c8", "\\upuparrows{}"],
  ["21c9", "\\rightrightarrows{}"],
  ["21ca", "\\downdownarrows{}"],
  ["21cb", "\\leftrightharpoons{}"],
  ["21cc", "\\rightleftharpoons{}"],
  ["21cd", "\\nLeftarrow{}"],
  ["21ce", "\\nLeftrightarrow{}"],
  ["21cf", "\\nRightarrow{}"],
  ["21d0", "\\Leftarrow{}"],
  ["21d1", "\\Uparrow{}"],
  ["21d2", "\\Rightarrow{}"],
  ["21d3", "\\Downarrow{}"],
  ["21d4", "\\Leftrightarrow{}"],
  ["21d5", "\\Updownarrow{}"],
  ["21da", "\\Lleftarrow{}"],
  ["21db", "\\Rrightarrow{}"],
  ["21dd", "\\rightsquigarrow{}"],
  ["21f5", "\\DownArrowUpArrow{}"],
  ["2200", "\\forall{}"],
  ["2201", "\\complement{}"],
  ["2202", "\\partial{}"],
  ["2203", "\\exists{}"],
  ["2204", "\\nexists{}"],
  ["2205", "\\varnothing{}"],
  ["2207", "\\nabla{}"],
  ["2208", "\\in{}"],
  ["2209", "\\not\\in{}"],
  ["220b", "\\ni{}"],
  ["220c", "\\not\\ni{}"],
  ["220f", "\\prod{}"],
  ["2210", "\\coprod{}"],
  ["2211", "\\sum{}"],
  ["2212", "-"],
  ["2213", "\\mp{}"],
  ["2214", "\\dotplus{}"],
  ["2216", "\\setminus{}"],
  ["2217", "{\\_\\ast}"],
  ["2218", "\\circ{}"],
  ["2219", "\\bullet{}"],
  ["221a", "\\surd{}"],
  ["221d", "\\propto{}"],
  ["221e", "\\infty{}"],
  ["221f", "\\rightangle{}"],
  ["2220", "\\angle{}"],
  ["2221", "\\measuredangle{}"],
  ["2222", "\\sphericalangle{}"],
  ["2223", "\\mid{}"],
  ["2224", "\\nmid{}"],
  ["2225", "\\parallel{}"],
  ["2226", "\\nparallel{}"],
  ["2227", "\\wedge{}"],
  ["2228", "\\vee{}"],
  ["2229", "\\cap{}"],
  ["222a", "\\cup{}"],
  ["222b", "\\int{}"],
  ["222c", "\\int\\!\\int{}"],
  ["222d", "\\int\\!\\int\\!\\int{}"],
  ["222e", "\\oint{}"],
  ["222f", "\\surfintegral{}"],
  ["2230", "\\volintegral{}"],
  ["2231", "\\clwintegral{}"],
  ["2232", "\\ElsevierGlyph{2232}"],
  ["2233", "\\ElsevierGlyph{2233}"],
  ["2234", "\\therefore{}"],
  ["2235", "\\because{}"],
  ["2237", "\\Colon{}"],
  ["2238", "\\ElsevierGlyph{2238}"],
  ["223a", "\\mathbin{{:}\\!\\!{-}\\!\\!{:}}"],
  ["223b", "\\homothetic{}"],
  ["223c", "\\sim{}"],
  ["223d", "\\backsim{}"],
  ["223e", "\\lazysinv{}"],
  ["2240", "\\wr{}"],
  ["2241", "\\not\\sim{}"],
  ["2242", "\\ElsevierGlyph{2242}"],
  ["2243", "\\simeq{}"],
  ["2244", "\\not\\simeq{}"],
  ["2245", "\\cong{}"],
  ["2246", "\\approxnotequal{}"],
  ["2247", "\\not\\cong{}"],
  ["2248", "\\approx{}"],
  ["2249", "\\not\\approx{}"],
  ["224a", "\\approxeq{}"],
  ["224b", "\\tildetrpl{}"],
  ["224c", "\\allequal{}"],
  ["224d", "\\asymp{}"],
  ["224e", "\\Bumpeq{}"],
  ["224f", "\\bumpeq{}"],
  ["2250", "\\doteq{}"],
  ["2251", "\\doteqdot{}"],
  ["2252", "\\fallingdotseq{}"],
  ["2253", "\\risingdotseq{}"],
  ["2254", ":="],
  ["2255", "=:"],
  ["2256", "\\eqcirc{}"],
  ["2257", "\\circeq{}"],
  ["2259", "\\estimates{}"],
  ["225a", "\\ElsevierGlyph{225A}"],
  ["225b", "\\starequal{}"],
  ["225c", "\\triangleq{}"],
  ["225f", "\\ElsevierGlyph{225F}"],
  ["2260", "\\not ="],
  ["2261", "\\equiv{}"],
  ["2262", "\\not\\equiv{}"],
  ["2264", "\\leq{}"],
  ["2265", "\\geq{}"],
  ["2266", "\\leqq{}"],
  ["2267", "\\geqq{}"],
  ["2268", "\\lneqq{}"],
  ["2269", "\\gneqq{}"],
  ["226a", "\\ll{}"],
  ["226b", "\\gg{}"],
  ["226c", "\\between{}"],
  ["226d", "\\not\\kern-0.3em\\times{}"],
  ["226e", "\\not&lt;"],
  ["226f", "\\not&gt;"],
  ["2270", "\\not\\leq{}"],
  ["2271", "\\not\\geq{}"],
  ["2272", "\\lessequivlnt{}"],
  ["2273", "\\greaterequivlnt{}"],
  ["2274", "\\ElsevierGlyph{2274}"],
  ["2275", "\\ElsevierGlyph{2275}"],
  ["2276", "\\lessgtr{}"],
  ["2277", "\\gtrless{}"],
  ["2278", "\\notlessgreater{}"],
  ["2279", "\\notgreaterless{}"],
  ["227a", "\\prec{}"],
  ["227b", "\\succ{}"],
  ["227c", "\\preccurlyeq{}"],
  ["227d", "\\succcurlyeq{}"],
  ["227e", "\\precapprox{}"],
  ["227f", "\\succapprox{}"],
  ["2280", "\\not\\prec{}"],
  ["2281", "\\not\\succ{}"],
  ["2282", "\\subset{}"],
  ["2283", "\\supset{}"],
  ["2284", "\\not\\subset{}"],
  ["2285", "\\not\\supset{}"],
  ["2286", "\\subseteq{}"],
  ["2287", "\\supseteq{}"],
  ["2288", "\\not\\subseteq{}"],
  ["2289", "\\not\\supseteq{}"],
  ["228a", "\\subsetneq{}"],
  ["228b", "\\supsetneq{}"],
  ["228e", "\\uplus{}"],
  ["228f", "\\sqsubset{}"],
  ["2290", "\\sqsupset{}"],
  ["2291", "\\sqsubseteq{}"],
  ["2292", "\\sqsupseteq{}"],
  ["2293", "\\sqcap{}"],
  ["2294", "\\sqcup{}"],
  ["2295", "\\oplus{}"],
  ["2296", "\\ominus{}"],
  ["2297", "\\otimes{}"],
  ["2298", "\\oslash{}"],
  ["2299", "\\odot{}"],
  ["229a", "\\circledcirc{}"],
  ["229b", "\\circledast{}"],
  ["229d", "\\circleddash{}"],
  ["229e", "\\boxplus{}"],
  ["229f", "\\boxminus{}"],
  ["22a0", "\\boxtimes{}"],
  ["22a1", "\\boxdot{}"],
  ["22a2", "\\vdash{}"],
  ["22a3", "\\dashv{}"],
  ["22a4", "\\top{}"],
  ["22a5", "\\perp{}"],
  ["22a7", "\\truestate{}"],
  ["22a8", "\\forcesextra{}"],
  ["22a9", "\\Vdash{}"],
  ["22aa", "\\Vvdash{}"],
  ["22ab", "\\VDash{}"],
  ["22ac", "\\nvdash{}"],
  ["22ad", "\\nvDash{}"],
  ["22ae", "\\nVdash{}"],
  ["22af", "\\nVDash{}"],
  ["22b2", "\\vartriangleleft{}"],
  ["22b3", "\\vartriangleright{}"],
  ["22b4", "\\trianglelefteq{}"],
  ["22b5", "\\trianglerighteq{}"],
  ["22b6", "\\original{}"],
  ["22b7", "\\image{}"],
  ["22b8", "\\multimap{}"],
  ["22b9", "\\hermitconjmatrix{}"],
  ["22ba", "\\intercal{}"],
  ["22bb", "\\veebar{}"],
  ["22be", "\\rightanglearc{}"],
  ["22c0", "\\ElsevierGlyph{22C0}"],
  ["22c1", "\\ElsevierGlyph{22C1}"],
  ["22c2", "\\bigcap{}"],
  ["22c3", "\\bigcup{}"],
  ["22c4", "\\diamond{}"],
  ["22c5", "\\cdot{}"],
  ["22c6", "\\star{}"],
  ["22c7", "\\divideontimes{}"],
  ["22c8", "\\bowtie{}"],
  ["22c9", "\\ltimes{}"],
  ["22ca", "\\rtimes{}"],
  ["22cb", "\\leftthreetimes{}"],
  ["22cc", "\\rightthreetimes{}"],
  ["22cd", "\\backsimeq{}"],
  ["22ce", "\\curlyvee{}"],
  ["22cf", "\\curlywedge{}"],
  ["22d0", "\\Subset{}"],
  ["22d1", "\\Supset{}"],
  ["22d2", "\\Cap{}"],
  ["22d3", "\\Cup{}"],
  ["22d4", "\\pitchfork{}"],
  ["22d6", "\\lessdot{}"],
  ["22d7", "\\gtrdot{}"],
  ["22d8", "\\verymuchless{}"],
  ["22d9", "\\verymuchgreater{}"],
  ["22da", "\\lesseqgtr{}"],
  ["22db", "\\gtreqless{}"],
  ["22de", "\\curlyeqprec{}"],
  ["22df", "\\curlyeqsucc{}"],
  ["22e2", "\\not\\sqsubseteq{}"],
  ["22e3", "\\not\\sqsupseteq{}"],
  ["22e5", "\\Elzsqspne{}"],
  ["22e6", "\\lnsim{}"],
  ["22e7", "\\gnsim{}"],
  ["22e8", "\\precedesnotsimilar{}"],
  ["22e9", "\\succnsim{}"],
  ["22ea", "\\ntriangleleft{}"],
  ["22eb", "\\ntriangleright{}"],
  ["22ec", "\\ntrianglelefteq{}"],
  ["22ed", "\\ntrianglerighteq{}"],
  ["22ee", "\\vdots{}"],
  ["22ef", "\\cdots{}"],
  ["22f0", "\\upslopeellipsis{}"],
  ["22f1", "\\downslopeellipsis{}"],
  ["2305", "\\barwedge{}"],
  ["2306", "\\perspcorrespond{}"],
  ["2308", "\\lceil{}"],
  ["2309", "\\rceil{}"],
  ["230a", "\\lfloor{}"],
  ["230b", "\\rfloor{}"],
  ["2315", "\\recorder{}"],
  ["2316", '\\mathchar"2208'],
  ["231c", "\\ulcorner{}"],
  ["231d", "\\urcorner{}"],
  ["231e", "\\llcorner{}"],
  ["231f", "\\lrcorner{}"],
  ["2322", "\\frown{}"],
  ["2323", "\\smile{}"],
  ["2329", "\\langle{}"],
  ["232a", "\\rangle{}"],
  ["233d", "\\ElsevierGlyph{E838}"],
  ["23a3", "\\Elzdlcorn{}"],
  ["23b0", "\\lmoustache{}"],
  ["23b1", "\\rmoustache{}"],
  ["2423", "\\textvisiblespace{}"],
  ["2460", "\\ding{172}"],
  ["2461", "\\ding{173}"],
  ["2462", "\\ding{174}"],
  ["2463", "\\ding{175}"],
  ["2464", "\\ding{176}"],
  ["2465", "\\ding{177}"],
  ["2466", "\\ding{178}"],
  ["2467", "\\ding{179}"],
  ["2468", "\\ding{180}"],
  ["2469", "\\ding{181}"],
  ["24c8", "\\circledS{}"],
  ["2506", "\\Elzdshfnc{}"],
  ["2519", "\\Elzsqfnw{}"],
  ["2571", "\\diagup{}"],
  ["25a0", "\\ding{110}"],
  ["25a1", "\\square{}"],
  ["25aa", "\\blacksquare{}"],
  ["25ad", "\\fbox{~~}"],
  ["25af", "\\Elzvrecto{}"],
  ["25b1", "\\ElsevierGlyph{E381}"],
  ["25b2", "\\ding{115}"],
  ["25b3", "\\bigtriangleup{}"],
  ["25b4", "\\blacktriangle{}"],
  ["25b5", "\\vartriangle{}"],
  ["25b8", "\\blacktriangleright{}"],
  ["25b9", "\\triangleright{}"],
  ["25bc", "\\ding{116}"],
  ["25bd", "\\bigtriangledown{}"],
  ["25be", "\\blacktriangledown{}"],
  ["25bf", "\\triangledown{}"],
  ["25c2", "\\blacktriangleleft{}"],
  ["25c3", "\\triangleleft{}"],
  ["25c6", "\\ding{117}"],
  ["25ca", "\\lozenge{}"],
  ["25cb", "\\bigcirc{}"],
  ["25cf", "\\ding{108}"],
  ["25d0", "\\Elzcirfl{}"],
  ["25d1", "\\Elzcirfr{}"],
  ["25d2", "\\Elzcirfb{}"],
  ["25d7", "\\ding{119}"],
  ["25d8", "\\Elzrvbull{}"],
  ["25e7", "\\Elzsqfl{}"],
  ["25e8", "\\Elzsqfr{}"],
  ["25ea", "\\Elzsqfse{}"],
  ["25ef", "\\bigcirc{}"],
  ["2605", "\\ding{72}"],
  ["2606", "\\ding{73}"],
  ["260e", "\\ding{37}"],
  ["261b", "\\ding{42}"],
  ["261e", "\\ding{43}"],
  ["263e", "\\rightmoon{}"],
  ["263f", "\\mercury{}"],
  ["2640", "\\venus{}"],
  ["2642", "\\male{}"],
  ["2643", "\\jupiter{}"],
  ["2644", "\\saturn{}"],
  ["2645", "\\uranus{}"],
  ["2646", "\\neptune{}"],
  ["2647", "\\pluto{}"],
  ["2648", "\\aries{}"],
  ["2649", "\\taurus{}"],
  ["264a", "\\gemini{}"],
  ["264b", "\\cancer{}"],
  ["264c", "\\leo{}"],
  ["264d", "\\virgo{}"],
  ["264e", "\\libra{}"],
  ["264f", "\\scorpio{}"],
  ["2650", "\\sagittarius{}"],
  ["2651", "\\capricornus{}"],
  ["2652", "\\aquarius{}"],
  ["2653", "\\pisces{}"],
  ["2660", "\\ding{171}"],
  ["2662", "\\diamond{}"],
  ["2663", "\\ding{168}"],
  ["2665", "\\ding{170}"],
  ["2666", "\\ding{169}"],
  ["2669", "\\quarternote{}"],
  ["266a", "\\eighthnote{}"],
  ["266d", "\\flat{}"],
  ["266e", "\\natural{}"],
  ["266f", "\\sharp{}"],
  ["2701", "\\ding{33}"],
  ["2702", "\\ding{34}"],
  ["2703", "\\ding{35}"],
  ["2704", "\\ding{36}"],
  ["2706", "\\ding{38}"],
  ["2707", "\\ding{39}"],
  ["2708", "\\ding{40}"],
  ["2709", "\\ding{41}"],
  ["270c", "\\ding{44}"],
  ["270d", "\\ding{45}"],
  ["270e", "\\ding{46}"],
  ["270f", "\\ding{47}"],
  ["2710", "\\ding{48}"],
  ["2711", "\\ding{49}"],
  ["2712", "\\ding{50}"],
  ["2713", "\\ding{51}"],
  ["2714", "\\ding{52}"],
  ["2715", "\\ding{53}"],
  ["2716", "\\ding{54}"],
  ["2717", "\\ding{55}"],
  ["2718", "\\ding{56}"],
  ["2719", "\\ding{57}"],
  ["271a", "\\ding{58}"],
  ["271b", "\\ding{59}"],
  ["271c", "\\ding{60}"],
  ["271d", "\\ding{61}"],
  ["271e", "\\ding{62}"],
  ["271f", "\\ding{63}"],
  ["2720", "\\ding{64}"],
  ["2721", "\\ding{65}"],
  ["2722", "\\ding{66}"],
  ["2723", "\\ding{67}"],
  ["2724", "\\ding{68}"],
  ["2725", "\\ding{69}"],
  ["2726", "\\ding{70}"],
  ["2727", "\\ding{71}"],
  ["2729", "\\ding{73}"],
  ["272a", "\\ding{74}"],
  ["272b", "\\ding{75}"],
  ["272c", "\\ding{76}"],
  ["272d", "\\ding{77}"],
  ["272e", "\\ding{78}"],
  ["272f", "\\ding{79}"],
  ["2730", "\\ding{80}"],
  ["2731", "\\ding{81}"],
  ["2732", "\\ding{82}"],
  ["2733", "\\ding{83}"],
  ["2734", "\\ding{84}"],
  ["2735", "\\ding{85}"],
  ["2736", "\\ding{86}"],
  ["2737", "\\ding{87}"],
  ["2738", "\\ding{88}"],
  ["2739", "\\ding{89}"],
  ["273a", "\\ding{90}"],
  ["273b", "\\ding{91}"],
  ["273c", "\\ding{92}"],
  ["273d", "\\ding{93}"],
  ["273e", "\\ding{94}"],
  ["273f", "\\ding{95}"],
  ["2740", "\\ding{96}"],
  ["2741", "\\ding{97}"],
  ["2742", "\\ding{98}"],
  ["2743", "\\ding{99}"],
  ["2744", "\\ding{100}"],
  ["2745", "\\ding{101}"],
  ["2746", "\\ding{102}"],
  ["2747", "\\ding{103}"],
  ["2748", "\\ding{104}"],
  ["2749", "\\ding{105}"],
  ["274a", "\\ding{106}"],
  ["274b", "\\ding{107}"],
  ["274d", "\\ding{109}"],
  ["274f", "\\ding{111}"],
  ["2750", "\\ding{112}"],
  ["2751", "\\ding{113}"],
  ["2752", "\\ding{114}"],
  ["2756", "\\ding{118}"],
  ["2758", "\\ding{120}"],
  ["2759", "\\ding{121}"],
  ["275a", "\\ding{122}"],
  ["275b", "\\ding{123}"],
  ["275c", "\\ding{124}"],
  ["275d", "\\ding{125}"],
  ["275e", "\\ding{126}"],
  ["2761", "\\ding{161}"],
  ["2762", "\\ding{162}"],
  ["2763", "\\ding{163}"],
  ["2764", "\\ding{164}"],
  ["2765", "\\ding{165}"],
  ["2766", "\\ding{166}"],
  ["2767", "\\ding{167}"],
  ["2776", "\\ding{182}"],
  ["2777", "\\ding{183}"],
  ["2778", "\\ding{184}"],
  ["2779", "\\ding{185}"],
  ["277a", "\\ding{186}"],
  ["277b", "\\ding{187}"],
  ["277c", "\\ding{188}"],
  ["277d", "\\ding{189}"],
  ["277e", "\\ding{190}"],
  ["277f", "\\ding{191}"],
  ["2780", "\\ding{192}"],
  ["2781", "\\ding{193}"],
  ["2782", "\\ding{194}"],
  ["2783", "\\ding{195}"],
  ["2784", "\\ding{196}"],
  ["2785", "\\ding{197}"],
  ["2786", "\\ding{198}"],
  ["2787", "\\ding{199}"],
  ["2788", "\\ding{200}"],
  ["2789", "\\ding{201}"],
  ["278a", "\\ding{202}"],
  ["278b", "\\ding{203}"],
  ["278c", "\\ding{204}"],
  ["278d", "\\ding{205}"],
  ["278e", "\\ding{206}"],
  ["278f", "\\ding{207}"],
  ["2790", "\\ding{208}"],
  ["2791", "\\ding{209}"],
  ["2792", "\\ding{210}"],
  ["2793", "\\ding{211}"],
  ["2794", "\\ding{212}"],
  ["2798", "\\ding{216}"],
  ["2799", "\\ding{217}"],
  ["279a", "\\ding{218}"],
  ["279b", "\\ding{219}"],
  ["279c", "\\ding{220}"],
  ["279d", "\\ding{221}"],
  ["279e", "\\ding{222}"],
  ["279f", "\\ding{223}"],
  ["27a0", "\\ding{224}"],
  ["27a1", "\\ding{225}"],
  ["27a2", "\\ding{226}"],
  ["27a3", "\\ding{227}"],
  ["27a4", "\\ding{228}"],
  ["27a5", "\\ding{229}"],
  ["27a6", "\\ding{230}"],
  ["27a7", "\\ding{231}"],
  ["27a8", "\\ding{232}"],
  ["27a9", "\\ding{233}"],
  ["27aa", "\\ding{234}"],
  ["27ab", "\\ding{235}"],
  ["27ac", "\\ding{236}"],
  ["27ad", "\\ding{237}"],
  ["27ae", "\\ding{238}"],
  ["27af", "\\ding{239}"],
  ["27b1", "\\ding{241}"],
  ["27b2", "\\ding{242}"],
  ["27b3", "\\ding{243}"],
  ["27b4", "\\ding{244}"],
  ["27b5", "\\ding{245}"],
  ["27b6", "\\ding{246}"],
  ["27b7", "\\ding{247}"],
  ["27b8", "\\ding{248}"],
  ["27b9", "\\ding{249}"],
  ["27ba", "\\ding{250}"],
  ["27bb", "\\ding{251}"],
  ["27bc", "\\ding{252}"],
  ["27bd", "\\ding{253}"],
  ["27be", "\\ding{254}"],
  ["27f5", "\\longleftarrow{}"],
  ["27f6", "\\longrightarrow{}"],
  ["27f7", "\\longleftrightarrow{}"],
  ["27f8", "\\Longleftarrow{}"],
  ["27f9", "\\Longrightarrow{}"],
  ["27fa", "\\Longleftrightarrow{}"],
  ["27fc", "\\longmapsto{}"],
  ["27ff", "\\sim\\joinrel\\leadsto"],
  ["2905", "\\ElsevierGlyph{E212}"],
  ["2912", "\\UpArrowBar{}"],
  ["2913", "\\DownArrowBar{}"],
  ["2923", "\\ElsevierGlyph{E20C}"],
  ["2924", "\\ElsevierGlyph{E20D}"],
  ["2925", "\\ElsevierGlyph{E20B}"],
  ["2926", "\\ElsevierGlyph{E20A}"],
  ["2927", "\\ElsevierGlyph{E211}"],
  ["2928", "\\ElsevierGlyph{E20E}"],
  ["2929", "\\ElsevierGlyph{E20F}"],
  ["292a", "\\ElsevierGlyph{E210}"],
  ["2933", "\\ElsevierGlyph{E21C}"],
  ["2936", "\\ElsevierGlyph{E21A}"],
  ["2937", "\\ElsevierGlyph{E219}"],
  ["2940", "\\Elolarr{}"],
  ["2941", "\\Elorarr{}"],
  ["2942", "\\ElzRlarr{}"],
  ["2944", "\\ElzrLarr{}"],
  ["2947", "\\Elzrarrx{}"],
  ["294e", "\\LeftRightVector{}"],
  ["294f", "\\RightUpDownVector{}"],
  ["2950", "\\DownLeftRightVector{}"],
  ["2951", "\\LeftUpDownVector{}"],
  ["2952", "\\LeftVectorBar{}"],
  ["2953", "\\RightVectorBar{}"],
  ["2954", "\\RightUpVectorBar{}"],
  ["2955", "\\RightDownVectorBar{}"],
  ["2956", "\\DownLeftVectorBar{}"],
  ["2957", "\\DownRightVectorBar{}"],
  ["2958", "\\LeftUpVectorBar{}"],
  ["2959", "\\LeftDownVectorBar{}"],
  ["295a", "\\LeftTeeVector{}"],
  ["295b", "\\RightTeeVector{}"],
  ["295c", "\\RightUpTeeVector{}"],
  ["295d", "\\RightDownTeeVector{}"],
  ["295e", "\\DownLeftTeeVector{}"],
  ["295f", "\\DownRightTeeVector{}"],
  ["2960", "\\LeftUpTeeVector{}"],
  ["2961", "\\LeftDownTeeVector{}"],
  ["296e", "\\UpEquilibrium{}"],
  ["296f", "\\ReverseUpEquilibrium{}"],
  ["2970", "\\RoundImplies{}"],
  ["297c", "\\ElsevierGlyph{E214}"],
  ["297d", "\\ElsevierGlyph{E215}"],
  ["2980", "\\Elztfnc{}"],
  ["2985", "\\ElsevierGlyph{3018}"],
  ["2986", "\\Elroang{}"],
  ["2993", "&lt;\\kern-0.58em("],
  ["2994", "\\ElsevierGlyph{E291}"],
  ["2999", "\\Elzddfnc{}"],
  ["299c", "\\Angle{}"],
  ["29a0", "\\Elzlpargt{}"],
  ["29b5", "\\ElsevierGlyph{E260}"],
  ["29b6", "\\ElsevierGlyph{E61B}"],
  ["29ca", "\\ElzLap{}"],
  ["29cb", "\\Elzdefas{}"],
  ["29cf", "\\LeftTriangleBar{}"],
  ["29d0", "\\RightTriangleBar{}"],
  ["29dc", "\\ElsevierGlyph{E372}"],
  ["29eb", "\\blacklozenge{}"],
  ["29f4", "\\RuleDelayed{}"],
  ["2a04", "\\Elxuplus{}"],
  ["2a05", "\\ElzThr{}"],
  ["2a06", "\\Elxsqcup{}"],
  ["2a07", "\\ElzInf{}"],
  ["2a08", "\\ElzSup{}"],
  ["2a0d", "\\ElzCint{}"],
  ["2a0f", "\\clockoint{}"],
  ["2a10", "\\ElsevierGlyph{E395}"],
  ["2a16", "\\sqrint{}"],
  ["2a25", "\\ElsevierGlyph{E25A}"],
  ["2a2a", "\\ElsevierGlyph{E25B}"],
  ["2a2d", "\\ElsevierGlyph{E25C}"],
  ["2a2e", "\\ElsevierGlyph{E25D}"],
  ["2a2f", "\\ElzTimes{}"],
  ["2a34", "\\ElsevierGlyph{E25E}"],
  ["2a35", "\\ElsevierGlyph{E25E}"],
  ["2a3c", "\\ElsevierGlyph{E259}"],
  ["2a3f", "\\amalg{}"],
  ["2a53", "\\ElzAnd{}"],
  ["2a54", "\\ElzOr{}"],
  ["2a55", "\\ElsevierGlyph{E36E}"],
  ["2a56", "\\ElOr{}"],
  ["2a5e", "\\perspcorrespond{}"],
  ["2a5f", "\\Elzminhat{}"],
  ["2a63", "\\ElsevierGlyph{225A}"],
  ["2a6e", "\\stackrel{*}{=}"],
  ["2a75", "\\Equal{}"],
  ["2a7d", "\\leqslant{}"],
  ["2a7e", "\\geqslant{}"],
  ["2a85", "\\lessapprox{}"],
  ["2a86", "\\gtrapprox{}"],
  ["2a87", "\\lneq{}"],
  ["2a88", "\\gneq{}"],
  ["2a89", "\\lnapprox{}"],
  ["2a8a", "\\gnapprox{}"],
  ["2a8b", "\\lesseqqgtr{}"],
  ["2a8c", "\\gtreqqless{}"],
  ["2a95", "\\eqslantless{}"],
  ["2a96", "\\eqslantgtr{}"],
  ["2a9d", "\\Pisymbol{ppi020}{117}"],
  ["2a9e", "\\Pisymbol{ppi020}{105}"],
  ["2aa1", "\\NestedLessLess{}"],
  ["2aa2", "\\NestedGreaterGreater{}"],
  ["2aaf", "\\preceq{}"],
  ["2ab0", "\\succeq{}"],
  ["2ab5", "\\precneqq{}"],
  ["2ab6", "\\succneqq{}"],
  ["2ab7", "\\precapprox{}"],
  ["2ab8", "\\succapprox{}"],
  ["2ab9", "\\precnapprox{}"],
  ["2aba", "\\succnapprox{}"],
  ["2ac5", "\\subseteqq{}"],
  ["2ac6", "\\supseteqq{}"],
  ["2acb", "\\subsetneqq{}"],
  ["2acc", "\\supsetneqq{}"],
  ["2aeb", "\\ElsevierGlyph{E30D}"],
  ["2af6", "\\Elztdcol{}"],
  ["2afd", "{{/}\\!\\!{/}}"],
  ["300a", "\\ElsevierGlyph{300A}"],
  ["300b", "\\ElsevierGlyph{300B}"],
  ["3018", "\\ElsevierGlyph{3018}"],
  ["3019", "\\ElsevierGlyph{3019}"],
  ["301a", "\\openbracketleft{}"],
  ["301b", "\\openbracketright{}"],
  ["fb00", "ff"],
  ["fb01", "fi"],
  ["fb02", "fl"],
  ["fb03", "ffi"],
  ["fb04", "ffl"],
  ["d400", "\\mathbf{A}"],
  ["d401", "\\mathbf{B}"],
  ["d402", "\\mathbf{C}"],
  ["d403", "\\mathbf{D}"],
  ["d404", "\\mathbf{E}"],
  ["d405", "\\mathbf{F}"],
  ["d406", "\\mathbf{G}"],
  ["d407", "\\mathbf{H}"],
  ["d408", "\\mathbf{I}"],
  ["d409", "\\mathbf{J}"],
  ["d40a", "\\mathbf{K}"],
  ["d40b", "\\mathbf{L}"],
  ["d40c", "\\mathbf{M}"],
  ["d40d", "\\mathbf{N}"],
  ["d40e", "\\mathbf{O}"],
  ["d40f", "\\mathbf{P}"],
  ["d410", "\\mathbf{Q}"],
  ["d411", "\\mathbf{R}"],
  ["d412", "\\mathbf{S}"],
  ["d413", "\\mathbf{T}"],
  ["d414", "\\mathbf{U}"],
  ["d415", "\\mathbf{V}"],
  ["d416", "\\mathbf{W}"],
  ["d417", "\\mathbf{X}"],
  ["d418", "\\mathbf{Y}"],
  ["d419", "\\mathbf{Z}"],
  ["d41a", "\\mathbf{a}"],
  ["d41b", "\\mathbf{b}"],
  ["d41c", "\\mathbf{c}"],
  ["d41d", "\\mathbf{d}"],
  ["d41e", "\\mathbf{e}"],
  ["d41f", "\\mathbf{f}"],
  ["d420", "\\mathbf{g}"],
  ["d421", "\\mathbf{h}"],
  ["d422", "\\mathbf{i}"],
  ["d423", "\\mathbf{j}"],
  ["d424", "\\mathbf{k}"],
  ["d425", "\\mathbf{l}"],
  ["d426", "\\mathbf{m}"],
  ["d427", "\\mathbf{n}"],
  ["d428", "\\mathbf{o}"],
  ["d429", "\\mathbf{p}"],
  ["d42a", "\\mathbf{q}"],
  ["d42b", "\\mathbf{r}"],
  ["d42c", "\\mathbf{s}"],
  ["d42d", "\\mathbf{t}"],
  ["d42e", "\\mathbf{u}"],
  ["d42f", "\\mathbf{v}"],
  ["d430", "\\mathbf{w}"],
  ["d431", "\\mathbf{x}"],
  ["d432", "\\mathbf{y}"],
  ["d433", "\\mathbf{z}"],
  ["d434", "\\mathsl{A}"],
  ["d435", "\\mathsl{B}"],
  ["d436", "\\mathsl{C}"],
  ["d437", "\\mathsl{D}"],
  ["d438", "\\mathsl{E}"],
  ["d439", "\\mathsl{F}"],
  ["d43a", "\\mathsl{G}"],
  ["d43b", "\\mathsl{H}"],
  ["d43c", "\\mathsl{I}"],
  ["d43d", "\\mathsl{J}"],
  ["d43e", "\\mathsl{K}"],
  ["d43f", "\\mathsl{L}"],
  ["d440", "\\mathsl{M}"],
  ["d441", "\\mathsl{N}"],
  ["d442", "\\mathsl{O}"],
  ["d443", "\\mathsl{P}"],
  ["d444", "\\mathsl{Q}"],
  ["d445", "\\mathsl{R}"],
  ["d446", "\\mathsl{S}"],
  ["d447", "\\mathsl{T}"],
  ["d448", "\\mathsl{U}"],
  ["d449", "\\mathsl{V}"],
  ["d44a", "\\mathsl{W}"],
  ["d44b", "\\mathsl{X}"],
  ["d44c", "\\mathsl{Y}"],
  ["d44d", "\\mathsl{Z}"],
  ["d44e", "\\mathsl{a}"],
  ["d44f", "\\mathsl{b}"],
  ["d450", "\\mathsl{c}"],
  ["d451", "\\mathsl{d}"],
  ["d452", "\\mathsl{e}"],
  ["d453", "\\mathsl{f}"],
  ["d454", "\\mathsl{g}"],
  ["d456", "\\mathsl{i}"],
  ["d457", "\\mathsl{j}"],
  ["d458", "\\mathsl{k}"],
  ["d459", "\\mathsl{l}"],
  ["d45a", "\\mathsl{m}"],
  ["d45b", "\\mathsl{n}"],
  ["d45c", "\\mathsl{o}"],
  ["d45d", "\\mathsl{p}"],
  ["d45e", "\\mathsl{q}"],
  ["d45f", "\\mathsl{r}"],
  ["d460", "\\mathsl{s}"],
  ["d461", "\\mathsl{t}"],
  ["d462", "\\mathsl{u}"],
  ["d463", "\\mathsl{v}"],
  ["d464", "\\mathsl{w}"],
  ["d465", "\\mathsl{x}"],
  ["d466", "\\mathsl{y}"],
  ["d467", "\\mathsl{z}"],
  ["d468", "\\mathbit{A}"],
  ["d469", "\\mathbit{B}"],
  ["d46a", "\\mathbit{C}"],
  ["d46b", "\\mathbit{D}"],
  ["d46c", "\\mathbit{E}"],
  ["d46d", "\\mathbit{F}"],
  ["d46e", "\\mathbit{G}"],
  ["d46f", "\\mathbit{H}"],
  ["d470", "\\mathbit{I}"],
  ["d471", "\\mathbit{J}"],
  ["d472", "\\mathbit{K}"],
  ["d473", "\\mathbit{L}"],
  ["d474", "\\mathbit{M}"],
  ["d475", "\\mathbit{N}"],
  ["d476", "\\mathbit{O}"],
  ["d477", "\\mathbit{P}"],
  ["d478", "\\mathbit{Q}"],
  ["d479", "\\mathbit{R}"],
  ["d47a", "\\mathbit{S}"],
  ["d47b", "\\mathbit{T}"],
  ["d47c", "\\mathbit{U}"],
  ["d47d", "\\mathbit{V}"],
  ["d47e", "\\mathbit{W}"],
  ["d47f", "\\mathbit{X}"],
  ["d480", "\\mathbit{Y}"],
  ["d481", "\\mathbit{Z}"],
  ["d482", "\\mathbit{a}"],
  ["d483", "\\mathbit{b}"],
  ["d484", "\\mathbit{c}"],
  ["d485", "\\mathbit{d}"],
  ["d486", "\\mathbit{e}"],
  ["d487", "\\mathbit{f}"],
  ["d488", "\\mathbit{g}"],
  ["d489", "\\mathbit{h}"],
  ["d48a", "\\mathbit{i}"],
  ["d48b", "\\mathbit{j}"],
  ["d48c", "\\mathbit{k}"],
  ["d48d", "\\mathbit{l}"],
  ["d48e", "\\mathbit{m}"],
  ["d48f", "\\mathbit{n}"],
  ["d490", "\\mathbit{o}"],
  ["d491", "\\mathbit{p}"],
  ["d492", "\\mathbit{q}"],
  ["d493", "\\mathbit{r}"],
  ["d494", "\\mathbit{s}"],
  ["d495", "\\mathbit{t}"],
  ["d496", "\\mathbit{u}"],
  ["d497", "\\mathbit{v}"],
  ["d498", "\\mathbit{w}"],
  ["d499", "\\mathbit{x}"],
  ["d49a", "\\mathbit{y}"],
  ["d49b", "\\mathbit{z}"],
  ["d49c", "\\mathscr{A}"],
  ["d49e", "\\mathscr{C}"],
  ["d49f", "\\mathscr{D}"],
  ["d4a2", "\\mathscr{G}"],
  ["d4a5", "\\mathscr{J}"],
  ["d4a6", "\\mathscr{K}"],
  ["d4a9", "\\mathscr{N}"],
  ["d4aa", "\\mathscr{O}"],
  ["d4ab", "\\mathscr{P}"],
  ["d4ac", "\\mathscr{Q}"],
  ["d4ae", "\\mathscr{S}"],
  ["d4af", "\\mathscr{T}"],
  ["d4b0", "\\mathscr{U}"],
  ["d4b1", "\\mathscr{V}"],
  ["d4b2", "\\mathscr{W}"],
  ["d4b3", "\\mathscr{X}"],
  ["d4b4", "\\mathscr{Y}"],
  ["d4b5", "\\mathscr{Z}"],
  ["d4b6", "\\mathscr{a}"],
  ["d4b7", "\\mathscr{b}"],
  ["d4b8", "\\mathscr{c}"],
  ["d4b9", "\\mathscr{d}"],
  ["d4bb", "\\mathscr{f}"],
  ["d4bd", "\\mathscr{h}"],
  ["d4be", "\\mathscr{i}"],
  ["d4bf", "\\mathscr{j}"],
  ["d4c0", "\\mathscr{k}"],
  ["d4c1", "\\mathscr{l}"],
  ["d4c2", "\\mathscr{m}"],
  ["d4c3", "\\mathscr{n}"],
  ["d4c5", "\\mathscr{p}"],
  ["d4c6", "\\mathscr{q}"],
  ["d4c7", "\\mathscr{r}"],
  ["d4c8", "\\mathscr{s}"],
  ["d4c9", "\\mathscr{t}"],
  ["d4ca", "\\mathscr{u}"],
  ["d4cb", "\\mathscr{v}"],
  ["d4cc", "\\mathscr{w}"],
  ["d4cd", "\\mathscr{x}"],
  ["d4ce", "\\mathscr{y}"],
  ["d4cf", "\\mathscr{z}"],
  ["d4d0", "\\mathmit{A}"],
  ["d4d1", "\\mathmit{B}"],
  ["d4d2", "\\mathmit{C}"],
  ["d4d3", "\\mathmit{D}"],
  ["d4d4", "\\mathmit{E}"],
  ["d4d5", "\\mathmit{F}"],
  ["d4d6", "\\mathmit{G}"],
  ["d4d7", "\\mathmit{H}"],
  ["d4d8", "\\mathmit{I}"],
  ["d4d9", "\\mathmit{J}"],
  ["d4da", "\\mathmit{K}"],
  ["d4db", "\\mathmit{L}"],
  ["d4dc", "\\mathmit{M}"],
  ["d4dd", "\\mathmit{N}"],
  ["d4de", "\\mathmit{O}"],
  ["d4df", "\\mathmit{P}"],
  ["d4e0", "\\mathmit{Q}"],
  ["d4e1", "\\mathmit{R}"],
  ["d4e2", "\\mathmit{S}"],
  ["d4e3", "\\mathmit{T}"],
  ["d4e4", "\\mathmit{U}"],
  ["d4e5", "\\mathmit{V}"],
  ["d4e6", "\\mathmit{W}"],
  ["d4e7", "\\mathmit{X}"],
  ["d4e8", "\\mathmit{Y}"],
  ["d4e9", "\\mathmit{Z}"],
  ["d4ea", "\\mathmit{a}"],
  ["d4eb", "\\mathmit{b}"],
  ["d4ec", "\\mathmit{c}"],
  ["d4ed", "\\mathmit{d}"],
  ["d4ee", "\\mathmit{e}"],
  ["d4ef", "\\mathmit{f}"],
  ["d4f0", "\\mathmit{g}"],
  ["d4f1", "\\mathmit{h}"],
  ["d4f2", "\\mathmit{i}"],
  ["d4f3", "\\mathmit{j}"],
  ["d4f4", "\\mathmit{k}"],
  ["d4f5", "\\mathmit{l}"],
  ["d4f6", "\\mathmit{m}"],
  ["d4f7", "\\mathmit{n}"],
  ["d4f8", "\\mathmit{o}"],
  ["d4f9", "\\mathmit{p}"],
  ["d4fa", "\\mathmit{q}"],
  ["d4fb", "\\mathmit{r}"],
  ["d4fc", "\\mathmit{s}"],
  ["d4fd", "\\mathmit{t}"],
  ["d4fe", "\\mathmit{u}"],
  ["d4ff", "\\mathmit{v}"],
  ["d500", "\\mathmit{w}"],
  ["d501", "\\mathmit{x}"],
  ["d502", "\\mathmit{y}"],
  ["d503", "\\mathmit{z}"],
  ["d504", "\\mathfrak{A}"],
  ["d505", "\\mathfrak{B}"],
  ["d507", "\\mathfrak{D}"],
  ["d508", "\\mathfrak{E}"],
  ["d509", "\\mathfrak{F}"],
  ["d50a", "\\mathfrak{G}"],
  ["d50d", "\\mathfrak{J}"],
  ["d50e", "\\mathfrak{K}"],
  ["d50f", "\\mathfrak{L}"],
  ["d510", "\\mathfrak{M}"],
  ["d511", "\\mathfrak{N}"],
  ["d512", "\\mathfrak{O}"],
  ["d513", "\\mathfrak{P}"],
  ["d514", "\\mathfrak{Q}"],
  ["d516", "\\mathfrak{S}"],
  ["d517", "\\mathfrak{T}"],
  ["d518", "\\mathfrak{U}"],
  ["d519", "\\mathfrak{V}"],
  ["d51a", "\\mathfrak{W}"],
  ["d51b", "\\mathfrak{X}"],
  ["d51c", "\\mathfrak{Y}"],
  ["d51e", "\\mathfrak{a}"],
  ["d51f", "\\mathfrak{b}"],
  ["d520", "\\mathfrak{c}"],
  ["d521", "\\mathfrak{d}"],
  ["d522", "\\mathfrak{e}"],
  ["d523", "\\mathfrak{f}"],
  ["d524", "\\mathfrak{g}"],
  ["d525", "\\mathfrak{h}"],
  ["d526", "\\mathfrak{i}"],
  ["d527", "\\mathfrak{j}"],
  ["d528", "\\mathfrak{k}"],
  ["d529", "\\mathfrak{l}"],
  ["d52a", "\\mathfrak{m}"],
  ["d52b", "\\mathfrak{n}"],
  ["d52c", "\\mathfrak{o}"],
  ["d52d", "\\mathfrak{p}"],
  ["d52e", "\\mathfrak{q}"],
  ["d52f", "\\mathfrak{r}"],
  ["d530", "\\mathfrak{s}"],
  ["d531", "\\mathfrak{t}"],
  ["d532", "\\mathfrak{u}"],
  ["d533", "\\mathfrak{v}"],
  ["d534", "\\mathfrak{w}"],
  ["d535", "\\mathfrak{x}"],
  ["d536", "\\mathfrak{y}"],
  ["d537", "\\mathfrak{z}"],
  ["d538", "\\mathbb{A}"],
  ["d539", "\\mathbb{B}"],
  ["d53b", "\\mathbb{D}"],
  ["d53c", "\\mathbb{E}"],
  ["d53d", "\\mathbb{F}"],
  ["d53e", "\\mathbb{G}"],
  ["d540", "\\mathbb{I}"],
  ["d541", "\\mathbb{J}"],
  ["d542", "\\mathbb{K}"],
  ["d543", "\\mathbb{L}"],
  ["d544", "\\mathbb{M}"],
  ["d546", "\\mathbb{O}"],
  ["d54a", "\\mathbb{S}"],
  ["d54b", "\\mathbb{T}"],
  ["d54c", "\\mathbb{U}"],
  ["d54d", "\\mathbb{V}"],
  ["d54e", "\\mathbb{W}"],
  ["d54f", "\\mathbb{X}"],
  ["d550", "\\mathbb{Y}"],
  ["d552", "\\mathbb{a}"],
  ["d553", "\\mathbb{b}"],
  ["d554", "\\mathbb{c}"],
  ["d555", "\\mathbb{d}"],
  ["d556", "\\mathbb{e}"],
  ["d557", "\\mathbb{f}"],
  ["d558", "\\mathbb{g}"],
  ["d559", "\\mathbb{h}"],
  ["d55a", "\\mathbb{i}"],
  ["d55b", "\\mathbb{j}"],
  ["d55c", "\\mathbb{k}"],
  ["d55d", "\\mathbb{l}"],
  ["d55e", "\\mathbb{m}"],
  ["d55f", "\\mathbb{n}"],
  ["d560", "\\mathbb{o}"],
  ["d561", "\\mathbb{p}"],
  ["d562", "\\mathbb{q}"],
  ["d563", "\\mathbb{r}"],
  ["d564", "\\mathbb{s}"],
  ["d565", "\\mathbb{t}"],
  ["d566", "\\mathbb{u}"],
  ["d567", "\\mathbb{v}"],
  ["d568", "\\mathbb{w}"],
  ["d569", "\\mathbb{x}"],
  ["d56a", "\\mathbb{y}"],
  ["d56b", "\\mathbb{z}"],
  ["d56c", "\\mathslbb{A}"],
  ["d56d", "\\mathslbb{B}"],
  ["d56e", "\\mathslbb{C}"],
  ["d56f", "\\mathslbb{D}"],
  ["d570", "\\mathslbb{E}"],
  ["d571", "\\mathslbb{F}"],
  ["d572", "\\mathslbb{G}"],
  ["d573", "\\mathslbb{H}"],
  ["d574", "\\mathslbb{I}"],
  ["d575", "\\mathslbb{J}"],
  ["d576", "\\mathslbb{K}"],
  ["d577", "\\mathslbb{L}"],
  ["d578", "\\mathslbb{M}"],
  ["d579", "\\mathslbb{N}"],
  ["d57a", "\\mathslbb{O}"],
  ["d57b", "\\mathslbb{P}"],
  ["d57c", "\\mathslbb{Q}"],
  ["d57d", "\\mathslbb{R}"],
  ["d57e", "\\mathslbb{S}"],
  ["d57f", "\\mathslbb{T}"],
  ["d580", "\\mathslbb{U}"],
  ["d581", "\\mathslbb{V}"],
  ["d582", "\\mathslbb{W}"],
  ["d583", "\\mathslbb{X}"],
  ["d584", "\\mathslbb{Y}"],
  ["d585", "\\mathslbb{Z}"],
  ["d586", "\\mathslbb{a}"],
  ["d587", "\\mathslbb{b}"],
  ["d588", "\\mathslbb{c}"],
  ["d589", "\\mathslbb{d}"],
  ["d58a", "\\mathslbb{e}"],
  ["d58b", "\\mathslbb{f}"],
  ["d58c", "\\mathslbb{g}"],
  ["d58d", "\\mathslbb{h}"],
  ["d58e", "\\mathslbb{i}"],
  ["d58f", "\\mathslbb{j}"],
  ["d590", "\\mathslbb{k}"],
  ["d591", "\\mathslbb{l}"],
  ["d592", "\\mathslbb{m}"],
  ["d593", "\\mathslbb{n}"],
  ["d594", "\\mathslbb{o}"],
  ["d595", "\\mathslbb{p}"],
  ["d596", "\\mathslbb{q}"],
  ["d597", "\\mathslbb{r}"],
  ["d598", "\\mathslbb{s}"],
  ["d599", "\\mathslbb{t}"],
  ["d59a", "\\mathslbb{u}"],
  ["d59b", "\\mathslbb{v}"],
  ["d59c", "\\mathslbb{w}"],
  ["d59d", "\\mathslbb{x}"],
  ["d59e", "\\mathslbb{y}"],
  ["d59f", "\\mathslbb{z}"],
  ["d5a0", "\\mathsf{A}"],
  ["d5a1", "\\mathsf{B}"],
  ["d5a2", "\\mathsf{C}"],
  ["d5a3", "\\mathsf{D}"],
  ["d5a4", "\\mathsf{E}"],
  ["d5a5", "\\mathsf{F}"],
  ["d5a6", "\\mathsf{G}"],
  ["d5a7", "\\mathsf{H}"],
  ["d5a8", "\\mathsf{I}"],
  ["d5a9", "\\mathsf{J}"],
  ["d5aa", "\\mathsf{K}"],
  ["d5ab", "\\mathsf{L}"],
  ["d5ac", "\\mathsf{M}"],
  ["d5ad", "\\mathsf{N}"],
  ["d5ae", "\\mathsf{O}"],
  ["d5af", "\\mathsf{P}"],
  ["d5b0", "\\mathsf{Q}"],
  ["d5b1", "\\mathsf{R}"],
  ["d5b2", "\\mathsf{S}"],
  ["d5b3", "\\mathsf{T}"],
  ["d5b4", "\\mathsf{U}"],
  ["d5b5", "\\mathsf{V}"],
  ["d5b6", "\\mathsf{W}"],
  ["d5b7", "\\mathsf{X}"],
  ["d5b8", "\\mathsf{Y}"],
  ["d5b9", "\\mathsf{Z}"],
  ["d5ba", "\\mathsf{a}"],
  ["d5bb", "\\mathsf{b}"],
  ["d5bc", "\\mathsf{c}"],
  ["d5bd", "\\mathsf{d}"],
  ["d5be", "\\mathsf{e}"],
  ["d5bf", "\\mathsf{f}"],
  ["d5c0", "\\mathsf{g}"],
  ["d5c1", "\\mathsf{h}"],
  ["d5c2", "\\mathsf{i}"],
  ["d5c3", "\\mathsf{j}"],
  ["d5c4", "\\mathsf{k}"],
  ["d5c5", "\\mathsf{l}"],
  ["d5c6", "\\mathsf{m}"],
  ["d5c7", "\\mathsf{n}"],
  ["d5c8", "\\mathsf{o}"],
  ["d5c9", "\\mathsf{p}"],
  ["d5ca", "\\mathsf{q}"],
  ["d5cb", "\\mathsf{r}"],
  ["d5cc", "\\mathsf{s}"],
  ["d5cd", "\\mathsf{t}"],
  ["d5ce", "\\mathsf{u}"],
  ["d5cf", "\\mathsf{v}"],
  ["d5d0", "\\mathsf{w}"],
  ["d5d1", "\\mathsf{x}"],
  ["d5d2", "\\mathsf{y}"],
  ["d5d3", "\\mathsf{z}"],
  ["d5d4", "\\mathsfbf{A}"],
  ["d5d5", "\\mathsfbf{B}"],
  ["d5d6", "\\mathsfbf{C}"],
  ["d5d7", "\\mathsfbf{D}"],
  ["d5d8", "\\mathsfbf{E}"],
  ["d5d9", "\\mathsfbf{F}"],
  ["d5da", "\\mathsfbf{G}"],
  ["d5db", "\\mathsfbf{H}"],
  ["d5dc", "\\mathsfbf{I}"],
  ["d5dd", "\\mathsfbf{J}"],
  ["d5de", "\\mathsfbf{K}"],
  ["d5df", "\\mathsfbf{L}"],
  ["d5e0", "\\mathsfbf{M}"],
  ["d5e1", "\\mathsfbf{N}"],
  ["d5e2", "\\mathsfbf{O}"],
  ["d5e3", "\\mathsfbf{P}"],
  ["d5e4", "\\mathsfbf{Q}"],
  ["d5e5", "\\mathsfbf{R}"],
  ["d5e6", "\\mathsfbf{S}"],
  ["d5e7", "\\mathsfbf{T}"],
  ["d5e8", "\\mathsfbf{U}"],
  ["d5e9", "\\mathsfbf{V}"],
  ["d5ea", "\\mathsfbf{W}"],
  ["d5eb", "\\mathsfbf{X}"],
  ["d5ec", "\\mathsfbf{Y}"],
  ["d5ed", "\\mathsfbf{Z}"],
  ["d5ee", "\\mathsfbf{a}"],
  ["d5ef", "\\mathsfbf{b}"],
  ["d5f0", "\\mathsfbf{c}"],
  ["d5f1", "\\mathsfbf{d}"],
  ["d5f2", "\\mathsfbf{e}"],
  ["d5f3", "\\mathsfbf{f}"],
  ["d5f4", "\\mathsfbf{g}"],
  ["d5f5", "\\mathsfbf{h}"],
  ["d5f6", "\\mathsfbf{i}"],
  ["d5f7", "\\mathsfbf{j}"],
  ["d5f8", "\\mathsfbf{k}"],
  ["d5f9", "\\mathsfbf{l}"],
  ["d5fa", "\\mathsfbf{m}"],
  ["d5fb", "\\mathsfbf{n}"],
  ["d5fc", "\\mathsfbf{o}"],
  ["d5fd", "\\mathsfbf{p}"],
  ["d5fe", "\\mathsfbf{q}"],
  ["d5ff", "\\mathsfbf{r}"],
  ["d600", "\\mathsfbf{s}"],
  ["d601", "\\mathsfbf{t}"],
  ["d602", "\\mathsfbf{u}"],
  ["d603", "\\mathsfbf{v}"],
  ["d604", "\\mathsfbf{w}"],
  ["d605", "\\mathsfbf{x}"],
  ["d606", "\\mathsfbf{y}"],
  ["d607", "\\mathsfbf{z}"],
  ["d608", "\\mathsfsl{A}"],
  ["d609", "\\mathsfsl{B}"],
  ["d60a", "\\mathsfsl{C}"],
  ["d60b", "\\mathsfsl{D}"],
  ["d60c", "\\mathsfsl{E}"],
  ["d60d", "\\mathsfsl{F}"],
  ["d60e", "\\mathsfsl{G}"],
  ["d60f", "\\mathsfsl{H}"],
  ["d610", "\\mathsfsl{I}"],
  ["d611", "\\mathsfsl{J}"],
  ["d612", "\\mathsfsl{K}"],
  ["d613", "\\mathsfsl{L}"],
  ["d614", "\\mathsfsl{M}"],
  ["d615", "\\mathsfsl{N}"],
  ["d616", "\\mathsfsl{O}"],
  ["d617", "\\mathsfsl{P}"],
  ["d618", "\\mathsfsl{Q}"],
  ["d619", "\\mathsfsl{R}"],
  ["d61a", "\\mathsfsl{S}"],
  ["d61b", "\\mathsfsl{T}"],
  ["d61c", "\\mathsfsl{U}"],
  ["d61d", "\\mathsfsl{V}"],
  ["d61e", "\\mathsfsl{W}"],
  ["d61f", "\\mathsfsl{X}"],
  ["d620", "\\mathsfsl{Y}"],
  ["d621", "\\mathsfsl{Z}"],
  ["d622", "\\mathsfsl{a}"],
  ["d623", "\\mathsfsl{b}"],
  ["d624", "\\mathsfsl{c}"],
  ["d625", "\\mathsfsl{d}"],
  ["d626", "\\mathsfsl{e}"],
  ["d627", "\\mathsfsl{f}"],
  ["d628", "\\mathsfsl{g}"],
  ["d629", "\\mathsfsl{h}"],
  ["d62a", "\\mathsfsl{i}"],
  ["d62b", "\\mathsfsl{j}"],
  ["d62c", "\\mathsfsl{k}"],
  ["d62d", "\\mathsfsl{l}"],
  ["d62e", "\\mathsfsl{m}"],
  ["d62f", "\\mathsfsl{n}"],
  ["d630", "\\mathsfsl{o}"],
  ["d631", "\\mathsfsl{p}"],
  ["d632", "\\mathsfsl{q}"],
  ["d633", "\\mathsfsl{r}"],
  ["d634", "\\mathsfsl{s}"],
  ["d635", "\\mathsfsl{t}"],
  ["d636", "\\mathsfsl{u}"],
  ["d637", "\\mathsfsl{v}"],
  ["d638", "\\mathsfsl{w}"],
  ["d639", "\\mathsfsl{x}"],
  ["d63a", "\\mathsfsl{y}"],
  ["d63b", "\\mathsfsl{z}"],
  ["d63c", "\\mathsfbfsl{A}"],
  ["d63d", "\\mathsfbfsl{B}"],
  ["d63e", "\\mathsfbfsl{C}"],
  ["d63f", "\\mathsfbfsl{D}"],
  ["d640", "\\mathsfbfsl{E}"],
  ["d641", "\\mathsfbfsl{F}"],
  ["d642", "\\mathsfbfsl{G}"],
  ["d643", "\\mathsfbfsl{H}"],
  ["d644", "\\mathsfbfsl{I}"],
  ["d645", "\\mathsfbfsl{J}"],
  ["d646", "\\mathsfbfsl{K}"],
  ["d647", "\\mathsfbfsl{L}"],
  ["d648", "\\mathsfbfsl{M}"],
  ["d649", "\\mathsfbfsl{N}"],
  ["d64a", "\\mathsfbfsl{O}"],
  ["d64b", "\\mathsfbfsl{P}"],
  ["d64c", "\\mathsfbfsl{Q}"],
  ["d64d", "\\mathsfbfsl{R}"],
  ["d64e", "\\mathsfbfsl{S}"],
  ["d64f", "\\mathsfbfsl{T}"],
  ["d650", "\\mathsfbfsl{U}"],
  ["d651", "\\mathsfbfsl{V}"],
  ["d652", "\\mathsfbfsl{W}"],
  ["d653", "\\mathsfbfsl{X}"],
  ["d654", "\\mathsfbfsl{Y}"],
  ["d655", "\\mathsfbfsl{Z}"],
  ["d656", "\\mathsfbfsl{a}"],
  ["d657", "\\mathsfbfsl{b}"],
  ["d658", "\\mathsfbfsl{c}"],
  ["d659", "\\mathsfbfsl{d}"],
  ["d65a", "\\mathsfbfsl{e}"],
  ["d65b", "\\mathsfbfsl{f}"],
  ["d65c", "\\mathsfbfsl{g}"],
  ["d65d", "\\mathsfbfsl{h}"],
  ["d65e", "\\mathsfbfsl{i}"],
  ["d65f", "\\mathsfbfsl{j}"],
  ["d660", "\\mathsfbfsl{k}"],
  ["d661", "\\mathsfbfsl{l}"],
  ["d662", "\\mathsfbfsl{m}"],
  ["d663", "\\mathsfbfsl{n}"],
  ["d664", "\\mathsfbfsl{o}"],
  ["d665", "\\mathsfbfsl{p}"],
  ["d666", "\\mathsfbfsl{q}"],
  ["d667", "\\mathsfbfsl{r}"],
  ["d668", "\\mathsfbfsl{s}"],
  ["d669", "\\mathsfbfsl{t}"],
  ["d66a", "\\mathsfbfsl{u}"],
  ["d66b", "\\mathsfbfsl{v}"],
  ["d66c", "\\mathsfbfsl{w}"],
  ["d66d", "\\mathsfbfsl{x}"],
  ["d66e", "\\mathsfbfsl{y}"],
  ["d66f", "\\mathsfbfsl{z}"],
  ["d670", "\\mathtt{A}"],
  ["d671", "\\mathtt{B}"],
  ["d672", "\\mathtt{C}"],
  ["d673", "\\mathtt{D}"],
  ["d674", "\\mathtt{E}"],
  ["d675", "\\mathtt{F}"],
  ["d676", "\\mathtt{G}"],
  ["d677", "\\mathtt{H}"],
  ["d678", "\\mathtt{I}"],
  ["d679", "\\mathtt{J}"],
  ["d67a", "\\mathtt{K}"],
  ["d67b", "\\mathtt{L}"],
  ["d67c", "\\mathtt{M}"],
  ["d67d", "\\mathtt{N}"],
  ["d67e", "\\mathtt{O}"],
  ["d67f", "\\mathtt{P}"],
  ["d680", "\\mathtt{Q}"],
  ["d681", "\\mathtt{R}"],
  ["d682", "\\mathtt{S}"],
  ["d683", "\\mathtt{T}"],
  ["d684", "\\mathtt{U}"],
  ["d685", "\\mathtt{V}"],
  ["d686", "\\mathtt{W}"],
  ["d687", "\\mathtt{X}"],
  ["d688", "\\mathtt{Y}"],
  ["d689", "\\mathtt{Z}"],
  ["d68a", "\\mathtt{a}"],
  ["d68b", "\\mathtt{b}"],
  ["d68c", "\\mathtt{c}"],
  ["d68d", "\\mathtt{d}"],
  ["d68e", "\\mathtt{e}"],
  ["d68f", "\\mathtt{f}"],
  ["d690", "\\mathtt{g}"],
  ["d691", "\\mathtt{h}"],
  ["d692", "\\mathtt{i}"],
  ["d693", "\\mathtt{j}"],
  ["d694", "\\mathtt{k}"],
  ["d695", "\\mathtt{l}"],
  ["d696", "\\mathtt{m}"],
  ["d697", "\\mathtt{n}"],
  ["d698", "\\mathtt{o}"],
  ["d699", "\\mathtt{p}"],
  ["d69a", "\\mathtt{q}"],
  ["d69b", "\\mathtt{r}"],
  ["d69c", "\\mathtt{s}"],
  ["d69d", "\\mathtt{t}"],
  ["d69e", "\\mathtt{u}"],
  ["d69f", "\\mathtt{v}"],
  ["d6a0", "\\mathtt{w}"],
  ["d6a1", "\\mathtt{x}"],
  ["d6a2", "\\mathtt{y}"],
  ["d6a3", "\\mathtt{z}"],
  ["d6a8", "\\mathbf{\\Alpha}"],
  ["d6a9", "\\mathbf{\\Beta}"],
  ["d6aa", "\\mathbf{\\Gamma}"],
  ["d6ab", "\\mathbf{\\Delta}"],
  ["d6ac", "\\mathbf{\\Epsilon}"],
  ["d6ad", "\\mathbf{\\Zeta}"],
  ["d6ae", "\\mathbf{\\Eta}"],
  ["d6af", "\\mathbf{\\Theta}"],
  ["d6b0", "\\mathbf{\\Iota}"],
  ["d6b1", "\\mathbf{\\Kappa}"],
  ["d6b2", "\\mathbf{\\Lambda}"],
  ["d6b5", "\\mathbf{\\Xi}"],
  ["d6b7", "\\mathbf{\\Pi}"],
  ["d6b8", "\\mathbf{\\Rho}"],
  ["d6b9", "\\mathbf{\\vartheta}"],
  ["d6ba", "\\mathbf{\\Sigma}"],
  ["d6bb", "\\mathbf{\\Tau}"],
  ["d6bc", "\\mathbf{\\Upsilon}"],
  ["d6bd", "\\mathbf{\\Phi}"],
  ["d6be", "\\mathbf{\\Chi}"],
  ["d6bf", "\\mathbf{\\Psi}"],
  ["d6c0", "\\mathbf{\\Omega}"],
  ["d6c1", "\\mathbf{\\nabla}"],
  ["d6c2", "\\mathbf{\\Alpha}"],
  ["d6c3", "\\mathbf{\\Beta}"],
  ["d6c4", "\\mathbf{\\Gamma}"],
  ["d6c5", "\\mathbf{\\Delta}"],
  ["d6c6", "\\mathbf{\\Epsilon}"],
  ["d6c7", "\\mathbf{\\Zeta}"],
  ["d6c8", "\\mathbf{\\Eta}"],
  ["d6c9", "\\mathbf{\\theta}"],
  ["d6ca", "\\mathbf{\\Iota}"],
  ["d6cb", "\\mathbf{\\Kappa}"],
  ["d6cc", "\\mathbf{\\Lambda}"],
  ["d6cf", "\\mathbf{\\Xi}"],
  ["d6d1", "\\mathbf{\\Pi}"],
  ["d6d2", "\\mathbf{\\Rho}"],
  ["d6d3", "\\mathbf{\\varsigma}"],
  ["d6d4", "\\mathbf{\\Sigma}"],
  ["d6d5", "\\mathbf{\\Tau}"],
  ["d6d6", "\\mathbf{\\Upsilon}"],
  ["d6d7", "\\mathbf{\\Phi}"],
  ["d6d8", "\\mathbf{\\Chi}"],
  ["d6d9", "\\mathbf{\\Psi}"],
  ["d6da", "\\mathbf{\\Omega}"],
  ["d6db", "\\partial{}"],
  ["d6dc", "\\in"],
  ["d6dd", "\\mathbf{\\vartheta}"],
  ["d6de", "\\mathbf{\\varkappa}"],
  ["d6df", "\\mathbf{\\phi}"],
  ["d6e0", "\\mathbf{\\varrho}"],
  ["d6e1", "\\mathbf{\\varpi}"],
  ["d6e2", "\\mathsl{\\Alpha}"],
  ["d6e3", "\\mathsl{\\Beta}"],
  ["d6e4", "\\mathsl{\\Gamma}"],
  ["d6e5", "\\mathsl{\\Delta}"],
  ["d6e6", "\\mathsl{\\Epsilon}"],
  ["d6e7", "\\mathsl{\\Zeta}"],
  ["d6e8", "\\mathsl{\\Eta}"],
  ["d6e9", "\\mathsl{\\Theta}"],
  ["d6ea", "\\mathsl{\\Iota}"],
  ["d6eb", "\\mathsl{\\Kappa}"],
  ["d6ec", "\\mathsl{\\Lambda}"],
  ["d6ef", "\\mathsl{\\Xi}"],
  ["d6f1", "\\mathsl{\\Pi}"],
  ["d6f2", "\\mathsl{\\Rho}"],
  ["d6f3", "\\mathsl{\\vartheta}"],
  ["d6f4", "\\mathsl{\\Sigma}"],
  ["d6f5", "\\mathsl{\\Tau}"],
  ["d6f6", "\\mathsl{\\Upsilon}"],
  ["d6f7", "\\mathsl{\\Phi}"],
  ["d6f8", "\\mathsl{\\Chi}"],
  ["d6f9", "\\mathsl{\\Psi}"],
  ["d6fa", "\\mathsl{\\Omega}"],
  ["d6fb", "\\mathsl{\\nabla}"],
  ["d6fc", "\\mathsl{\\Alpha}"],
  ["d6fd", "\\mathsl{\\Beta}"],
  ["d6fe", "\\mathsl{\\Gamma}"],
  ["d6ff", "\\mathsl{\\Delta}"],
  ["d700", "\\mathsl{\\Epsilon}"],
  ["d701", "\\mathsl{\\Zeta}"],
  ["d702", "\\mathsl{\\Eta}"],
  ["d703", "\\mathsl{\\Theta}"],
  ["d704", "\\mathsl{\\Iota}"],
  ["d705", "\\mathsl{\\Kappa}"],
  ["d706", "\\mathsl{\\Lambda}"],
  ["d709", "\\mathsl{\\Xi}"],
  ["d70b", "\\mathsl{\\Pi}"],
  ["d70c", "\\mathsl{\\Rho}"],
  ["d70d", "\\mathsl{\\varsigma}"],
  ["d70e", "\\mathsl{\\Sigma}"],
  ["d70f", "\\mathsl{\\Tau}"],
  ["d710", "\\mathsl{\\Upsilon}"],
  ["d711", "\\mathsl{\\Phi}"],
  ["d712", "\\mathsl{\\Chi}"],
  ["d713", "\\mathsl{\\Psi}"],
  ["d714", "\\mathsl{\\Omega}"],
  ["d715", "\\partial{}"],
  ["d716", "\\in"],
  ["d717", "\\mathsl{\\vartheta}"],
  ["d718", "\\mathsl{\\varkappa}"],
  ["d719", "\\mathsl{\\phi}"],
  ["d71a", "\\mathsl{\\varrho}"],
  ["d71b", "\\mathsl{\\varpi}"],
  ["d71c", "\\mathbit{\\Alpha}"],
  ["d71d", "\\mathbit{\\Beta}"],
  ["d71e", "\\mathbit{\\Gamma}"],
  ["d71f", "\\mathbit{\\Delta}"],
  ["d720", "\\mathbit{\\Epsilon}"],
  ["d721", "\\mathbit{\\Zeta}"],
  ["d722", "\\mathbit{\\Eta}"],
  ["d723", "\\mathbit{\\Theta}"],
  ["d724", "\\mathbit{\\Iota}"],
  ["d725", "\\mathbit{\\Kappa}"],
  ["d726", "\\mathbit{\\Lambda}"],
  ["d729", "\\mathbit{\\Xi}"],
  ["d72b", "\\mathbit{\\Pi}"],
  ["d72c", "\\mathbit{\\Rho}"],
  ["d72d", "\\mathbit{O}"],
  ["d72e", "\\mathbit{\\Sigma}"],
  ["d72f", "\\mathbit{\\Tau}"],
  ["d730", "\\mathbit{\\Upsilon}"],
  ["d731", "\\mathbit{\\Phi}"],
  ["d732", "\\mathbit{\\Chi}"],
  ["d733", "\\mathbit{\\Psi}"],
  ["d734", "\\mathbit{\\Omega}"],
  ["d735", "\\mathbit{\\nabla}"],
  ["d736", "\\mathbit{\\Alpha}"],
  ["d737", "\\mathbit{\\Beta}"],
  ["d738", "\\mathbit{\\Gamma}"],
  ["d739", "\\mathbit{\\Delta}"],
  ["d73a", "\\mathbit{\\Epsilon}"],
  ["d73b", "\\mathbit{\\Zeta}"],
  ["d73c", "\\mathbit{\\Eta}"],
  ["d73d", "\\mathbit{\\Theta}"],
  ["d73e", "\\mathbit{\\Iota}"],
  ["d73f", "\\mathbit{\\Kappa}"],
  ["d740", "\\mathbit{\\Lambda}"],
  ["d743", "\\mathbit{\\Xi}"],
  ["d745", "\\mathbit{\\Pi}"],
  ["d746", "\\mathbit{\\Rho}"],
  ["d747", "\\mathbit{\\varsigma}"],
  ["d748", "\\mathbit{\\Sigma}"],
  ["d749", "\\mathbit{\\Tau}"],
  ["d74a", "\\mathbit{\\Upsilon}"],
  ["d74b", "\\mathbit{\\Phi}"],
  ["d74c", "\\mathbit{\\Chi}"],
  ["d74d", "\\mathbit{\\Psi}"],
  ["d74e", "\\mathbit{\\Omega}"],
  ["d74f", "\\partial{}"],
  ["d750", "\\in"],
  ["d751", "\\mathbit{\\vartheta}"],
  ["d752", "\\mathbit{\\varkappa}"],
  ["d753", "\\mathbit{\\phi}"],
  ["d754", "\\mathbit{\\varrho}"],
  ["d755", "\\mathbit{\\varpi}"],
  ["d756", "\\mathsfbf{\\Alpha}"],
  ["d757", "\\mathsfbf{\\Beta}"],
  ["d758", "\\mathsfbf{\\Gamma}"],
  ["d759", "\\mathsfbf{\\Delta}"],
  ["d75a", "\\mathsfbf{\\Epsilon}"],
  ["d75b", "\\mathsfbf{\\Zeta}"],
  ["d75c", "\\mathsfbf{\\Eta}"],
  ["d75d", "\\mathsfbf{\\Theta}"],
  ["d75e", "\\mathsfbf{\\Iota}"],
  ["d75f", "\\mathsfbf{\\Kappa}"],
  ["d760", "\\mathsfbf{\\Lambda}"],
  ["d763", "\\mathsfbf{\\Xi}"],
  ["d765", "\\mathsfbf{\\Pi}"],
  ["d766", "\\mathsfbf{\\Rho}"],
  ["d767", "\\mathsfbf{\\vartheta}"],
  ["d768", "\\mathsfbf{\\Sigma}"],
  ["d769", "\\mathsfbf{\\Tau}"],
  ["d76a", "\\mathsfbf{\\Upsilon}"],
  ["d76b", "\\mathsfbf{\\Phi}"],
  ["d76c", "\\mathsfbf{\\Chi}"],
  ["d76d", "\\mathsfbf{\\Psi}"],
  ["d76e", "\\mathsfbf{\\Omega}"],
  ["d76f", "\\mathsfbf{\\nabla}"],
  ["d770", "\\mathsfbf{\\Alpha}"],
  ["d771", "\\mathsfbf{\\Beta}"],
  ["d772", "\\mathsfbf{\\Gamma}"],
  ["d773", "\\mathsfbf{\\Delta}"],
  ["d774", "\\mathsfbf{\\Epsilon}"],
  ["d775", "\\mathsfbf{\\Zeta}"],
  ["d776", "\\mathsfbf{\\Eta}"],
  ["d777", "\\mathsfbf{\\Theta}"],
  ["d778", "\\mathsfbf{\\Iota}"],
  ["d779", "\\mathsfbf{\\Kappa}"],
  ["d77a", "\\mathsfbf{\\Lambda}"],
  ["d77d", "\\mathsfbf{\\Xi}"],
  ["d77f", "\\mathsfbf{\\Pi}"],
  ["d780", "\\mathsfbf{\\Rho}"],
  ["d781", "\\mathsfbf{\\varsigma}"],
  ["d782", "\\mathsfbf{\\Sigma}"],
  ["d783", "\\mathsfbf{\\Tau}"],
  ["d784", "\\mathsfbf{\\Upsilon}"],
  ["d785", "\\mathsfbf{\\Phi}"],
  ["d786", "\\mathsfbf{\\Chi}"],
  ["d787", "\\mathsfbf{\\Psi}"],
  ["d788", "\\mathsfbf{\\Omega}"],
  ["d789", "\\partial{}"],
  ["d78a", "\\in"],
  ["d78b", "\\mathsfbf{\\vartheta}"],
  ["d78c", "\\mathsfbf{\\varkappa}"],
  ["d78d", "\\mathsfbf{\\phi}"],
  ["d78e", "\\mathsfbf{\\varrho}"],
  ["d78f", "\\mathsfbf{\\varpi}"],
  ["d790", "\\mathsfbfsl{\\Alpha}"],
  ["d791", "\\mathsfbfsl{\\Beta}"],
  ["d792", "\\mathsfbfsl{\\Gamma}"],
  ["d793", "\\mathsfbfsl{\\Delta}"],
  ["d794", "\\mathsfbfsl{\\Epsilon}"],
  ["d795", "\\mathsfbfsl{\\Zeta}"],
  ["d796", "\\mathsfbfsl{\\Eta}"],
  ["d797", "\\mathsfbfsl{\\vartheta}"],
  ["d798", "\\mathsfbfsl{\\Iota}"],
  ["d799", "\\mathsfbfsl{\\Kappa}"],
  ["d79a", "\\mathsfbfsl{\\Lambda}"],
  ["d79d", "\\mathsfbfsl{\\Xi}"],
  ["d79f", "\\mathsfbfsl{\\Pi}"],
  ["d7a0", "\\mathsfbfsl{\\Rho}"],
  ["d7a1", "\\mathsfbfsl{\\vartheta}"],
  ["d7a2", "\\mathsfbfsl{\\Sigma}"],
  ["d7a3", "\\mathsfbfsl{\\Tau}"],
  ["d7a4", "\\mathsfbfsl{\\Upsilon}"],
  ["d7a5", "\\mathsfbfsl{\\Phi}"],
  ["d7a6", "\\mathsfbfsl{\\Chi}"],
  ["d7a7", "\\mathsfbfsl{\\Psi}"],
  ["d7a8", "\\mathsfbfsl{\\Omega}"],
  ["d7a9", "\\mathsfbfsl{\\nabla}"],
  ["d7aa", "\\mathsfbfsl{\\Alpha}"],
  ["d7ab", "\\mathsfbfsl{\\Beta}"],
  ["d7ac", "\\mathsfbfsl{\\Gamma}"],
  ["d7ad", "\\mathsfbfsl{\\Delta}"],
  ["d7ae", "\\mathsfbfsl{\\Epsilon}"],
  ["d7af", "\\mathsfbfsl{\\Zeta}"],
  ["d7b0", "\\mathsfbfsl{\\Eta}"],
  ["d7b1", "\\mathsfbfsl{\\vartheta}"],
  ["d7b2", "\\mathsfbfsl{\\Iota}"],
  ["d7b3", "\\mathsfbfsl{\\Kappa}"],
  ["d7b4", "\\mathsfbfsl{\\Lambda}"],
  ["d7b7", "\\mathsfbfsl{\\Xi}"],
  ["d7b9", "\\mathsfbfsl{\\Pi}"],
  ["d7ba", "\\mathsfbfsl{\\Rho}"],
  ["d7bb", "\\mathsfbfsl{\\varsigma}"],
  ["d7bc", "\\mathsfbfsl{\\Sigma}"],
  ["d7bd", "\\mathsfbfsl{\\Tau}"],
  ["d7be", "\\mathsfbfsl{\\Upsilon}"],
  ["d7bf", "\\mathsfbfsl{\\Phi}"],
  ["d7c0", "\\mathsfbfsl{\\Chi}"],
  ["d7c1", "\\mathsfbfsl{\\Psi}"],
  ["d7c2", "\\mathsfbfsl{\\Omega}"],
  ["d7c3", "\\partial{}"],
  ["d7c4", "\\in"],
  ["d7c5", "\\mathsfbfsl{\\vartheta}"],
  ["d7c6", "\\mathsfbfsl{\\varkappa}"],
  ["d7c7", "\\mathsfbfsl{\\phi}"],
  ["d7c8", "\\mathsfbfsl{\\varrho}"],
  ["d7c9", "\\mathsfbfsl{\\varpi}"],
  ["d7ce", "\\mathbf{0}"],
  ["d7cf", "\\mathbf{1}"],
  ["d7d0", "\\mathbf{2}"],
  ["d7d1", "\\mathbf{3}"],
  ["d7d2", "\\mathbf{4}"],
  ["d7d3", "\\mathbf{5}"],
  ["d7d4", "\\mathbf{6}"],
  ["d7d5", "\\mathbf{7}"],
  ["d7d6", "\\mathbf{8}"],
  ["d7d7", "\\mathbf{9}"],
  ["d7d8", "\\mathbb{0}"],
  ["d7d9", "\\mathbb{1}"],
  ["d7da", "\\mathbb{2}"],
  ["d7db", "\\mathbb{3}"],
  ["d7dc", "\\mathbb{4}"],
  ["d7dd", "\\mathbb{5}"],
  ["d7de", "\\mathbb{6}"],
  ["d7df", "\\mathbb{7}"],
  ["d7e0", "\\mathbb{8}"],
  ["d7e1", "\\mathbb{9}"],
  ["d7e2", "\\mathsf{0}"],
  ["d7e3", "\\mathsf{1}"],
  ["d7e4", "\\mathsf{2}"],
  ["d7e5", "\\mathsf{3}"],
  ["d7e6", "\\mathsf{4}"],
  ["d7e7", "\\mathsf{5}"],
  ["d7e8", "\\mathsf{6}"],
  ["d7e9", "\\mathsf{7}"],
  ["d7ea", "\\mathsf{8}"],
  ["d7eb", "\\mathsf{9}"],
  ["d7ec", "\\mathsfbf{0}"],
  ["d7ed", "\\mathsfbf{1}"],
  ["d7ee", "\\mathsfbf{2}"],
  ["d7ef", "\\mathsfbf{3}"],
  ["d7f0", "\\mathsfbf{4}"],
  ["d7f1", "\\mathsfbf{5}"],
  ["d7f2", "\\mathsfbf{6}"],
  ["d7f3", "\\mathsfbf{7}"],
  ["d7f4", "\\mathsfbf{8}"],
  ["d7f5", "\\mathsfbf{9}"],
  ["d7f6", "\\mathtt{0}"],
  ["d7f7", "\\mathtt{1}"],
  ["d7f8", "\\mathtt{2}"],
  ["d7f9", "\\mathtt{3}"],
  ["d7fa", "\\mathtt{4}"],
  ["d7fb", "\\mathtt{5}"],
  ["d7fc", "\\mathtt{6}"],
  ["d7fd", "\\mathtt{7}"],
  ["d7fe", "\\mathtt{8}"],
  ["d7ff", "\\mathtt{9}"]
]);

// src/transforms/escapeCharacters.ts
var VERBATIM_FIELDS = [
  "url",
  "doi",
  "eprint",
  "file",
  "verba",
  "verbb",
  "verbc",
  "pdf"
];
function createEscapeCharactersTransform() {
  return {
    name: "escape-characters",
    apply: /* @__PURE__ */ __name((ast) => {
      for (const field of ast.fields()) {
        if (VERBATIM_FIELDS.includes(field.name)) {
          continue;
        }
        for (const entry of field.value.concat) {
          entry.value = escapeCharacters(entry.value);
        }
      }
      return void 0;
    }, "apply")
  };
}
__name(createEscapeCharactersTransform, "createEscapeCharactersTransform");
function escapeCharacters(value) {
  let result = value;
  const mathExpressions = [];
  result = result.replace(/\$[^$]+\$/g, (match) => {
    mathExpressions.push(match);
    return `MATH.EXP.${mathExpressions.length - 1}`;
  });
  let newstr = "";
  let escapeMode = false;
  for (let i = 0; i < result.length; i++) {
    if (escapeMode) {
      escapeMode = false;
      newstr += result[i];
      continue;
    }
    if (result[i] === "\\") {
      escapeMode = true;
      newstr += result[i];
      continue;
    }
    const c = result.charCodeAt(i).toString(16).padStart(4, "0");
    newstr += specialCharacters.get(c) ?? result[i];
  }
  return newstr.replace(
    /MATH\.EXP\.(\d+)/g,
    (_, i) => mathExpressions[Number(i)] ?? ""
  );
}
__name(escapeCharacters, "escapeCharacters");

// src/transforms/fieldCommas.ts
function createFieldCommasTransform(trailing) {
  return {
    name: "field-commas",
    apply: /* @__PURE__ */ __name((astProxy) => {
      const entries = astProxy.entries();
      for (const entry of entries) {
        for (let i = 0; i < entry.fields.length; i++) {
          const field = entry.fields[i];
          field.hasComma = i < entry.fields.length - 1 || trailing;
        }
      }
      return void 0;
    }, "apply")
  };
}
__name(createFieldCommasTransform, "createFieldCommasTransform");

// src/transforms/formatPageRange.ts
function createFormatPageRangeTransform() {
  return {
    name: "format-page-range",
    apply(ast) {
      for (const field of ast.fields()) {
        if (field.name.toLocaleLowerCase() === "pages") {
          for (const entry of field.value.concat) {
            entry.value = formatPageRange(entry.value);
          }
          ast.invalidateField(field);
        }
      }
      return void 0;
    }
  };
}
__name(createFormatPageRangeTransform, "createFormatPageRangeTransform");
function formatPageRange(str) {
  let result = str;
  for (let i = 0; i < 4; i++) {
    result = result.replace(/(\d)\s*-\s*(\d)/g, "$1--$2");
  }
  return result;
}
__name(formatPageRange, "formatPageRange");

// src/parsers/entryKeyTemplateParser.ts
function parseEntryKeyTemplate(template) {
  const tokens = [];
  const matches = template.matchAll(/\[[^:\]]+(?::[^:\]]+)*\]/g);
  let pos = 0;
  for (const match of matches) {
    if (match.index === void 0) break;
    if (match.index !== pos) {
      tokens.push(template.slice(pos, match.index));
    }
    const [tokenKeyN, ...modifierKeys] = match[0].slice(1, -1).split(":");
    if (!tokenKeyN) {
      throw new Error("Token parse error");
    }
    let n;
    const tokenKey = tokenKeyN.replace(/[0-9]+/g, (m) => {
      n = Number(m);
      return "N";
    });
    tokens.push({
      marker: tokenKey,
      parameter: n,
      modifiers: modifierKeys
    });
    pos = match.index + match[0].length;
  }
  if (pos < template.length) {
    tokens.push(template.slice(pos));
  }
  return tokens;
}
__name(parseEntryKeyTemplate, "parseEntryKeyTemplate");

// src/parsers/nameFieldParser.ts
function parseNameList(value) {
  return value.split(/\s+and\s+/i).map(parseName);
}
__name(parseNameList, "parseNameList");
function detectNameSyntax(tokens) {
  const names = tokens.filter((token) => token.type === "name");
  const prefixes = tokens.filter((token) => token.type === "prefix");
  const commas = tokens.filter((token) => token.type === "comma");
  if (tokens.length === 0) {
    return "Empty";
  }
  if (tokens.length === 1 && nameStr(tokens) === "others") {
    return "Others";
  }
  if (tokens.length === names.length && tokens.length === 1) {
    return "LastName";
  }
  if (tokens.length === names.length) {
    return "FirstName LastNames";
  }
  if (prefixes.length > 0 && commas.length === 0) {
    return "FirstNames Prefixes LastNames";
  }
  if (commas.length === 1) {
    return "LastNames, FirstNames Prefixes";
  }
  if (commas.length === 2) {
    return "LastNames, Suffixes, FirstNames Prefixes";
  }
  throw new Error(
    `Invalid name syntax: ${tokens.map((token) => token.type).join(" ")}`
  );
}
__name(detectNameSyntax, "detectNameSyntax");
function parseName(name) {
  const tokens = tokeniseName(name);
  switch (detectNameSyntax(tokens)) {
    case "Empty":
      return { first: "", last: "", pre: "", suf: "" };
    case "Others":
      return { first: "", last: "others", pre: "", suf: "" };
    case "LastName":
      return { first: "", last: nameStr(tokens), pre: "", suf: "" };
    case "FirstName LastNames": {
      const [first, last] = partition(tokens, ["name", "name"]);
      return { first: nameStr(first), last: nameStr(last), pre: "", suf: "" };
    }
    case "FirstNames Prefixes LastNames": {
      const [first, pre, last] = partition(tokens, [
        "name",
        "prefix",
        "name"
      ]);
      return {
        first: nameStr(first),
        pre: nameStr(pre),
        last: nameStr(last),
        suf: ""
      };
    }
    case "LastNames, FirstNames Prefixes": {
      const [lastNames, firstNames, prefixes] = partition(tokens, [
        "name",
        "comma",
        "prefix"
      ]);
      return {
        last: nameStr(lastNames),
        first: nameStr(firstNames),
        pre: nameStr(prefixes),
        suf: ""
      };
    }
    case "LastNames, Suffixes, FirstNames Prefixes": {
      const [lastNames, suffixes, firstNames, prefixes] = partition(tokens, [
        "name",
        "comma",
        "comma",
        "prefix"
      ]);
      return {
        last: nameStr(lastNames),
        suf: nameStr(suffixes),
        first: nameStr(firstNames),
        pre: nameStr(prefixes)
      };
    }
  }
}
__name(parseName, "parseName");
function tokeniseName(name) {
  const tokens = [];
  let current = "";
  function flushToken() {
    if (!current) return;
    tokens.push({
      type: isPrefixToken(current) ? "prefix" : "name",
      value: current
    });
  }
  __name(flushToken, "flushToken");
  for (const c of name) {
    if (c === ",") {
      flushToken();
      tokens.push({ type: "comma" });
      current = "";
    } else if (/\s/.test(c)) {
      flushToken();
      current = "";
    } else {
      current += c;
    }
  }
  flushToken();
  return tokens;
}
__name(tokeniseName, "tokeniseName");
function nameStr(tokens) {
  return tokens.filter(
    (token) => token.type !== "comma"
  ).map((token) => token.value).join(" ");
}
__name(nameStr, "nameStr");
function isPrefixToken(token) {
  return /^[a-z]/.test(token);
}
__name(isPrefixToken, "isPrefixToken");
function partition(tokens, divideBefore) {
  const partitions = divideBefore.map(() => []);
  let currPartition = -1;
  for (const token of tokens) {
    if (divideBefore[currPartition + 1] === token.type) {
      currPartition++;
    }
    partitions[currPartition]?.push(token);
  }
  return partitions;
}
__name(partition, "partition");

// src/generateKeys.ts
var SPECIAL_MARKERS = {
  auth: {
    description: "Last name of first authors",
    callback: /* @__PURE__ */ __name((v) => {
      const authors = parseNameList(v.get("author") ?? "");
      const author = authors[0]?.last;
      return author ? [author] : [];
    }, "callback")
  },
  authEtAl: {
    description: "If 1 or 2 authors, both authors, otherwise first author and EtAl",
    callback: /* @__PURE__ */ __name((v) => {
      const authors = parseNameList(v.get("author") ?? "");
      return [
        ...authors.slice(0, 2).map((author) => author.last),
        ...authors.length > 2 ? ["Et", "Al"] : []
      ];
    }, "callback")
  },
  authors: {
    description: "Last name all authors",
    callback: /* @__PURE__ */ __name((v) => {
      const authors = parseNameList(v.get("author") ?? "");
      return authors.map((author) => author.last);
    }, "callback")
  },
  authorsN: {
    description: "Last name N authors, with EtAl if more",
    callback: /* @__PURE__ */ __name((v, n = 0) => {
      const authors = parseNameList(v.get("author") ?? "");
      return [
        ...authors.slice(0, n).map((author) => author.last),
        ...authors.length > n ? ["Et", "Al"] : []
      ];
    }, "callback")
  },
  veryshorttitle: {
    description: "First non-function word of the title",
    callback: /* @__PURE__ */ __name((v) => nonFunctionWords(title(v)).slice(0, 1), "callback")
  },
  shorttitle: {
    description: "First three non-function words of the title",
    callback: /* @__PURE__ */ __name((v) => nonFunctionWords(title(v)).slice(0, 3), "callback")
  },
  title: {
    description: "Full title, capitalized",
    callback: /* @__PURE__ */ __name((v) => capitalize(words(title(v))), "callback")
  },
  fulltitle: {
    description: "Full title, verbatim",
    callback: /* @__PURE__ */ __name((v) => words(title(v)), "callback")
  },
  year: {
    description: "Year",
    callback: /* @__PURE__ */ __name((v) => {
      const year = v.get("year")?.replace(/[^0-9]/g, "");
      return year ? [year] : [];
    }, "callback")
  },
  duplicateLetter: {
    description: "If the multiple entries end up with the same key, then insert a letter a-z. By default this will be inserted at the end.",
    callback: /* @__PURE__ */ __name((_, __, duplicate) => [duplicate ? numToLetter(duplicate) : ""], "callback")
  },
  duplicateNumber: {
    description: "If the multiple entries end up with the same key, then insert a number.",
    callback: /* @__PURE__ */ __name((_, __, duplicate) => [duplicate ? String(duplicate) : ""], "callback")
  }
};
function numToLetter(n) {
  return String.fromCharCode(96 + n);
}
__name(numToLetter, "numToLetter");
var MODIFIERS = {
  required: {
    description: "If data is missing, revert to existing key",
    callback: /* @__PURE__ */ __name((words2) => {
      if (words2.length === 0) throw new MissingRequiredData();
      return words2;
    }, "callback")
  },
  lower: {
    description: "Convert to lowercase",
    callback: /* @__PURE__ */ __name((words2) => words2.map((word) => word.toLocaleLowerCase()), "callback")
  },
  upper: {
    description: "Convert to uppercase",
    callback: /* @__PURE__ */ __name((words2) => words2.map((word) => word.toLocaleUpperCase()), "callback")
  },
  capitalize: {
    description: "Capitalize first letter of each word",
    callback: capitalize
  }
};
var MissingRequiredData = class extends Error {
  static {
    __name(this, "MissingRequiredData");
  }
};
function generateKeys(entries, cache, entryKeyTemplate) {
  let template = entryKeyTemplate;
  if (!entryKeyTemplate.includes("[duplicateLetter]") && !entryKeyTemplate.includes("[duplicateNumber]")) {
    template = `${entryKeyTemplate}[duplicateLetter]`;
  }
  const parsedTemplate = parseEntryKeyTemplate(template);
  const entriesByKey = /* @__PURE__ */ new Map();
  for (const entry of entries) {
    const entryValues = cache.lookupRenderedEntryValues(entry);
    const key = generateKey(entryValues, parsedTemplate);
    if (!key) continue;
    const entriesSoFar = entriesByKey.get(key) ?? [];
    entriesSoFar.push(entry);
    entriesByKey.set(key, entriesSoFar);
  }
  const keys = /* @__PURE__ */ new Map();
  for (const [key, entries2] of entriesByKey) {
    const regenerateDuplicate = entries2.length > 1;
    for (let i = 0; i < entries2.length; i++) {
      const node = entries2[i];
      if (!node) continue;
      const entryValues = cache.lookupRenderedEntryValues(node);
      const newKey = regenerateDuplicate ? generateKey(entryValues, parsedTemplate, i + 1) : key;
      if (!newKey) continue;
      keys.set(node, newKey);
    }
  }
  return keys;
}
__name(generateKeys, "generateKeys");
function generateKey(valueLookup, entryKeyTemplate, duplicateNumber) {
  try {
    let newKey = entryKeyTemplate.map((token) => {
      if (typeof token === "string") {
        return token;
      }
      const { marker, parameter, modifiers } = token;
      const specialMarker = SPECIAL_MARKERS[marker];
      let key;
      if (specialMarker) {
        key = specialMarker.callback(valueLookup, parameter, duplicateNumber);
      } else if (marker === marker.toLocaleUpperCase()) {
        const value = valueLookup.get(marker.toLocaleLowerCase());
        key = value ? words(value) : [];
      } else {
        throw new Error(`Invalid citation key token ${marker}`);
      }
      for (const modifierKey of modifiers) {
        const modifier = MODIFIERS[modifierKey];
        if (modifier) {
          key = modifier.callback(key);
        } else {
          throw new Error(`Invalid modifier ${modifierKey}`);
        }
      }
      return key.join("");
    }).join("");
    newKey = removeUnsafeEntryKeyChars(newKey);
    if (newKey === "") return;
    return newKey;
  } catch (e) {
    if (e instanceof MissingRequiredData) {
      return;
    }
    throw e;
  }
}
__name(generateKey, "generateKey");
var functionWords = /* @__PURE__ */ new Set([
  "a",
  "about",
  "above",
  "across",
  "against",
  "along",
  "among",
  "an",
  "and",
  "around",
  "at",
  "before",
  "behind",
  "below",
  "beneath",
  "beside",
  "between",
  "beyond",
  "but",
  "by",
  "down",
  "during",
  "except",
  "for",
  "for",
  "from",
  "in",
  "inside",
  "into",
  "like",
  "near",
  "nor",
  "of",
  "off",
  "on",
  "onto",
  "or",
  "since",
  "so",
  "the",
  "through",
  "to",
  "toward",
  "under",
  "until",
  "up",
  "upon",
  "with",
  "within",
  "without",
  "yet"
]);
function nonFunctionWords(value) {
  return words(value).filter(
    (word) => !functionWords.has(word.toLocaleLowerCase())
  );
}
__name(nonFunctionWords, "nonFunctionWords");
function words(value) {
  return value.split(/[\s.,:;]+/).filter((word) => word.length > 0);
}
__name(words, "words");
function capitalize(words2) {
  return words2.map(
    (word) => word.slice(0, 1).toLocaleUpperCase() + word.slice(1).toLocaleLowerCase()
  );
}
__name(capitalize, "capitalize");
function title(entryValues) {
  return entryValues.get("title") ?? entryValues.get("booktitle") ?? "";
}
__name(title, "title");
function removeUnsafeEntryKeyChars(str) {
  return str.replace(/[{},\s\\#%~()"'=.,:;[\]_]+/g, "");
}
__name(removeUnsafeEntryKeyChars, "removeUnsafeEntryKeyChars");

// src/transforms/generateKeys.ts
function createGenerateKeysTransform(template) {
  return {
    name: "generate-keys",
    apply: /* @__PURE__ */ __name((astProxy) => {
      const newKeys = generateKeys(astProxy.entries(), astProxy, template);
      for (const entry of astProxy.entries()) {
        const newKey = newKeys.get(entry);
        if (newKey) {
          entry.key = newKey;
        }
      }
      return void 0;
    }, "apply")
  };
}
__name(createGenerateKeysTransform, "createGenerateKeysTransform");

// src/transforms/indentFields.ts
function createIndentFieldsTransform(indent) {
  return {
    name: "indent",
    apply: /* @__PURE__ */ __name((astProxy) => {
      const fields = astProxy.fields();
      for (const field of fields) {
        field.whitespacePrefix = `
${indent}`;
      }
      return void 0;
    }, "apply")
  };
}
__name(createIndentFieldsTransform, "createIndentFieldsTransform");

// src/transforms/limitAuthors.ts
function createLimitAuthorsTransform(maxAuthors) {
  return {
    name: "limit-authors",
    apply: /* @__PURE__ */ __name((astProxy) => {
      const fields = astProxy.fields();
      for (const field of fields) {
        if (field.name.toLocaleLowerCase() === "author") {
          for (const node of field.value.concat) {
            const authors = node.value.split(" and ");
            if (authors.length > maxAuthors) {
              node.value = [...authors.slice(0, maxAuthors), "others"].join(
                " and "
              );
            }
          }
        }
      }
      return void 0;
    }, "apply")
  };
}
__name(createLimitAuthorsTransform, "createLimitAuthorsTransform");

// src/transforms/lowercaseEntryType.ts
function createLowercaseEntryTypeTransform() {
  return {
    name: "lowercase-entry-type",
    apply: /* @__PURE__ */ __name((ast) => {
      for (const entry of ast.entries()) {
        entry.parent.command = entry.parent.command.toLocaleLowerCase();
      }
      return void 0;
    }, "apply")
  };
}
__name(createLowercaseEntryTypeTransform, "createLowercaseEntryTypeTransform");

// src/transforms/lowercaseFields.ts
function createLowercaseFieldsTransform() {
  return {
    name: "lowercase-fields",
    apply: /* @__PURE__ */ __name((ast) => {
      for (const field of ast.fields()) {
        const newName = field.name.toLocaleLowerCase();
        if (newName !== field.name) {
          field.name = newName;
          ast.invalidateField(field);
        }
      }
      return void 0;
    }, "apply")
  };
}
__name(createLowercaseFieldsTransform, "createLowercaseFieldsTransform");

// src/utils.ts
function alphaNum(str) {
  return str.replace(/[^0-9A-Za-z]/g, "").toLocaleLowerCase();
}
__name(alphaNum, "alphaNum");
function convertCRLF(str) {
  return str.replace(/\r\n?/g, "\n");
}
__name(convertCRLF, "convertCRLF");
function wrapText(line, lineWidth) {
  const words2 = line.split(" ");
  const lines = [];
  let currLine = "";
  for (const [i, word] of words2.entries()) {
    if (currLine.length + word.length + 1 > lineWidth && i > 0) {
      lines.push(currLine.trim());
      currLine = "";
    }
    currLine += `${word} `;
  }
  return [...lines, currLine.trim()];
}
__name(wrapText, "wrapText");
function unwrapText(str) {
  return str.replace(/\s*\n\s*\n\s*/g, "<<BIBTEX_TIDY_PARA>>").replace(/\s*\n\s*/g, " ").replace(/<<BIBTEX_TIDY_PARA>>/g, "\n\n");
}
__name(unwrapText, "unwrapText");
function isEntryNode(node) {
  return node.type !== "text" && node.block?.type === "entry";
}
__name(isEntryNode, "isEntryNode");

// src/duplicates.ts
function checkForDuplicates(cache, duplicateRules, merge) {
  const rules = /* @__PURE__ */ new Map();
  if (duplicateRules) {
    for (const rule of duplicateRules) {
      rules.set(rule, !!merge);
    }
  }
  if (!rules.has("key")) {
    rules.set("key", false);
  }
  const duplicateEntries = /* @__PURE__ */ new Set();
  const warnings = [];
  const keys = /* @__PURE__ */ new Map();
  const dois = /* @__PURE__ */ new Map();
  const citations = /* @__PURE__ */ new Map();
  const abstracts = /* @__PURE__ */ new Map();
  for (const entry of cache.entries()) {
    for (const [rule, doMerge] of rules) {
      let duplicateOf;
      let warning;
      switch (rule) {
        case "key": {
          if (!entry.key) continue;
          const keyLC = entry.key.toLocaleLowerCase();
          duplicateOf = keys.get(keyLC);
          if (!duplicateOf) {
            keys.set(keyLC, entry);
          } else {
            warning = `The citation key ${entry.key} has already been used.`;
          }
          break;
        }
        case "doi": {
          const doi = alphaNum(cache.lookupRenderedEntryValue(entry, "doi"));
          if (!doi) continue;
          duplicateOf = dois.get(doi);
          if (!duplicateOf) {
            dois.set(doi, entry);
          } else {
            warning = `Entry ${entry.key} has an identical DOI to entry ${duplicateOf.key}.`;
          }
          break;
        }
        case "citation": {
          const ttl = cache.lookupRenderedEntryValue(entry, "title");
          const aut = cache.lookupRenderedEntryValue(entry, "author");
          const num = cache.lookupRenderedEntryValue(entry, "number");
          if (!ttl || !aut) continue;
          const cit = [
            alphaNum(parseNameList(aut)[0]?.last ?? aut),
            alphaNum(ttl),
            alphaNum(num ?? "0")
          ].join(":");
          duplicateOf = citations.get(cit);
          if (!duplicateOf) {
            citations.set(cit, entry);
          } else {
            warning = `Entry ${entry.key} has similar content to entry ${duplicateOf.key}.`;
          }
          break;
        }
        case "abstract": {
          const abstract = alphaNum(
            cache.lookupRenderedEntryValue(entry, "abstract")
          );
          const abs = abstract.slice(0, 100);
          if (!abs) continue;
          duplicateOf = abstracts.get(abs);
          if (!duplicateOf) {
            abstracts.set(abs, entry);
          } else {
            warning = `Entry ${entry.key} has a similar abstract to entry ${duplicateOf.key}.`;
          }
          break;
        }
      }
      if (duplicateOf && doMerge) {
        duplicateEntries.add(entry);
        mergeEntries(merge, duplicateOf, entry);
      }
      if (warning) {
        warnings.push({
          code: "DUPLICATE_ENTRY",
          rule,
          message: `Duplicate ${doMerge ? "removed" : "detected"}. ${warning}`
        });
      }
    }
  }
  return { entries: duplicateEntries, warnings };
}
__name(checkForDuplicates, "checkForDuplicates");
function mergeEntries(merge, duplicateOf, entry) {
  if (!merge) return;
  switch (merge) {
    case "last":
      duplicateOf.key = entry.key;
      duplicateOf.fields = entry.fields;
      break;
    case "combine":
    case "overwrite":
      for (const field of entry.fields) {
        const existing = duplicateOf.fields.find(
          (f) => f.name.toLocaleLowerCase() === field.name.toLocaleLowerCase()
        );
        if (!existing) {
          duplicateOf.fields.push(field);
        } else if (merge === "overwrite") {
          existing.value = field.value;
        }
      }
      break;
    // TODO: case 'keep-both'
    case "first":
      return;
  }
}
__name(mergeEntries, "mergeEntries");

// src/transforms/mergeEntries.ts
function createMergeEntriesTransform(duplicatesOpt, merge) {
  return {
    name: "merge-entries",
    dependencies: ["generate-keys", "sort-entries"],
    apply: /* @__PURE__ */ __name((astProxy) => {
      const duplicates = checkForDuplicates(astProxy, duplicatesOpt, merge);
      const root = astProxy.root();
      root.children = root.children.filter(
        (child) => !isEntryNode(child) || !duplicates.entries.has(child.block)
      );
      return duplicates.warnings;
    }, "apply")
  };
}
__name(createMergeEntriesTransform, "createMergeEntriesTransform");

// src/transforms/preferCurly.ts
function createPreferCurlyTransform() {
  return {
    name: "prefer-curly",
    apply: /* @__PURE__ */ __name((ast) => {
      for (const field of ast.fields()) {
        if (field.name.toLowerCase() === "month" && monthAliases[ast.lookupRenderedEntryValue(field)]) {
          continue;
        }
        for (const child of field.value.concat) {
          child.type = "braced";
        }
        ast.invalidateField(field);
      }
      return void 0;
    }, "apply")
  };
}
__name(createPreferCurlyTransform, "createPreferCurlyTransform");

// src/transforms/preferNumeric.ts
function createPreferNumericTransform() {
  return {
    name: "prefer-numeric",
    apply: /* @__PURE__ */ __name((ast) => {
      for (const field of ast.fields()) {
        for (const child of field.value.concat) {
          const isNumeric = child.value.match(/^[1-9][0-9]*$/);
          if (isNumeric) {
            child.type = "literal";
          }
        }
        ast.invalidateField(field);
      }
      return void 0;
    }, "apply")
  };
}
__name(createPreferNumericTransform, "createPreferNumericTransform");

// src/transforms/removeBraces.ts
function createRemoveBracesTransform(fields) {
  const set = new Set(fields.map((f) => f.toLocaleLowerCase()));
  return {
    name: "remove-braces",
    apply: /* @__PURE__ */ __name((ast) => {
      for (const field of ast.fields()) {
        if (set.has(field.name.toLocaleLowerCase())) {
          for (const node of field.value.concat) {
            if (node.type === "braced") {
              node.value = stringifyLaTeX(flattenLaTeX(parseLaTeX(node.value)));
            }
          }
        }
      }
      return void 0;
    }, "apply")
  };
}
__name(createRemoveBracesTransform, "createRemoveBracesTransform");

// src/transforms/removeComments.ts
function createRemoveCommentsTransform() {
  return {
    name: "remove-comments",
    apply: /* @__PURE__ */ __name((astProxy) => {
      astProxy.root().children = astProxy.root().children.filter(
        (child) => child.type !== "text" && (child.type !== "block" || child.block?.type !== "comment")
      );
      return void 0;
    }, "apply")
  };
}
__name(createRemoveCommentsTransform, "createRemoveCommentsTransform");

// src/transforms/removeDuplicateFields.ts
function createRemoveDuplicateFieldsTransform() {
  return {
    name: "remove-duplicate-fields",
    apply: /* @__PURE__ */ __name((astProxy) => {
      for (const node of astProxy.root().children) {
        if (node.type === "block" && node.block?.type === "entry") {
          const fieldSeen = /* @__PURE__ */ new Set();
          node.block.fields = node.block.fields.filter((field) => {
            const nameLc = field.name.toLocaleLowerCase();
            if (fieldSeen.has(nameLc)) {
              return false;
            }
            fieldSeen.add(nameLc);
            return true;
          });
        }
      }
      return void 0;
    }, "apply")
  };
}
__name(createRemoveDuplicateFieldsTransform, "createRemoveDuplicateFieldsTransform");

// src/transforms/removeEmptyFields.ts
function createRemoveEmptyFieldsTransform() {
  return {
    name: "remove-empty-fields",
    apply: /* @__PURE__ */ __name((ast) => {
      for (const node of ast.root().children) {
        if (node.type === "block" && node.block?.type === "entry") {
          const entry = node.block;
          entry.fields = entry.fields.filter(
            (field) => ast.lookupRenderedEntryValue(field) !== ""
          );
        }
      }
      return void 0;
    }, "apply")
  };
}
__name(createRemoveEmptyFieldsTransform, "createRemoveEmptyFieldsTransform");

// src/transforms/removeEnclosingBraces.ts
function createRemoveEnclosingBracesTransform() {
  return {
    name: "remove-enclosing-braces",
    apply: /* @__PURE__ */ __name((ast) => {
      for (const field of ast.fields()) {
        for (const node of field.value.concat) {
          if (node.type === "braced") {
            node.value = node.value.replace(/^\{([^{}]*)\}$/g, "$1");
          }
          ast.invalidateField(field);
        }
      }
      return void 0;
    }, "apply")
  };
}
__name(createRemoveEnclosingBracesTransform, "createRemoveEnclosingBracesTransform");

// src/transforms/removeSpecifiedFields.ts
function createRemoveSpecifiedFieldsTransform(omit) {
  return {
    name: "remove-specified-fields",
    apply(ast) {
      const set = new Set(omit.map((f) => f.toLocaleLowerCase()));
      for (const field of ast.fields()) {
        if (set.has(field.name.toLocaleLowerCase())) {
          field.parent.fields = field.parent.fields.filter((f) => f !== field);
        }
      }
      return void 0;
    }
  };
}
__name(createRemoveSpecifiedFieldsTransform, "createRemoveSpecifiedFieldsTransform");

// src/transforms/resetWhitespace.ts
function createResetWhitespaceTransform(keepCommentWhitespace) {
  return {
    name: "reset-whitespace",
    apply: /* @__PURE__ */ __name((astProxy) => {
      const children = astProxy.root().children;
      let prev;
      for (const child of children) {
        const preserve = isComment2(child) && keepCommentWhitespace;
        const preservePrev = prev && isComment2(prev) && keepCommentWhitespace;
        if (keepCommentWhitespace && child.type === "block" && prev?.type === "text" && !prev.text.endsWith("\n")) {
          prev.text = `${prev.text.trimEnd()}
`;
        }
        if (!preserve) {
          child.whitespacePrefix = prev && !preservePrev ? "\n" : "";
          if (child.type === "text") {
            child.text = child.text.trim();
          } else if (child.block) {
            if (child.block.type === "entry") {
              for (const field of child.block.fields) {
                field.whitespacePrefix = "";
              }
            } else if (child.block.type === "comment") {
              child.block.raw = child.block.raw.trim();
            }
          }
        }
        prev = child;
      }
      return void 0;
    }, "apply")
  };
}
__name(createResetWhitespaceTransform, "createResetWhitespaceTransform");
function isComment2(node) {
  return node.type === "text" || node.block?.type === "comment";
}
__name(isComment2, "isComment");

// src/transforms/sortEntries.ts
var MONTH_MACROS = [
  "jan",
  "feb",
  "mar",
  "apr",
  "may",
  "jun",
  "jul",
  "aug",
  "sep",
  "oct",
  "nov",
  "dec"
];
function createSortEntriesTransform(sort) {
  return {
    name: "sort-entries",
    dependencies: ["generate-keys", "merge-entries", "prefer-numeric"],
    apply: /* @__PURE__ */ __name((astProxy) => {
      sortEntries(astProxy.root(), astProxy, sort);
      return void 0;
    }, "apply")
  };
}
__name(createSortEntriesTransform, "createSortEntriesTransform");
function sortEntries(ast, cache, sort) {
  const sortIndexes = /* @__PURE__ */ new Map();
  const precedingMeta = [];
  for (const item of ast.children) {
    if (item.type === "text" || item.block?.type !== "entry" && !sort.includes("special")) {
      precedingMeta.push(item);
      continue;
    }
    const sortIndex = /* @__PURE__ */ new Map();
    for (let key of sort) {
      if (key.startsWith("-")) key = key.slice(1);
      let val;
      switch (key) {
        case "key":
          if (item.block?.type !== "entry") continue;
          val = item.block.key ?? "";
          break;
        case "type":
          val = item.command;
          break;
        case "month": {
          if (item.block?.type !== "entry") continue;
          const v = cache.lookupRenderedEntryValue(item.block, key);
          const i = v ? MONTH_MACROS.indexOf(v) : -1;
          val = i > -1 ? i : "";
          break;
        }
        case "special":
          val = isBibLaTeXSpecialEntry(item) ? 0 : 1;
          break;
        default:
          if (item.block?.type !== "entry") continue;
          val = cache.lookupRenderedEntryValue(item.block, key);
      }
      sortIndex.set(key, typeof val === "string" ? val.toLowerCase() : val);
    }
    sortIndexes.set(item, sortIndex);
    while (precedingMeta.length > 0) {
      const index = precedingMeta.pop();
      if (!index) break;
      sortIndexes.set(index, sortIndex);
    }
  }
  for (const prefixedKey of [...sort].reverse()) {
    const desc = prefixedKey.startsWith("-");
    const key = desc ? prefixedKey.slice(1) : prefixedKey;
    ast.children.sort((a, b) => {
      let ia = sortIndexes.get(a)?.get(key) ?? "\uFFF0";
      let ib = sortIndexes.get(b)?.get(key) ?? "\uFFF0";
      if (typeof ia === "number") ia = String(ia).padStart(50, "0");
      if (typeof ib === "number") ib = String(ib).padStart(50, "0");
      return (desc ? ib : ia).localeCompare(desc ? ia : ib);
    });
  }
}
__name(sortEntries, "sortEntries");
var SPECIAL_ENTRIES = /* @__PURE__ */ new Set([
  "string",
  "preamble",
  // http://tug.ctan.org/info/biblatex-cheatsheet/biblatex-cheatsheet.pdf
  "set",
  "xdata"
]);
function isBibLaTeXSpecialEntry(node) {
  return SPECIAL_ENTRIES.has(node.command.toLowerCase());
}
__name(isBibLaTeXSpecialEntry, "isBibLaTeXSpecialEntry");

// src/transforms/sortFields.ts
function createSortFieldsTransform(sortFields) {
  return {
    name: "sort-fields",
    apply: /* @__PURE__ */ __name((astProxy) => {
      const entries = astProxy.entries();
      sortEntryFields(entries, sortFields);
      return void 0;
    }, "apply")
  };
}
__name(createSortFieldsTransform, "createSortFieldsTransform");
function sortEntryFields(entries, fieldOrder) {
  for (const entry of entries) {
    entry.fields.sort((a, b) => {
      const orderA = fieldOrder.indexOf(a.name.toLocaleLowerCase());
      const orderB = fieldOrder.indexOf(b.name.toLocaleLowerCase());
      if (orderA === -1 && orderB === -1) return 0;
      if (orderA === -1) return 1;
      if (orderB === -1) return -1;
      if (orderB < orderA) return 1;
      if (orderB > orderA) return -1;
      return 0;
    });
  }
}
__name(sortEntryFields, "sortEntryFields");

// src/transforms/wrapValues.ts
function createWrapValuesTransform(indent, align, wrap) {
  return {
    name: "wrap-values",
    apply: /* @__PURE__ */ __name((astProxy) => {
      const fields = astProxy.fields();
      for (const field of fields) {
        for (const node of field.value.concat) {
          let value = unwrapText(node.value);
          if (node.type === "braced" && field.value.concat.length === 1) {
            value = value.trim();
          }
          if (node.type === "braced") {
            const lineLength = `${indent}${align}{${value}}`.length;
            const multiLine = value.includes("\n\n");
            if (wrap && lineLength > wrap || multiLine) {
              let paragraphs = value.split("\n\n");
              const valIndent = indent.repeat(2);
              if (wrap) {
                const wrapCol = wrap;
                paragraphs = paragraphs.map(
                  (paragraph) => wrapText(paragraph, wrapCol - valIndent.length).join(
                    `
${valIndent}`
                  )
                );
              }
              value = `
${valIndent}${paragraphs.join(`

${valIndent}`)}
${indent}`;
            }
            node.value = value;
          }
        }
      }
      return void 0;
    }, "apply")
  };
}
__name(createWrapValuesTransform, "createWrapValuesTransform");

// src/pipeline.ts
function sortPipeline(Transforms) {
  const sorted = [];
  const visited = /* @__PURE__ */ new Set();
  const visit = /* @__PURE__ */ __name((Transform) => {
    if (visited.has(Transform.name)) return;
    visited.add(Transform.name);
    for (const dep of Transform.dependencies ?? []) {
      const depTransform = Transforms.find((t) => t.name === dep);
      if (depTransform) visit(depTransform);
    }
    sorted.push(Transform);
  }, "visit");
  Transforms.forEach(visit);
  return sorted;
}
__name(sortPipeline, "sortPipeline");
function generateTransformPipeline(options) {
  const pipeline = [];
  if (options.months) {
    pipeline.push(createAbbreviateMonthsTransform());
  }
  if (options.dropAllCaps) {
    pipeline.push(createDropAllCapsTransform());
  }
  if (options.encodeUrls) {
    pipeline.push(createEncodeUrlsTransform());
  }
  if (options.escape) {
    pipeline.push(createEscapeCharactersTransform());
  }
  pipeline.push(createFormatPageRangeTransform());
  if (options.generateKeys) {
    pipeline.push(createGenerateKeysTransform(options.generateKeys));
  }
  if (options.maxAuthors) {
    pipeline.push(createLimitAuthorsTransform(options.maxAuthors));
  }
  if (options.lowercase) {
    pipeline.push(
      createLowercaseEntryTypeTransform(),
      createLowercaseFieldsTransform()
    );
  }
  if (options.merge || options.duplicates) {
    pipeline.push(
      createMergeEntriesTransform(options.duplicates, options.merge)
    );
  }
  if (options.omit) {
    pipeline.push(createRemoveSpecifiedFieldsTransform(options.omit));
  }
  if (options.enclosingBraces) {
    pipeline.push(createEncloseBracesTransform(options.enclosingBraces));
  }
  if (options.curly) {
    pipeline.push(createPreferCurlyTransform());
  }
  if (options.numeric) {
    pipeline.push(createPreferNumericTransform());
  }
  if (options.removeBraces) {
    pipeline.push(createRemoveBracesTransform(options.removeBraces));
  }
  if (options.stripComments) {
    pipeline.push(createRemoveCommentsTransform());
  }
  if (options.removeDuplicateFields) {
    pipeline.push(createRemoveDuplicateFieldsTransform());
  }
  if (options.removeEmptyFields) {
    pipeline.push(createRemoveEmptyFieldsTransform());
  }
  if (options.sort) {
    pipeline.push(createSortEntriesTransform(options.sort));
  }
  if (options.sortFields) {
    pipeline.push(createSortFieldsTransform(options.sortFields));
  }
  if (options.stripEnclosingBraces) {
    pipeline.push(createRemoveEnclosingBracesTransform());
  }
  pipeline.push(createResetWhitespaceTransform(!options.tidyComments));
  const indent = options.tab ? "	" : " ".repeat(options.space);
  pipeline.push(createIndentFieldsTransform(indent));
  if (options.blankLines) {
    pipeline.push(createBlankLinesTransform());
  }
  pipeline.push(createAlignValuesTransform(options.align));
  pipeline.push(createFieldCommasTransform(options.trailingCommas ?? false));
  pipeline.push(createWrapValuesTransform(indent, options.align, options.wrap));
  return sortPipeline(pipeline);
}
__name(generateTransformPipeline, "generateTransformPipeline");

// src/tidy.ts
var verbose = false;
function tidy(input, options_ = {}) {
  const options = normalizeOptions(options_);
  const inputFixed = convertCRLF(input);
  const ast = parseBibTeX(inputFixed);
  const cache = new ASTProxy(ast);
  const pipeline = generateTransformPipeline(options);
  const warnings = cache.entries().filter((entry) => !entry.key).map((entry) => ({
    code: "MISSING_KEY",
    message: `${entry.parent.command} entry does not have a citation key.`
  }));
  if (verbose) {
    console.log(logAST(ast));
  }
  for (const transform of pipeline) {
    const result = transform.apply(cache);
    if (verbose) {
      console.log(`

## Applying transform: ${transform.name}`);
      console.log(logAST(ast));
    }
    if (result) warnings.push(...result);
  }
  const bibtex = formatBibtex(ast);
  return { bibtex, warnings, count: cache.entries().length };
}
__name(tidy, "tidy");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  tidy
});