'use strict';

var obsidian = require('obsidian');
var sysPath = require('path');
var require$$0$4 = require('events');
var require$$0$2 = require('util');
var fs$3 = require('fs');
var require$$0$3 = require('stream');
var require$$1$1 = require('os');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var sysPath__default = /*#__PURE__*/_interopDefaultLegacy(sysPath);
var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$4);
var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0$2);
var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs$3);
var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$3);
var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);

/*! *****************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */

var extendStatics = function(d, b) {
    extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
    return extendStatics(d, b);
};

function __extends(d, b) {
    extendStatics(d, b);
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}

var __assign = function() {
    __assign = Object.assign || function __assign(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};

function __awaiter(thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
}

function __generator(thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
}

var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

function createCommonjsModule(fn, basedir, module) {
	return module = {
		path: basedir,
		exports: {},
		require: function (path, base) {
			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
		}
	}, fn(module, module.exports), module.exports;
}

function commonjsRequire () {
	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
}

const WIN_SLASH = '\\\\/';
const WIN_NO_SLASH = `[^${WIN_SLASH}]`;

/**
 * Posix glob regex
 */

const DOT_LITERAL = '\\.';
const PLUS_LITERAL = '\\+';
const QMARK_LITERAL = '\\?';
const SLASH_LITERAL = '\\/';
const ONE_CHAR = '(?=.)';
const QMARK = '[^/]';
const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
const NO_DOT = `(?!${DOT_LITERAL})`;
const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
const STAR = `${QMARK}*?`;

const POSIX_CHARS = {
  DOT_LITERAL,
  PLUS_LITERAL,
  QMARK_LITERAL,
  SLASH_LITERAL,
  ONE_CHAR,
  QMARK,
  END_ANCHOR,
  DOTS_SLASH,
  NO_DOT,
  NO_DOTS,
  NO_DOT_SLASH,
  NO_DOTS_SLASH,
  QMARK_NO_DOT,
  STAR,
  START_ANCHOR
};

/**
 * Windows glob regex
 */

const WINDOWS_CHARS = {
  ...POSIX_CHARS,

  SLASH_LITERAL: `[${WIN_SLASH}]`,
  QMARK: WIN_NO_SLASH,
  STAR: `${WIN_NO_SLASH}*?`,
  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
  NO_DOT: `(?!${DOT_LITERAL})`,
  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`
};

/**
 * POSIX Bracket Regex
 */

const POSIX_REGEX_SOURCE = {
  alnum: 'a-zA-Z0-9',
  alpha: 'a-zA-Z',
  ascii: '\\x00-\\x7F',
  blank: ' \\t',
  cntrl: '\\x00-\\x1F\\x7F',
  digit: '0-9',
  graph: '\\x21-\\x7E',
  lower: 'a-z',
  print: '\\x20-\\x7E ',
  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
  space: ' \\t\\r\\n\\v\\f',
  upper: 'A-Z',
  word: 'A-Za-z0-9_',
  xdigit: 'A-Fa-f0-9'
};

var constants = {
  MAX_LENGTH: 1024 * 64,
  POSIX_REGEX_SOURCE,

  // regular expressions
  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,

  // Replace globs with equivalent patterns to reduce parsing time.
  REPLACEMENTS: {
    '***': '*',
    '**/**': '**',
    '**/**/**': '**'
  },

  // Digits
  CHAR_0: 48, /* 0 */
  CHAR_9: 57, /* 9 */

  // Alphabet chars.
  CHAR_UPPERCASE_A: 65, /* A */
  CHAR_LOWERCASE_A: 97, /* a */
  CHAR_UPPERCASE_Z: 90, /* Z */
  CHAR_LOWERCASE_Z: 122, /* z */

  CHAR_LEFT_PARENTHESES: 40, /* ( */
  CHAR_RIGHT_PARENTHESES: 41, /* ) */

  CHAR_ASTERISK: 42, /* * */

  // Non-alphabetic chars.
  CHAR_AMPERSAND: 38, /* & */
  CHAR_AT: 64, /* @ */
  CHAR_BACKWARD_SLASH: 92, /* \ */
  CHAR_CARRIAGE_RETURN: 13, /* \r */
  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
  CHAR_COLON: 58, /* : */
  CHAR_COMMA: 44, /* , */
  CHAR_DOT: 46, /* . */
  CHAR_DOUBLE_QUOTE: 34, /* " */
  CHAR_EQUAL: 61, /* = */
  CHAR_EXCLAMATION_MARK: 33, /* ! */
  CHAR_FORM_FEED: 12, /* \f */
  CHAR_FORWARD_SLASH: 47, /* / */
  CHAR_GRAVE_ACCENT: 96, /* ` */
  CHAR_HASH: 35, /* # */
  CHAR_HYPHEN_MINUS: 45, /* - */
  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
  CHAR_LEFT_CURLY_BRACE: 123, /* { */
  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
  CHAR_LINE_FEED: 10, /* \n */
  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
  CHAR_PERCENT: 37, /* % */
  CHAR_PLUS: 43, /* + */
  CHAR_QUESTION_MARK: 63, /* ? */
  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
  CHAR_SEMICOLON: 59, /* ; */
  CHAR_SINGLE_QUOTE: 39, /* ' */
  CHAR_SPACE: 32, /*   */
  CHAR_TAB: 9, /* \t */
  CHAR_UNDERSCORE: 95, /* _ */
  CHAR_VERTICAL_LINE: 124, /* | */
  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */

  SEP: sysPath__default['default'].sep,

  /**
   * Create EXTGLOB_CHARS
   */

  extglobChars(chars) {
    return {
      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
      '?': { type: 'qmark', open: '(?:', close: ')?' },
      '+': { type: 'plus', open: '(?:', close: ')+' },
      '*': { type: 'star', open: '(?:', close: ')*' },
      '@': { type: 'at', open: '(?:', close: ')' }
    };
  },

  /**
   * Create GLOB_CHARS
   */

  globChars(win32) {
    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
  }
};

var utils = createCommonjsModule(function (module, exports) {


const win32 = process.platform === 'win32';
const {
  REGEX_BACKSLASH,
  REGEX_REMOVE_BACKSLASH,
  REGEX_SPECIAL_CHARS,
  REGEX_SPECIAL_CHARS_GLOBAL
} = constants;

exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');

exports.removeBackslashes = str => {
  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
    return match === '\\' ? '' : match;
  });
};

exports.supportsLookbehinds = () => {
  const segs = process.version.slice(1).split('.').map(Number);
  if (segs.length === 3 && segs[0] >= 9 || (segs[0] === 8 && segs[1] >= 10)) {
    return true;
  }
  return false;
};

exports.isWindows = options => {
  if (options && typeof options.windows === 'boolean') {
    return options.windows;
  }
  return win32 === true || sysPath__default['default'].sep === '\\';
};

exports.escapeLast = (input, char, lastIdx) => {
  const idx = input.lastIndexOf(char, lastIdx);
  if (idx === -1) return input;
  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
};

exports.removePrefix = (input, state = {}) => {
  let output = input;
  if (output.startsWith('./')) {
    output = output.slice(2);
    state.prefix = './';
  }
  return output;
};

exports.wrapOutput = (input, state = {}, options = {}) => {
  const prepend = options.contains ? '' : '^';
  const append = options.contains ? '' : '$';

  let output = `${prepend}(?:${input})${append}`;
  if (state.negated === true) {
    output = `(?:^(?!${output}).*$)`;
  }
  return output;
};
});

const {
  CHAR_ASTERISK,             /* * */
  CHAR_AT,                   /* @ */
  CHAR_BACKWARD_SLASH,       /* \ */
  CHAR_COMMA,                /* , */
  CHAR_DOT,                  /* . */
  CHAR_EXCLAMATION_MARK,     /* ! */
  CHAR_FORWARD_SLASH,        /* / */
  CHAR_LEFT_CURLY_BRACE,     /* { */
  CHAR_LEFT_PARENTHESES,     /* ( */
  CHAR_LEFT_SQUARE_BRACKET,  /* [ */
  CHAR_PLUS,                 /* + */
  CHAR_QUESTION_MARK,        /* ? */
  CHAR_RIGHT_CURLY_BRACE,    /* } */
  CHAR_RIGHT_PARENTHESES,    /* ) */
  CHAR_RIGHT_SQUARE_BRACKET  /* ] */
} = constants;

const isPathSeparator = code => {
  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
};

const depth = token => {
  if (token.isPrefix !== true) {
    token.depth = token.isGlobstar ? Infinity : 1;
  }
};

/**
 * Quickly scans a glob pattern and returns an object with a handful of
 * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
 * `glob` (the actual pattern), and `negated` (true if the path starts with `!`).
 *
 * ```js
 * const pm = require('picomatch');
 * console.log(pm.scan('foo/bar/*.js'));
 * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
 * ```
 * @param {String} `str`
 * @param {Object} `options`
 * @return {Object} Returns an object with tokens and regex source string.
 * @api public
 */

const scan = (input, options) => {
  const opts = options || {};

  const length = input.length - 1;
  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
  const slashes = [];
  const tokens = [];
  const parts = [];

  let str = input;
  let index = -1;
  let start = 0;
  let lastIndex = 0;
  let isBrace = false;
  let isBracket = false;
  let isGlob = false;
  let isExtglob = false;
  let isGlobstar = false;
  let braceEscaped = false;
  let backslashes = false;
  let negated = false;
  let finished = false;
  let braces = 0;
  let prev;
  let code;
  let token = { value: '', depth: 0, isGlob: false };

  const eos = () => index >= length;
  const peek = () => str.charCodeAt(index + 1);
  const advance = () => {
    prev = code;
    return str.charCodeAt(++index);
  };

  while (index < length) {
    code = advance();
    let next;

    if (code === CHAR_BACKWARD_SLASH) {
      backslashes = token.backslashes = true;
      code = advance();

      if (code === CHAR_LEFT_CURLY_BRACE) {
        braceEscaped = true;
      }
      continue;
    }

    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
      braces++;

      while (eos() !== true && (code = advance())) {
        if (code === CHAR_BACKWARD_SLASH) {
          backslashes = token.backslashes = true;
          advance();
          continue;
        }

        if (code === CHAR_LEFT_CURLY_BRACE) {
          braces++;
          continue;
        }

        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
          isBrace = token.isBrace = true;
          isGlob = token.isGlob = true;
          finished = true;

          if (scanToEnd === true) {
            continue;
          }

          break;
        }

        if (braceEscaped !== true && code === CHAR_COMMA) {
          isBrace = token.isBrace = true;
          isGlob = token.isGlob = true;
          finished = true;

          if (scanToEnd === true) {
            continue;
          }

          break;
        }

        if (code === CHAR_RIGHT_CURLY_BRACE) {
          braces--;

          if (braces === 0) {
            braceEscaped = false;
            isBrace = token.isBrace = true;
            finished = true;
            break;
          }
        }
      }

      if (scanToEnd === true) {
        continue;
      }

      break;
    }

    if (code === CHAR_FORWARD_SLASH) {
      slashes.push(index);
      tokens.push(token);
      token = { value: '', depth: 0, isGlob: false };

      if (finished === true) continue;
      if (prev === CHAR_DOT && index === (start + 1)) {
        start += 2;
        continue;
      }

      lastIndex = index + 1;
      continue;
    }

    if (opts.noext !== true) {
      const isExtglobChar = code === CHAR_PLUS
        || code === CHAR_AT
        || code === CHAR_ASTERISK
        || code === CHAR_QUESTION_MARK
        || code === CHAR_EXCLAMATION_MARK;

      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
        isGlob = token.isGlob = true;
        isExtglob = token.isExtglob = true;
        finished = true;

        if (scanToEnd === true) {
          while (eos() !== true && (code = advance())) {
            if (code === CHAR_BACKWARD_SLASH) {
              backslashes = token.backslashes = true;
              code = advance();
              continue;
            }

            if (code === CHAR_RIGHT_PARENTHESES) {
              isGlob = token.isGlob = true;
              finished = true;
              break;
            }
          }
          continue;
        }
        break;
      }
    }

    if (code === CHAR_ASTERISK) {
      if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
      isGlob = token.isGlob = true;
      finished = true;

      if (scanToEnd === true) {
        continue;
      }
      break;
    }

    if (code === CHAR_QUESTION_MARK) {
      isGlob = token.isGlob = true;
      finished = true;

      if (scanToEnd === true) {
        continue;
      }
      break;
    }

    if (code === CHAR_LEFT_SQUARE_BRACKET) {
      while (eos() !== true && (next = advance())) {
        if (next === CHAR_BACKWARD_SLASH) {
          backslashes = token.backslashes = true;
          advance();
          continue;
        }

        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
          isBracket = token.isBracket = true;
          isGlob = token.isGlob = true;
          finished = true;

          if (scanToEnd === true) {
            continue;
          }
          break;
        }
      }
    }

    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
      negated = token.negated = true;
      start++;
      continue;
    }

    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
      isGlob = token.isGlob = true;

      if (scanToEnd === true) {
        while (eos() !== true && (code = advance())) {
          if (code === CHAR_LEFT_PARENTHESES) {
            backslashes = token.backslashes = true;
            code = advance();
            continue;
          }

          if (code === CHAR_RIGHT_PARENTHESES) {
            finished = true;
            break;
          }
        }
        continue;
      }
      break;
    }

    if (isGlob === true) {
      finished = true;

      if (scanToEnd === true) {
        continue;
      }

      break;
    }
  }

  if (opts.noext === true) {
    isExtglob = false;
    isGlob = false;
  }

  let base = str;
  let prefix = '';
  let glob = '';

  if (start > 0) {
    prefix = str.slice(0, start);
    str = str.slice(start);
    lastIndex -= start;
  }

  if (base && isGlob === true && lastIndex > 0) {
    base = str.slice(0, lastIndex);
    glob = str.slice(lastIndex);
  } else if (isGlob === true) {
    base = '';
    glob = str;
  } else {
    base = str;
  }

  if (base && base !== '' && base !== '/' && base !== str) {
    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
      base = base.slice(0, -1);
    }
  }

  if (opts.unescape === true) {
    if (glob) glob = utils.removeBackslashes(glob);

    if (base && backslashes === true) {
      base = utils.removeBackslashes(base);
    }
  }

  const state = {
    prefix,
    input,
    start,
    base,
    glob,
    isBrace,
    isBracket,
    isGlob,
    isExtglob,
    isGlobstar,
    negated
  };

  if (opts.tokens === true) {
    state.maxDepth = 0;
    if (!isPathSeparator(code)) {
      tokens.push(token);
    }
    state.tokens = tokens;
  }

  if (opts.parts === true || opts.tokens === true) {
    let prevIndex;

    for (let idx = 0; idx < slashes.length; idx++) {
      const n = prevIndex ? prevIndex + 1 : start;
      const i = slashes[idx];
      const value = input.slice(n, i);
      if (opts.tokens) {
        if (idx === 0 && start !== 0) {
          tokens[idx].isPrefix = true;
          tokens[idx].value = prefix;
        } else {
          tokens[idx].value = value;
        }
        depth(tokens[idx]);
        state.maxDepth += tokens[idx].depth;
      }
      if (idx !== 0 || value !== '') {
        parts.push(value);
      }
      prevIndex = i;
    }

    if (prevIndex && prevIndex + 1 < input.length) {
      const value = input.slice(prevIndex + 1);
      parts.push(value);

      if (opts.tokens) {
        tokens[tokens.length - 1].value = value;
        depth(tokens[tokens.length - 1]);
        state.maxDepth += tokens[tokens.length - 1].depth;
      }
    }

    state.slashes = slashes;
    state.parts = parts;
  }

  return state;
};

var scan_1 = scan;

/**
 * Constants
 */

const {
  MAX_LENGTH,
  POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
  REGEX_NON_SPECIAL_CHARS,
  REGEX_SPECIAL_CHARS_BACKREF,
  REPLACEMENTS
} = constants;

/**
 * Helpers
 */

const expandRange = (args, options) => {
  if (typeof options.expandRange === 'function') {
    return options.expandRange(...args, options);
  }

  args.sort();
  const value = `[${args.join('-')}]`;

  try {
    /* eslint-disable-next-line no-new */
    new RegExp(value);
  } catch (ex) {
    return args.map(v => utils.escapeRegex(v)).join('..');
  }

  return value;
};

/**
 * Create the message for a syntax error
 */

const syntaxError = (type, char) => {
  return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
};

/**
 * Parse the given input string.
 * @param {String} input
 * @param {Object} options
 * @return {Object}
 */

const parse = (input, options) => {
  if (typeof input !== 'string') {
    throw new TypeError('Expected a string');
  }

  input = REPLACEMENTS[input] || input;

  const opts = { ...options };
  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;

  let len = input.length;
  if (len > max) {
    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
  }

  const bos = { type: 'bos', value: '', output: opts.prepend || '' };
  const tokens = [bos];

  const capture = opts.capture ? '' : '?:';
  const win32 = utils.isWindows(options);

  // create constants based on platform, for windows or posix
  const PLATFORM_CHARS = constants.globChars(win32);
  const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);

  const {
    DOT_LITERAL,
    PLUS_LITERAL,
    SLASH_LITERAL,
    ONE_CHAR,
    DOTS_SLASH,
    NO_DOT,
    NO_DOT_SLASH,
    NO_DOTS_SLASH,
    QMARK,
    QMARK_NO_DOT,
    STAR,
    START_ANCHOR
  } = PLATFORM_CHARS;

  const globstar = (opts) => {
    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
  };

  const nodot = opts.dot ? '' : NO_DOT;
  const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
  let star = opts.bash === true ? globstar(opts) : STAR;

  if (opts.capture) {
    star = `(${star})`;
  }

  // minimatch options support
  if (typeof opts.noext === 'boolean') {
    opts.noextglob = opts.noext;
  }

  const state = {
    input,
    index: -1,
    start: 0,
    dot: opts.dot === true,
    consumed: '',
    output: '',
    prefix: '',
    backtrack: false,
    negated: false,
    brackets: 0,
    braces: 0,
    parens: 0,
    quotes: 0,
    globstar: false,
    tokens
  };

  input = utils.removePrefix(input, state);
  len = input.length;

  const extglobs = [];
  const braces = [];
  const stack = [];
  let prev = bos;
  let value;

  /**
   * Tokenizing helpers
   */

  const eos = () => state.index === len - 1;
  const peek = state.peek = (n = 1) => input[state.index + n];
  const advance = state.advance = () => input[++state.index];
  const remaining = () => input.slice(state.index + 1);
  const consume = (value = '', num = 0) => {
    state.consumed += value;
    state.index += num;
  };
  const append = token => {
    state.output += token.output != null ? token.output : token.value;
    consume(token.value);
  };

  const negate = () => {
    let count = 1;

    while (peek() === '!' && (peek(2) !== '(' || peek(3) === '?')) {
      advance();
      state.start++;
      count++;
    }

    if (count % 2 === 0) {
      return false;
    }

    state.negated = true;
    state.start++;
    return true;
  };

  const increment = type => {
    state[type]++;
    stack.push(type);
  };

  const decrement = type => {
    state[type]--;
    stack.pop();
  };

  /**
   * Push tokens onto the tokens array. This helper speeds up
   * tokenizing by 1) helping us avoid backtracking as much as possible,
   * and 2) helping us avoid creating extra tokens when consecutive
   * characters are plain text. This improves performance and simplifies
   * lookbehinds.
   */

  const push = tok => {
    if (prev.type === 'globstar') {
      const isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
      const isExtglob = tok.extglob === true || (extglobs.length && (tok.type === 'pipe' || tok.type === 'paren'));

      if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
        state.output = state.output.slice(0, -prev.output.length);
        prev.type = 'star';
        prev.value = '*';
        prev.output = star;
        state.output += prev.output;
      }
    }

    if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) {
      extglobs[extglobs.length - 1].inner += tok.value;
    }

    if (tok.value || tok.output) append(tok);
    if (prev && prev.type === 'text' && tok.type === 'text') {
      prev.value += tok.value;
      prev.output = (prev.output || '') + tok.value;
      return;
    }

    tok.prev = prev;
    tokens.push(tok);
    prev = tok;
  };

  const extglobOpen = (type, value) => {
    const token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };

    token.prev = prev;
    token.parens = state.parens;
    token.output = state.output;
    const output = (opts.capture ? '(' : '') + token.open;

    increment('parens');
    push({ type, value, output: state.output ? '' : ONE_CHAR });
    push({ type: 'paren', extglob: true, value: advance(), output });
    extglobs.push(token);
  };

  const extglobClose = token => {
    let output = token.close + (opts.capture ? ')' : '');

    if (token.type === 'negate') {
      let extglobStar = star;

      if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
        extglobStar = globstar(opts);
      }

      if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
        output = token.close = `)$))${extglobStar}`;
      }

      if (token.prev.type === 'bos' && eos()) {
        state.negatedExtglob = true;
      }
    }

    push({ type: 'paren', extglob: true, value, output });
    decrement('parens');
  };

  /**
   * Fast paths
   */

  if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
    let backslashes = false;

    let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
      if (first === '\\') {
        backslashes = true;
        return m;
      }

      if (first === '?') {
        if (esc) {
          return esc + first + (rest ? QMARK.repeat(rest.length) : '');
        }
        if (index === 0) {
          return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
        }
        return QMARK.repeat(chars.length);
      }

      if (first === '.') {
        return DOT_LITERAL.repeat(chars.length);
      }

      if (first === '*') {
        if (esc) {
          return esc + first + (rest ? star : '');
        }
        return star;
      }
      return esc ? m : `\\${m}`;
    });

    if (backslashes === true) {
      if (opts.unescape === true) {
        output = output.replace(/\\/g, '');
      } else {
        output = output.replace(/\\+/g, m => {
          return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
        });
      }
    }

    if (output === input && opts.contains === true) {
      state.output = input;
      return state;
    }

    state.output = utils.wrapOutput(output, state, options);
    return state;
  }

  /**
   * Tokenize input until we reach end-of-string
   */

  while (!eos()) {
    value = advance();

    if (value === '\u0000') {
      continue;
    }

    /**
     * Escaped characters
     */

    if (value === '\\') {
      const next = peek();

      if (next === '/' && opts.bash !== true) {
        continue;
      }

      if (next === '.' || next === ';') {
        continue;
      }

      if (!next) {
        value += '\\';
        push({ type: 'text', value });
        continue;
      }

      // collapse slashes to reduce potential for exploits
      const match = /^\\+/.exec(remaining());
      let slashes = 0;

      if (match && match[0].length > 2) {
        slashes = match[0].length;
        state.index += slashes;
        if (slashes % 2 !== 0) {
          value += '\\';
        }
      }

      if (opts.unescape === true) {
        value = advance() || '';
      } else {
        value += advance() || '';
      }

      if (state.brackets === 0) {
        push({ type: 'text', value });
        continue;
      }
    }

    /**
     * If we're inside a regex character class, continue
     * until we reach the closing bracket.
     */

    if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
      if (opts.posix !== false && value === ':') {
        const inner = prev.value.slice(1);
        if (inner.includes('[')) {
          prev.posix = true;

          if (inner.includes(':')) {
            const idx = prev.value.lastIndexOf('[');
            const pre = prev.value.slice(0, idx);
            const rest = prev.value.slice(idx + 2);
            const posix = POSIX_REGEX_SOURCE$1[rest];
            if (posix) {
              prev.value = pre + posix;
              state.backtrack = true;
              advance();

              if (!bos.output && tokens.indexOf(prev) === 1) {
                bos.output = ONE_CHAR;
              }
              continue;
            }
          }
        }
      }

      if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
        value = `\\${value}`;
      }

      if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
        value = `\\${value}`;
      }

      if (opts.posix === true && value === '!' && prev.value === '[') {
        value = '^';
      }

      prev.value += value;
      append({ value });
      continue;
    }

    /**
     * If we're inside a quoted string, continue
     * until we reach the closing double quote.
     */

    if (state.quotes === 1 && value !== '"') {
      value = utils.escapeRegex(value);
      prev.value += value;
      append({ value });
      continue;
    }

    /**
     * Double quotes
     */

    if (value === '"') {
      state.quotes = state.quotes === 1 ? 0 : 1;
      if (opts.keepQuotes === true) {
        push({ type: 'text', value });
      }
      continue;
    }

    /**
     * Parentheses
     */

    if (value === '(') {
      increment('parens');
      push({ type: 'paren', value });
      continue;
    }

    if (value === ')') {
      if (state.parens === 0 && opts.strictBrackets === true) {
        throw new SyntaxError(syntaxError('opening', '('));
      }

      const extglob = extglobs[extglobs.length - 1];
      if (extglob && state.parens === extglob.parens + 1) {
        extglobClose(extglobs.pop());
        continue;
      }

      push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
      decrement('parens');
      continue;
    }

    /**
     * Square brackets
     */

    if (value === '[') {
      if (opts.nobracket === true || !remaining().includes(']')) {
        if (opts.nobracket !== true && opts.strictBrackets === true) {
          throw new SyntaxError(syntaxError('closing', ']'));
        }

        value = `\\${value}`;
      } else {
        increment('brackets');
      }

      push({ type: 'bracket', value });
      continue;
    }

    if (value === ']') {
      if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
        push({ type: 'text', value, output: `\\${value}` });
        continue;
      }

      if (state.brackets === 0) {
        if (opts.strictBrackets === true) {
          throw new SyntaxError(syntaxError('opening', '['));
        }

        push({ type: 'text', value, output: `\\${value}` });
        continue;
      }

      decrement('brackets');

      const prevValue = prev.value.slice(1);
      if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
        value = `/${value}`;
      }

      prev.value += value;
      append({ value });

      // when literal brackets are explicitly disabled
      // assume we should match with a regex character class
      if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
        continue;
      }

      const escaped = utils.escapeRegex(prev.value);
      state.output = state.output.slice(0, -prev.value.length);

      // when literal brackets are explicitly enabled
      // assume we should escape the brackets to match literal characters
      if (opts.literalBrackets === true) {
        state.output += escaped;
        prev.value = escaped;
        continue;
      }

      // when the user specifies nothing, try to match both
      prev.value = `(${capture}${escaped}|${prev.value})`;
      state.output += prev.value;
      continue;
    }

    /**
     * Braces
     */

    if (value === '{' && opts.nobrace !== true) {
      increment('braces');

      const open = {
        type: 'brace',
        value,
        output: '(',
        outputIndex: state.output.length,
        tokensIndex: state.tokens.length
      };

      braces.push(open);
      push(open);
      continue;
    }

    if (value === '}') {
      const brace = braces[braces.length - 1];

      if (opts.nobrace === true || !brace) {
        push({ type: 'text', value, output: value });
        continue;
      }

      let output = ')';

      if (brace.dots === true) {
        const arr = tokens.slice();
        const range = [];

        for (let i = arr.length - 1; i >= 0; i--) {
          tokens.pop();
          if (arr[i].type === 'brace') {
            break;
          }
          if (arr[i].type !== 'dots') {
            range.unshift(arr[i].value);
          }
        }

        output = expandRange(range, opts);
        state.backtrack = true;
      }

      if (brace.comma !== true && brace.dots !== true) {
        const out = state.output.slice(0, brace.outputIndex);
        const toks = state.tokens.slice(brace.tokensIndex);
        brace.value = brace.output = '\\{';
        value = output = '\\}';
        state.output = out;
        for (const t of toks) {
          state.output += (t.output || t.value);
        }
      }

      push({ type: 'brace', value, output });
      decrement('braces');
      braces.pop();
      continue;
    }

    /**
     * Pipes
     */

    if (value === '|') {
      if (extglobs.length > 0) {
        extglobs[extglobs.length - 1].conditions++;
      }
      push({ type: 'text', value });
      continue;
    }

    /**
     * Commas
     */

    if (value === ',') {
      let output = value;

      const brace = braces[braces.length - 1];
      if (brace && stack[stack.length - 1] === 'braces') {
        brace.comma = true;
        output = '|';
      }

      push({ type: 'comma', value, output });
      continue;
    }

    /**
     * Slashes
     */

    if (value === '/') {
      // if the beginning of the glob is "./", advance the start
      // to the current index, and don't add the "./" characters
      // to the state. This greatly simplifies lookbehinds when
      // checking for BOS characters like "!" and "." (not "./")
      if (prev.type === 'dot' && state.index === state.start + 1) {
        state.start = state.index + 1;
        state.consumed = '';
        state.output = '';
        tokens.pop();
        prev = bos; // reset "prev" to the first token
        continue;
      }

      push({ type: 'slash', value, output: SLASH_LITERAL });
      continue;
    }

    /**
     * Dots
     */

    if (value === '.') {
      if (state.braces > 0 && prev.type === 'dot') {
        if (prev.value === '.') prev.output = DOT_LITERAL;
        const brace = braces[braces.length - 1];
        prev.type = 'dots';
        prev.output += value;
        prev.value += value;
        brace.dots = true;
        continue;
      }

      if ((state.braces + state.parens) === 0 && prev.type !== 'bos' && prev.type !== 'slash') {
        push({ type: 'text', value, output: DOT_LITERAL });
        continue;
      }

      push({ type: 'dot', value, output: DOT_LITERAL });
      continue;
    }

    /**
     * Question marks
     */

    if (value === '?') {
      const isGroup = prev && prev.value === '(';
      if (!isGroup && opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
        extglobOpen('qmark', value);
        continue;
      }

      if (prev && prev.type === 'paren') {
        const next = peek();
        let output = value;

        if (next === '<' && !utils.supportsLookbehinds()) {
          throw new Error('Node.js v10 or higher is required for regex lookbehinds');
        }

        if ((prev.value === '(' && !/[!=<:]/.test(next)) || (next === '<' && !/<([!=]|\w+>)/.test(remaining()))) {
          output = `\\${value}`;
        }

        push({ type: 'text', value, output });
        continue;
      }

      if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
        push({ type: 'qmark', value, output: QMARK_NO_DOT });
        continue;
      }

      push({ type: 'qmark', value, output: QMARK });
      continue;
    }

    /**
     * Exclamation
     */

    if (value === '!') {
      if (opts.noextglob !== true && peek() === '(') {
        if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
          extglobOpen('negate', value);
          continue;
        }
      }

      if (opts.nonegate !== true && state.index === 0) {
        negate();
        continue;
      }
    }

    /**
     * Plus
     */

    if (value === '+') {
      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
        extglobOpen('plus', value);
        continue;
      }

      if ((prev && prev.value === '(') || opts.regex === false) {
        push({ type: 'plus', value, output: PLUS_LITERAL });
        continue;
      }

      if ((prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) || state.parens > 0) {
        push({ type: 'plus', value });
        continue;
      }

      push({ type: 'plus', value: PLUS_LITERAL });
      continue;
    }

    /**
     * Plain text
     */

    if (value === '@') {
      if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
        push({ type: 'at', extglob: true, value, output: '' });
        continue;
      }

      push({ type: 'text', value });
      continue;
    }

    /**
     * Plain text
     */

    if (value !== '*') {
      if (value === '$' || value === '^') {
        value = `\\${value}`;
      }

      const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
      if (match) {
        value += match[0];
        state.index += match[0].length;
      }

      push({ type: 'text', value });
      continue;
    }

    /**
     * Stars
     */

    if (prev && (prev.type === 'globstar' || prev.star === true)) {
      prev.type = 'star';
      prev.star = true;
      prev.value += value;
      prev.output = star;
      state.backtrack = true;
      state.globstar = true;
      consume(value);
      continue;
    }

    let rest = remaining();
    if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
      extglobOpen('star', value);
      continue;
    }

    if (prev.type === 'star') {
      if (opts.noglobstar === true) {
        consume(value);
        continue;
      }

      const prior = prev.prev;
      const before = prior.prev;
      const isStart = prior.type === 'slash' || prior.type === 'bos';
      const afterStar = before && (before.type === 'star' || before.type === 'globstar');

      if (opts.bash === true && (!isStart || (rest[0] && rest[0] !== '/'))) {
        push({ type: 'star', value, output: '' });
        continue;
      }

      const isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
      const isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
      if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
        push({ type: 'star', value, output: '' });
        continue;
      }

      // strip consecutive `/**/`
      while (rest.slice(0, 3) === '/**') {
        const after = input[state.index + 4];
        if (after && after !== '/') {
          break;
        }
        rest = rest.slice(3);
        consume('/**', 3);
      }

      if (prior.type === 'bos' && eos()) {
        prev.type = 'globstar';
        prev.value += value;
        prev.output = globstar(opts);
        state.output = prev.output;
        state.globstar = true;
        consume(value);
        continue;
      }

      if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
        state.output = state.output.slice(0, -(prior.output + prev.output).length);
        prior.output = `(?:${prior.output}`;

        prev.type = 'globstar';
        prev.output = globstar(opts) + (opts.strictSlashes ? ')' : '|$)');
        prev.value += value;
        state.globstar = true;
        state.output += prior.output + prev.output;
        consume(value);
        continue;
      }

      if (prior.type === 'slash' && prior.prev.type !== 'bos' && rest[0] === '/') {
        const end = rest[1] !== void 0 ? '|$' : '';

        state.output = state.output.slice(0, -(prior.output + prev.output).length);
        prior.output = `(?:${prior.output}`;

        prev.type = 'globstar';
        prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
        prev.value += value;

        state.output += prior.output + prev.output;
        state.globstar = true;

        consume(value + advance());

        push({ type: 'slash', value: '/', output: '' });
        continue;
      }

      if (prior.type === 'bos' && rest[0] === '/') {
        prev.type = 'globstar';
        prev.value += value;
        prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
        state.output = prev.output;
        state.globstar = true;
        consume(value + advance());
        push({ type: 'slash', value: '/', output: '' });
        continue;
      }

      // remove single star from output
      state.output = state.output.slice(0, -prev.output.length);

      // reset previous token to globstar
      prev.type = 'globstar';
      prev.output = globstar(opts);
      prev.value += value;

      // reset output with globstar
      state.output += prev.output;
      state.globstar = true;
      consume(value);
      continue;
    }

    const token = { type: 'star', value, output: star };

    if (opts.bash === true) {
      token.output = '.*?';
      if (prev.type === 'bos' || prev.type === 'slash') {
        token.output = nodot + token.output;
      }
      push(token);
      continue;
    }

    if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
      token.output = value;
      push(token);
      continue;
    }

    if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
      if (prev.type === 'dot') {
        state.output += NO_DOT_SLASH;
        prev.output += NO_DOT_SLASH;

      } else if (opts.dot === true) {
        state.output += NO_DOTS_SLASH;
        prev.output += NO_DOTS_SLASH;

      } else {
        state.output += nodot;
        prev.output += nodot;
      }

      if (peek() !== '*') {
        state.output += ONE_CHAR;
        prev.output += ONE_CHAR;
      }
    }

    push(token);
  }

  while (state.brackets > 0) {
    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
    state.output = utils.escapeLast(state.output, '[');
    decrement('brackets');
  }

  while (state.parens > 0) {
    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
    state.output = utils.escapeLast(state.output, '(');
    decrement('parens');
  }

  while (state.braces > 0) {
    if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
    state.output = utils.escapeLast(state.output, '{');
    decrement('braces');
  }

  if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
    push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
  }

  // rebuild the output if we had to backtrack at any point
  if (state.backtrack === true) {
    state.output = '';

    for (const token of state.tokens) {
      state.output += token.output != null ? token.output : token.value;

      if (token.suffix) {
        state.output += token.suffix;
      }
    }
  }

  return state;
};

/**
 * Fast paths for creating regular expressions for common glob patterns.
 * This can significantly speed up processing and has very little downside
 * impact when none of the fast paths match.
 */

parse.fastpaths = (input, options) => {
  const opts = { ...options };
  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
  const len = input.length;
  if (len > max) {
    throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
  }

  input = REPLACEMENTS[input] || input;
  const win32 = utils.isWindows(options);

  // create constants based on platform, for windows or posix
  const {
    DOT_LITERAL,
    SLASH_LITERAL,
    ONE_CHAR,
    DOTS_SLASH,
    NO_DOT,
    NO_DOTS,
    NO_DOTS_SLASH,
    STAR,
    START_ANCHOR
  } = constants.globChars(win32);

  const nodot = opts.dot ? NO_DOTS : NO_DOT;
  const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
  const capture = opts.capture ? '' : '?:';
  const state = { negated: false, prefix: '' };
  let star = opts.bash === true ? '.*?' : STAR;

  if (opts.capture) {
    star = `(${star})`;
  }

  const globstar = (opts) => {
    if (opts.noglobstar === true) return star;
    return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
  };

  const create = str => {
    switch (str) {
      case '*':
        return `${nodot}${ONE_CHAR}${star}`;

      case '.*':
        return `${DOT_LITERAL}${ONE_CHAR}${star}`;

      case '*.*':
        return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;

      case '*/*':
        return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;

      case '**':
        return nodot + globstar(opts);

      case '**/*':
        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;

      case '**/*.*':
        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;

      case '**/.*':
        return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;

      default: {
        const match = /^(.*?)\.(\w+)$/.exec(str);
        if (!match) return;

        const source = create(match[1]);
        if (!source) return;

        return source + DOT_LITERAL + match[2];
      }
    }
  };

  const output = utils.removePrefix(input, state);
  let source = create(output);

  if (source && opts.strictSlashes !== true) {
    source += `${SLASH_LITERAL}?`;
  }

  return source;
};

var parse_1 = parse;

const isObject = val => val && typeof val === 'object' && !Array.isArray(val);

/**
 * Creates a matcher function from one or more glob patterns. The
 * returned function takes a string to match as its first argument,
 * and returns true if the string is a match. The returned matcher
 * function also takes a boolean as the second argument that, when true,
 * returns an object with additional information.
 *
 * ```js
 * const picomatch = require('picomatch');
 * // picomatch(glob[, options]);
 *
 * const isMatch = picomatch('*.!(*a)');
 * console.log(isMatch('a.a')); //=> false
 * console.log(isMatch('a.b')); //=> true
 * ```
 * @name picomatch
 * @param {String|Array} `globs` One or more glob patterns.
 * @param {Object=} `options`
 * @return {Function=} Returns a matcher function.
 * @api public
 */

const picomatch = (glob, options, returnState = false) => {
  if (Array.isArray(glob)) {
    const fns = glob.map(input => picomatch(input, options, returnState));
    const arrayMatcher = str => {
      for (const isMatch of fns) {
        const state = isMatch(str);
        if (state) return state;
      }
      return false;
    };
    return arrayMatcher;
  }

  const isState = isObject(glob) && glob.tokens && glob.input;

  if (glob === '' || (typeof glob !== 'string' && !isState)) {
    throw new TypeError('Expected pattern to be a non-empty string');
  }

  const opts = options || {};
  const posix = utils.isWindows(options);
  const regex = isState
    ? picomatch.compileRe(glob, options)
    : picomatch.makeRe(glob, options, false, true);

  const state = regex.state;
  delete regex.state;

  let isIgnored = () => false;
  if (opts.ignore) {
    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
    isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
  }

  const matcher = (input, returnObject = false) => {
    const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
    const result = { glob, state, regex, posix, input, output, match, isMatch };

    if (typeof opts.onResult === 'function') {
      opts.onResult(result);
    }

    if (isMatch === false) {
      result.isMatch = false;
      return returnObject ? result : false;
    }

    if (isIgnored(input)) {
      if (typeof opts.onIgnore === 'function') {
        opts.onIgnore(result);
      }
      result.isMatch = false;
      return returnObject ? result : false;
    }

    if (typeof opts.onMatch === 'function') {
      opts.onMatch(result);
    }
    return returnObject ? result : true;
  };

  if (returnState) {
    matcher.state = state;
  }

  return matcher;
};

/**
 * Test `input` with the given `regex`. This is used by the main
 * `picomatch()` function to test the input string.
 *
 * ```js
 * const picomatch = require('picomatch');
 * // picomatch.test(input, regex[, options]);
 *
 * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
 * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
 * ```
 * @param {String} `input` String to test.
 * @param {RegExp} `regex`
 * @return {Object} Returns an object with matching info.
 * @api public
 */

picomatch.test = (input, regex, options, { glob, posix } = {}) => {
  if (typeof input !== 'string') {
    throw new TypeError('Expected input to be a string');
  }

  if (input === '') {
    return { isMatch: false, output: '' };
  }

  const opts = options || {};
  const format = opts.format || (posix ? utils.toPosixSlashes : null);
  let match = input === glob;
  let output = (match && format) ? format(input) : input;

  if (match === false) {
    output = format ? format(input) : input;
    match = output === glob;
  }

  if (match === false || opts.capture === true) {
    if (opts.matchBase === true || opts.basename === true) {
      match = picomatch.matchBase(input, regex, options, posix);
    } else {
      match = regex.exec(output);
    }
  }

  return { isMatch: Boolean(match), match, output };
};

/**
 * Match the basename of a filepath.
 *
 * ```js
 * const picomatch = require('picomatch');
 * // picomatch.matchBase(input, glob[, options]);
 * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
 * ```
 * @param {String} `input` String to test.
 * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
 * @return {Boolean}
 * @api public
 */

picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
  return regex.test(sysPath__default['default'].basename(input));
};

/**
 * Returns true if **any** of the given glob `patterns` match the specified `string`.
 *
 * ```js
 * const picomatch = require('picomatch');
 * // picomatch.isMatch(string, patterns[, options]);
 *
 * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
 * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
 * ```
 * @param {String|Array} str The string to test.
 * @param {String|Array} patterns One or more glob patterns to use for matching.
 * @param {Object} [options] See available [options](#options).
 * @return {Boolean} Returns true if any patterns match `str`
 * @api public
 */

picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);

/**
 * Parse a glob pattern to create the source string for a regular
 * expression.
 *
 * ```js
 * const picomatch = require('picomatch');
 * const result = picomatch.parse(pattern[, options]);
 * ```
 * @param {String} `pattern`
 * @param {Object} `options`
 * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
 * @api public
 */

picomatch.parse = (pattern, options) => {
  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
  return parse_1(pattern, { ...options, fastpaths: false });
};

/**
 * Scan a glob pattern to separate the pattern into segments.
 *
 * ```js
 * const picomatch = require('picomatch');
 * // picomatch.scan(input[, options]);
 *
 * const result = picomatch.scan('!./foo/*.js');
 * console.log(result);
 * { prefix: '!./',
 *   input: '!./foo/*.js',
 *   start: 3,
 *   base: 'foo',
 *   glob: '*.js',
 *   isBrace: false,
 *   isBracket: false,
 *   isGlob: true,
 *   isExtglob: false,
 *   isGlobstar: false,
 *   negated: true }
 * ```
 * @param {String} `input` Glob pattern to scan.
 * @param {Object} `options`
 * @return {Object} Returns an object with
 * @api public
 */

picomatch.scan = (input, options) => scan_1(input, options);

/**
 * Create a regular expression from a parsed glob pattern.
 *
 * ```js
 * const picomatch = require('picomatch');
 * const state = picomatch.parse('*.js');
 * // picomatch.compileRe(state[, options]);
 *
 * console.log(picomatch.compileRe(state));
 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
 * ```
 * @param {String} `state` The object returned from the `.parse` method.
 * @param {Object} `options`
 * @return {RegExp} Returns a regex created from the given pattern.
 * @api public
 */

picomatch.compileRe = (parsed, options, returnOutput = false, returnState = false) => {
  if (returnOutput === true) {
    return parsed.output;
  }

  const opts = options || {};
  const prepend = opts.contains ? '' : '^';
  const append = opts.contains ? '' : '$';

  let source = `${prepend}(?:${parsed.output})${append}`;
  if (parsed && parsed.negated === true) {
    source = `^(?!${source}).*$`;
  }

  const regex = picomatch.toRegex(source, options);
  if (returnState === true) {
    regex.state = parsed;
  }

  return regex;
};

picomatch.makeRe = (input, options, returnOutput = false, returnState = false) => {
  if (!input || typeof input !== 'string') {
    throw new TypeError('Expected a non-empty string');
  }

  const opts = options || {};
  let parsed = { negated: false, fastpaths: true };
  let prefix = '';
  let output;

  if (input.startsWith('./')) {
    input = input.slice(2);
    prefix = parsed.prefix = './';
  }

  if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
    output = parse_1.fastpaths(input, options);
  }

  if (output === undefined) {
    parsed = parse_1(input, options);
    parsed.prefix = prefix + (parsed.prefix || '');
  } else {
    parsed.output = output;
  }

  return picomatch.compileRe(parsed, options, returnOutput, returnState);
};

/**
 * Create a regular expression from the given regex source string.
 *
 * ```js
 * const picomatch = require('picomatch');
 * // picomatch.toRegex(source[, options]);
 *
 * const { output } = picomatch.parse('*.js');
 * console.log(picomatch.toRegex(output));
 * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
 * ```
 * @param {String} `source` Regular expression source string.
 * @param {Object} `options`
 * @return {RegExp}
 * @api public
 */

picomatch.toRegex = (source, options) => {
  try {
    const opts = options || {};
    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
  } catch (err) {
    if (options && options.debug === true) throw err;
    return /$^/;
  }
};

/**
 * Picomatch constants.
 * @return {Object}
 */

picomatch.constants = constants;

/**
 * Expose "picomatch"
 */

var picomatch_1 = picomatch;

var picomatch$1 = picomatch_1;

const { Readable } = require$$0__default$1['default'];

const { promisify } = require$$0__default['default'];


const readdir = promisify(fs__default['default'].readdir);
const stat = promisify(fs__default['default'].stat);
const lstat = promisify(fs__default['default'].lstat);
const realpath = promisify(fs__default['default'].realpath);

/**
 * @typedef {Object} EntryInfo
 * @property {String} path
 * @property {String} fullPath
 * @property {fs.Stats=} stats
 * @property {fs.Dirent=} dirent
 * @property {String} basename
 */

const BANG = '!';
const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP']);
const FILE_TYPE = 'files';
const DIR_TYPE = 'directories';
const FILE_DIR_TYPE = 'files_directories';
const EVERYTHING_TYPE = 'all';
const ALL_TYPES = [FILE_TYPE, DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE];

const isNormalFlowError = error => NORMAL_FLOW_ERRORS.has(error.code);

const normalizeFilter = filter => {
  if (filter === undefined) return;
  if (typeof filter === 'function') return filter;

  if (typeof filter === 'string') {
    const glob = picomatch$1(filter.trim());
    return entry => glob(entry.basename);
  }

  if (Array.isArray(filter)) {
    const positive = [];
    const negative = [];
    for (const item of filter) {
      const trimmed = item.trim();
      if (trimmed.charAt(0) === BANG) {
        negative.push(picomatch$1(trimmed.slice(1)));
      } else {
        positive.push(picomatch$1(trimmed));
      }
    }

    if (negative.length > 0) {
      if (positive.length > 0) {
        return entry =>
          positive.some(f => f(entry.basename)) && !negative.some(f => f(entry.basename));
      }
      return entry => !negative.some(f => f(entry.basename));
    }
    return entry => positive.some(f => f(entry.basename));
  }
};

class ReaddirpStream extends Readable {
  static get defaultOptions() {
    return {
      root: '.',
      /* eslint-disable no-unused-vars */
      fileFilter: (path) => true,
      directoryFilter: (path) => true,
      /* eslint-enable no-unused-vars */
      type: FILE_TYPE,
      lstat: false,
      depth: 2147483648,
      alwaysStat: false
    };
  }

  constructor(options = {}) {
    super({
      objectMode: true,
      autoDestroy: true,
      highWaterMark: options.highWaterMark || 4096
    });
    const opts = { ...ReaddirpStream.defaultOptions, ...options };
    const { root, type } = opts;

    this._fileFilter = normalizeFilter(opts.fileFilter);
    this._directoryFilter = normalizeFilter(opts.directoryFilter);

    const statMethod = opts.lstat ? lstat : stat;
    // Use bigint stats if it's windows and stat() supports options (node 10+).
    if (process.platform === 'win32' && stat.length === 3) {
      this._stat = path => statMethod(path, { bigint: true });
    } else {
      this._stat = statMethod;
    }

    this._maxDepth = opts.depth;
    this._wantsDir = [DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
    this._wantsFile = [FILE_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
    this._wantsEverything = type === EVERYTHING_TYPE;
    this._root = sysPath__default['default'].resolve(root);
    this._isDirent = ('Dirent' in fs__default['default']) && !opts.alwaysStat;
    this._statsProp = this._isDirent ? 'dirent' : 'stats';
    this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };

    // Launch stream with one parent, the root dir.
    this.parents = [this._exploreDir(root, 1)];
    this.reading = false;
    this.parent = undefined;
  }

  async _read(batch) {
    if (this.reading) return;
    this.reading = true;

    try {
      while (!this.destroyed && batch > 0) {
        const { path, depth, files = [] } = this.parent || {};

        if (files.length > 0) {
          const slice = files.splice(0, batch).map(dirent => this._formatEntry(dirent, path));
          for (const entry of await Promise.all(slice)) {
            if (this.destroyed) return;

            const entryType = await this._getEntryType(entry);
            if (entryType === 'directory' && this._directoryFilter(entry)) {
              if (depth <= this._maxDepth) {
                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
              }

              if (this._wantsDir) {
                this.push(entry);
                batch--;
              }
            } else if ((entryType === 'file' || this._includeAsFile(entry)) && this._fileFilter(entry)) {
              if (this._wantsFile) {
                this.push(entry);
                batch--;
              }
            }
          }
        } else {
          const parent = this.parents.pop();
          if (!parent) {
            this.push(null);
            break;
          }
          this.parent = await parent;
          if (this.destroyed) return;
        }
      }
    } catch (error) {
      this.destroy(error);
    } finally {
      this.reading = false;
    }
  }

  async _exploreDir(path, depth) {
    let files;
    try {
      files = await readdir(path, this._rdOptions);
    } catch (error) {
      this._onError(error);
    }
    return {files, depth, path};
  }

  async _formatEntry(dirent, path) {
    let entry;
    try {
      const basename = this._isDirent ? dirent.name : dirent;
      const fullPath = sysPath__default['default'].resolve(sysPath__default['default'].join(path, basename));
      entry = {path: sysPath__default['default'].relative(this._root, fullPath), fullPath, basename};
      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
    } catch (err) {
      this._onError(err);
    }
    return entry;
  }

  _onError(err) {
    if (isNormalFlowError(err) && !this.destroyed) {
      this.emit('warn', err);
    } else {
      this.destroy(err);
    }
  }

  async _getEntryType(entry) {
    // entry may be undefined, because a warning or an error were emitted
    // and the statsProp is undefined
    const stats = entry && entry[this._statsProp];
    if (!stats) {
      return;
    }
    if (stats.isFile()) {
      return 'file';
    }
    if (stats.isDirectory()) {
      return 'directory';
    }
    if (stats && stats.isSymbolicLink()) {
      const full = entry.fullPath;
      try {
        const entryRealPath = await realpath(full);
        const entryRealPathStats = await lstat(entryRealPath);
        if (entryRealPathStats.isFile()) {
          return 'file';
        }
        if (entryRealPathStats.isDirectory()) {
          const len = entryRealPath.length;
          if (full.startsWith(entryRealPath) && full.substr(len, 1) === sysPath__default['default'].sep) {
            return this._onError(new Error(
              `Circular symlink detected: "${full}" points to "${entryRealPath}"`
            ));
          }
          return 'directory';
        }
      } catch (error) {
        this._onError(error);
      }
    }
  }

  _includeAsFile(entry) {
    const stats = entry && entry[this._statsProp];

    return stats && this._wantsEverything && !stats.isDirectory();
  }
}

/**
 * @typedef {Object} ReaddirpArguments
 * @property {Function=} fileFilter
 * @property {Function=} directoryFilter
 * @property {String=} type
 * @property {Number=} depth
 * @property {String=} root
 * @property {Boolean=} lstat
 * @property {Boolean=} bigint
 */

/**
 * Main function which ends up calling readdirRec and reads all files and directories in given root recursively.
 * @param {String} root Root directory
 * @param {ReaddirpArguments=} options Options to specify root (start directory), filters and recursion depth
 */
const readdirp = (root, options = {}) => {
  let type = options.entryType || options.type;
  if (type === 'both') type = FILE_DIR_TYPE; // backwards-compatibility
  if (type) options.type = type;
  if (!root) {
    throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
  } else if (typeof root !== 'string') {
    throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
  } else if (type && !ALL_TYPES.includes(type)) {
    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
  }

  options.root = root;
  return new ReaddirpStream(options);
};

const readdirpPromise = (root, options = {}) => {
  return new Promise((resolve, reject) => {
    const files = [];
    readdirp(root, options)
      .on('data', entry => files.push(entry))
      .on('end', () => resolve(files))
      .on('error', error => reject(error));
  });
};

readdirp.promise = readdirpPromise;
readdirp.ReaddirpStream = ReaddirpStream;
readdirp.default = readdirp;

var readdirp_1 = readdirp;

/*!
 * normalize-path <https://github.com/jonschlinkert/normalize-path>
 *
 * Copyright (c) 2014-2018, Jon Schlinkert.
 * Released under the MIT License.
 */

var normalizePath = function(path, stripTrailing) {
  if (typeof path !== 'string') {
    throw new TypeError('expected path to be a string');
  }

  if (path === '\\' || path === '/') return '/';

  var len = path.length;
  if (len <= 1) return path;

  // ensure that win32 namespaces has two leading slashes, so that the path is
  // handled properly by the win32 version of path.parse() after being normalized
  // https://msdn.microsoft.com/library/windows/desktop/aa365247(v=vs.85).aspx#namespaces
  var prefix = '';
  if (len > 4 && path[3] === '\\') {
    var ch = path[2];
    if ((ch === '?' || ch === '.') && path.slice(0, 2) === '\\\\') {
      path = path.slice(2);
      prefix = '//';
    }
  }

  var segs = path.split(/[/\\]+/);
  if (stripTrailing !== false && segs[segs.length - 1] === '') {
    segs.pop();
  }
  return prefix + segs.join('/');
};

var anymatch_1 = createCommonjsModule(function (module, exports) {

Object.defineProperty(exports, "__esModule", { value: true });




/**
 * @typedef {(testString: string) => boolean} AnymatchFn
 * @typedef {string|RegExp|AnymatchFn} AnymatchPattern
 * @typedef {AnymatchPattern|AnymatchPattern[]} AnymatchMatcher
 */
const BANG = '!';
const DEFAULT_OPTIONS = {returnIndex: false};
const arrify = (item) => Array.isArray(item) ? item : [item];

/**
 * @param {AnymatchPattern} matcher
 * @param {object} options
 * @returns {AnymatchFn}
 */
const createPattern = (matcher, options) => {
  if (typeof matcher === 'function') {
    return matcher;
  }
  if (typeof matcher === 'string') {
    const glob = picomatch$1(matcher, options);
    return (string) => matcher === string || glob(string);
  }
  if (matcher instanceof RegExp) {
    return (string) => matcher.test(string);
  }
  return (string) => false;
};

/**
 * @param {Array<Function>} patterns
 * @param {Array<Function>} negPatterns
 * @param {String|Array} args
 * @param {Boolean} returnIndex
 * @returns {boolean|number}
 */
const matchPatterns = (patterns, negPatterns, args, returnIndex) => {
  const isList = Array.isArray(args);
  const _path = isList ? args[0] : args;
  if (!isList && typeof _path !== 'string') {
    throw new TypeError('anymatch: second argument must be a string: got ' +
      Object.prototype.toString.call(_path))
  }
  const path = normalizePath(_path);

  for (let index = 0; index < negPatterns.length; index++) {
    const nglob = negPatterns[index];
    if (nglob(path)) {
      return returnIndex ? -1 : false;
    }
  }

  const applied = isList && [path].concat(args.slice(1));
  for (let index = 0; index < patterns.length; index++) {
    const pattern = patterns[index];
    if (isList ? pattern(...applied) : pattern(path)) {
      return returnIndex ? index : true;
    }
  }

  return returnIndex ? -1 : false;
};

/**
 * @param {AnymatchMatcher} matchers
 * @param {Array|string} testString
 * @param {object} options
 * @returns {boolean|number|Function}
 */
const anymatch = (matchers, testString, options = DEFAULT_OPTIONS) => {
  if (matchers == null) {
    throw new TypeError('anymatch: specify first argument');
  }
  const opts = typeof options === 'boolean' ? {returnIndex: options} : options;
  const returnIndex = opts.returnIndex || false;

  // Early cache for matchers.
  const mtchers = arrify(matchers);
  const negatedGlobs = mtchers
    .filter(item => typeof item === 'string' && item.charAt(0) === BANG)
    .map(item => item.slice(1))
    .map(item => picomatch$1(item, opts));
  const patterns = mtchers.map(matcher => createPattern(matcher, opts));

  if (testString == null) {
    return (testString, ri = false) => {
      const returnIndex = typeof ri === 'boolean' ? ri : false;
      return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
    }
  }

  return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
};

anymatch.default = anymatch;
module.exports = anymatch;
});

/*!
 * is-extglob <https://github.com/jonschlinkert/is-extglob>
 *
 * Copyright (c) 2014-2016, Jon Schlinkert.
 * Licensed under the MIT License.
 */

var isExtglob = function isExtglob(str) {
  if (typeof str !== 'string' || str === '') {
    return false;
  }

  var match;
  while ((match = /(\\).|([@?!+*]\(.*\))/g.exec(str))) {
    if (match[2]) return true;
    str = str.slice(match.index + match[0].length);
  }

  return false;
};

/*!
 * is-glob <https://github.com/jonschlinkert/is-glob>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */


var chars = { '{': '}', '(': ')', '[': ']'};
var strictRegex = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
var relaxedRegex = /\\(.)|(^!|[*?{}()[\]]|\(\?)/;

var isGlob = function isGlob(str, options) {
  if (typeof str !== 'string' || str === '') {
    return false;
  }

  if (isExtglob(str)) {
    return true;
  }

  var regex = strictRegex;
  var match;

  // optionally relax regex
  if (options && options.strict === false) {
    regex = relaxedRegex;
  }

  while ((match = regex.exec(str))) {
    if (match[2]) return true;
    var idx = match.index + match[0].length;

    // if an open bracket/brace/paren is escaped,
    // set the index to the next closing character
    var open = match[1];
    var close = open ? chars[open] : null;
    if (open && close) {
      var n = str.indexOf(close, idx);
      if (n !== -1) {
        idx = n + 1;
      }
    }

    str = str.slice(idx);
  }
  return false;
};

var pathPosixDirname = sysPath__default['default'].posix.dirname;
var isWin32 = require$$1__default['default'].platform() === 'win32';

var slash = '/';
var backslash = /\\/g;
var enclosure = /[\{\[].*[\/]*.*[\}\]]$/;
var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;

/**
 * @param {string} str
 * @param {Object} opts
 * @param {boolean} [opts.flipBackslashes=true]
 */
var globParent = function globParent(str, opts) {
  var options = Object.assign({ flipBackslashes: true }, opts);

  // flip windows path separators
  if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
    str = str.replace(backslash, slash);
  }

  // special case for strings ending in enclosure containing path separator
  if (enclosure.test(str)) {
    str += slash;
  }

  // preserves full path in case of trailing path separator
  str += 'a';

  // remove path parts that are globby
  do {
    str = pathPosixDirname(str);
  } while (isGlob(str) || globby.test(str));

  // remove escape chars and return result
  return str.replace(escaped, '$1');
};

var utils$1 = createCommonjsModule(function (module, exports) {

exports.isInteger = num => {
  if (typeof num === 'number') {
    return Number.isInteger(num);
  }
  if (typeof num === 'string' && num.trim() !== '') {
    return Number.isInteger(Number(num));
  }
  return false;
};

/**
 * Find a node of the given type
 */

exports.find = (node, type) => node.nodes.find(node => node.type === type);

/**
 * Find a node of the given type
 */

exports.exceedsLimit = (min, max, step = 1, limit) => {
  if (limit === false) return false;
  if (!exports.isInteger(min) || !exports.isInteger(max)) return false;
  return ((Number(max) - Number(min)) / Number(step)) >= limit;
};

/**
 * Escape the given node with '\\' before node.value
 */

exports.escapeNode = (block, n = 0, type) => {
  let node = block.nodes[n];
  if (!node) return;

  if ((type && node.type === type) || node.type === 'open' || node.type === 'close') {
    if (node.escaped !== true) {
      node.value = '\\' + node.value;
      node.escaped = true;
    }
  }
};

/**
 * Returns true if the given brace node should be enclosed in literal braces
 */

exports.encloseBrace = node => {
  if (node.type !== 'brace') return false;
  if ((node.commas >> 0 + node.ranges >> 0) === 0) {
    node.invalid = true;
    return true;
  }
  return false;
};

/**
 * Returns true if a brace node is invalid.
 */

exports.isInvalidBrace = block => {
  if (block.type !== 'brace') return false;
  if (block.invalid === true || block.dollar) return true;
  if ((block.commas >> 0 + block.ranges >> 0) === 0) {
    block.invalid = true;
    return true;
  }
  if (block.open !== true || block.close !== true) {
    block.invalid = true;
    return true;
  }
  return false;
};

/**
 * Returns true if a node is an open or close node
 */

exports.isOpenOrClose = node => {
  if (node.type === 'open' || node.type === 'close') {
    return true;
  }
  return node.open === true || node.close === true;
};

/**
 * Reduce an array of text nodes.
 */

exports.reduce = nodes => nodes.reduce((acc, node) => {
  if (node.type === 'text') acc.push(node.value);
  if (node.type === 'range') node.type = 'text';
  return acc;
}, []);

/**
 * Flatten an array
 */

exports.flatten = (...args) => {
  const result = [];
  const flat = arr => {
    for (let i = 0; i < arr.length; i++) {
      let ele = arr[i];
      Array.isArray(ele) ? flat(ele) : ele !== void 0 && result.push(ele);
    }
    return result;
  };
  flat(args);
  return result;
};
});

var stringify = (ast, options = {}) => {
  let stringify = (node, parent = {}) => {
    let invalidBlock = options.escapeInvalid && utils$1.isInvalidBrace(parent);
    let invalidNode = node.invalid === true && options.escapeInvalid === true;
    let output = '';

    if (node.value) {
      if ((invalidBlock || invalidNode) && utils$1.isOpenOrClose(node)) {
        return '\\' + node.value;
      }
      return node.value;
    }

    if (node.value) {
      return node.value;
    }

    if (node.nodes) {
      for (let child of node.nodes) {
        output += stringify(child);
      }
    }
    return output;
  };

  return stringify(ast);
};

/*!
 * is-number <https://github.com/jonschlinkert/is-number>
 *
 * Copyright (c) 2014-present, Jon Schlinkert.
 * Released under the MIT License.
 */

var isNumber = function(num) {
  if (typeof num === 'number') {
    return num - num === 0;
  }
  if (typeof num === 'string' && num.trim() !== '') {
    return Number.isFinite ? Number.isFinite(+num) : isFinite(+num);
  }
  return false;
};

const toRegexRange = (min, max, options) => {
  if (isNumber(min) === false) {
    throw new TypeError('toRegexRange: expected the first argument to be a number');
  }

  if (max === void 0 || min === max) {
    return String(min);
  }

  if (isNumber(max) === false) {
    throw new TypeError('toRegexRange: expected the second argument to be a number.');
  }

  let opts = { relaxZeros: true, ...options };
  if (typeof opts.strictZeros === 'boolean') {
    opts.relaxZeros = opts.strictZeros === false;
  }

  let relax = String(opts.relaxZeros);
  let shorthand = String(opts.shorthand);
  let capture = String(opts.capture);
  let wrap = String(opts.wrap);
  let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;

  if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
    return toRegexRange.cache[cacheKey].result;
  }

  let a = Math.min(min, max);
  let b = Math.max(min, max);

  if (Math.abs(a - b) === 1) {
    let result = min + '|' + max;
    if (opts.capture) {
      return `(${result})`;
    }
    if (opts.wrap === false) {
      return result;
    }
    return `(?:${result})`;
  }

  let isPadded = hasPadding(min) || hasPadding(max);
  let state = { min, max, a, b };
  let positives = [];
  let negatives = [];

  if (isPadded) {
    state.isPadded = isPadded;
    state.maxLen = String(state.max).length;
  }

  if (a < 0) {
    let newMin = b < 0 ? Math.abs(b) : 1;
    negatives = splitToPatterns(newMin, Math.abs(a), state, opts);
    a = state.a = 0;
  }

  if (b >= 0) {
    positives = splitToPatterns(a, b, state, opts);
  }

  state.negatives = negatives;
  state.positives = positives;
  state.result = collatePatterns(negatives, positives);

  if (opts.capture === true) {
    state.result = `(${state.result})`;
  } else if (opts.wrap !== false && (positives.length + negatives.length) > 1) {
    state.result = `(?:${state.result})`;
  }

  toRegexRange.cache[cacheKey] = state;
  return state.result;
};

function collatePatterns(neg, pos, options) {
  let onlyNegative = filterPatterns(neg, pos, '-', false) || [];
  let onlyPositive = filterPatterns(pos, neg, '', false) || [];
  let intersected = filterPatterns(neg, pos, '-?', true) || [];
  let subpatterns = onlyNegative.concat(intersected).concat(onlyPositive);
  return subpatterns.join('|');
}

function splitToRanges(min, max) {
  let nines = 1;
  let zeros = 1;

  let stop = countNines(min, nines);
  let stops = new Set([max]);

  while (min <= stop && stop <= max) {
    stops.add(stop);
    nines += 1;
    stop = countNines(min, nines);
  }

  stop = countZeros(max + 1, zeros) - 1;

  while (min < stop && stop <= max) {
    stops.add(stop);
    zeros += 1;
    stop = countZeros(max + 1, zeros) - 1;
  }

  stops = [...stops];
  stops.sort(compare);
  return stops;
}

/**
 * Convert a range to a regex pattern
 * @param {Number} `start`
 * @param {Number} `stop`
 * @return {String}
 */

function rangeToPattern(start, stop, options) {
  if (start === stop) {
    return { pattern: start, count: [], digits: 0 };
  }

  let zipped = zip(start, stop);
  let digits = zipped.length;
  let pattern = '';
  let count = 0;

  for (let i = 0; i < digits; i++) {
    let [startDigit, stopDigit] = zipped[i];

    if (startDigit === stopDigit) {
      pattern += startDigit;

    } else if (startDigit !== '0' || stopDigit !== '9') {
      pattern += toCharacterClass(startDigit, stopDigit);

    } else {
      count++;
    }
  }

  if (count) {
    pattern += options.shorthand === true ? '\\d' : '[0-9]';
  }

  return { pattern, count: [count], digits };
}

function splitToPatterns(min, max, tok, options) {
  let ranges = splitToRanges(min, max);
  let tokens = [];
  let start = min;
  let prev;

  for (let i = 0; i < ranges.length; i++) {
    let max = ranges[i];
    let obj = rangeToPattern(String(start), String(max), options);
    let zeros = '';

    if (!tok.isPadded && prev && prev.pattern === obj.pattern) {
      if (prev.count.length > 1) {
        prev.count.pop();
      }

      prev.count.push(obj.count[0]);
      prev.string = prev.pattern + toQuantifier(prev.count);
      start = max + 1;
      continue;
    }

    if (tok.isPadded) {
      zeros = padZeros(max, tok, options);
    }

    obj.string = zeros + obj.pattern + toQuantifier(obj.count);
    tokens.push(obj);
    start = max + 1;
    prev = obj;
  }

  return tokens;
}

function filterPatterns(arr, comparison, prefix, intersection, options) {
  let result = [];

  for (let ele of arr) {
    let { string } = ele;

    // only push if _both_ are negative...
    if (!intersection && !contains(comparison, 'string', string)) {
      result.push(prefix + string);
    }

    // or _both_ are positive
    if (intersection && contains(comparison, 'string', string)) {
      result.push(prefix + string);
    }
  }
  return result;
}

/**
 * Zip strings
 */

function zip(a, b) {
  let arr = [];
  for (let i = 0; i < a.length; i++) arr.push([a[i], b[i]]);
  return arr;
}

function compare(a, b) {
  return a > b ? 1 : b > a ? -1 : 0;
}

function contains(arr, key, val) {
  return arr.some(ele => ele[key] === val);
}

function countNines(min, len) {
  return Number(String(min).slice(0, -len) + '9'.repeat(len));
}

function countZeros(integer, zeros) {
  return integer - (integer % Math.pow(10, zeros));
}

function toQuantifier(digits) {
  let [start = 0, stop = ''] = digits;
  if (stop || start > 1) {
    return `{${start + (stop ? ',' + stop : '')}}`;
  }
  return '';
}

function toCharacterClass(a, b, options) {
  return `[${a}${(b - a === 1) ? '' : '-'}${b}]`;
}

function hasPadding(str) {
  return /^-?(0+)\d/.test(str);
}

function padZeros(value, tok, options) {
  if (!tok.isPadded) {
    return value;
  }

  let diff = Math.abs(tok.maxLen - String(value).length);
  let relax = options.relaxZeros !== false;

  switch (diff) {
    case 0:
      return '';
    case 1:
      return relax ? '0?' : '0';
    case 2:
      return relax ? '0{0,2}' : '00';
    default: {
      return relax ? `0{0,${diff}}` : `0{${diff}}`;
    }
  }
}

/**
 * Cache
 */

toRegexRange.cache = {};
toRegexRange.clearCache = () => (toRegexRange.cache = {});

/**
 * Expose `toRegexRange`
 */

var toRegexRange_1 = toRegexRange;

const isObject$1 = val => val !== null && typeof val === 'object' && !Array.isArray(val);

const transform = toNumber => {
  return value => toNumber === true ? Number(value) : String(value);
};

const isValidValue = value => {
  return typeof value === 'number' || (typeof value === 'string' && value !== '');
};

const isNumber$1 = num => Number.isInteger(+num);

const zeros = input => {
  let value = `${input}`;
  let index = -1;
  if (value[0] === '-') value = value.slice(1);
  if (value === '0') return false;
  while (value[++index] === '0');
  return index > 0;
};

const stringify$1 = (start, end, options) => {
  if (typeof start === 'string' || typeof end === 'string') {
    return true;
  }
  return options.stringify === true;
};

const pad = (input, maxLength, toNumber) => {
  if (maxLength > 0) {
    let dash = input[0] === '-' ? '-' : '';
    if (dash) input = input.slice(1);
    input = (dash + input.padStart(dash ? maxLength - 1 : maxLength, '0'));
  }
  if (toNumber === false) {
    return String(input);
  }
  return input;
};

const toMaxLen = (input, maxLength) => {
  let negative = input[0] === '-' ? '-' : '';
  if (negative) {
    input = input.slice(1);
    maxLength--;
  }
  while (input.length < maxLength) input = '0' + input;
  return negative ? ('-' + input) : input;
};

const toSequence = (parts, options) => {
  parts.negatives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
  parts.positives.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);

  let prefix = options.capture ? '' : '?:';
  let positives = '';
  let negatives = '';
  let result;

  if (parts.positives.length) {
    positives = parts.positives.join('|');
  }

  if (parts.negatives.length) {
    negatives = `-(${prefix}${parts.negatives.join('|')})`;
  }

  if (positives && negatives) {
    result = `${positives}|${negatives}`;
  } else {
    result = positives || negatives;
  }

  if (options.wrap) {
    return `(${prefix}${result})`;
  }

  return result;
};

const toRange = (a, b, isNumbers, options) => {
  if (isNumbers) {
    return toRegexRange_1(a, b, { wrap: false, ...options });
  }

  let start = String.fromCharCode(a);
  if (a === b) return start;

  let stop = String.fromCharCode(b);
  return `[${start}-${stop}]`;
};

const toRegex = (start, end, options) => {
  if (Array.isArray(start)) {
    let wrap = options.wrap === true;
    let prefix = options.capture ? '' : '?:';
    return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
  }
  return toRegexRange_1(start, end, options);
};

const rangeError = (...args) => {
  return new RangeError('Invalid range arguments: ' + require$$0__default['default'].inspect(...args));
};

const invalidRange = (start, end, options) => {
  if (options.strictRanges === true) throw rangeError([start, end]);
  return [];
};

const invalidStep = (step, options) => {
  if (options.strictRanges === true) {
    throw new TypeError(`Expected step "${step}" to be a number`);
  }
  return [];
};

const fillNumbers = (start, end, step = 1, options = {}) => {
  let a = Number(start);
  let b = Number(end);

  if (!Number.isInteger(a) || !Number.isInteger(b)) {
    if (options.strictRanges === true) throw rangeError([start, end]);
    return [];
  }

  // fix negative zero
  if (a === 0) a = 0;
  if (b === 0) b = 0;

  let descending = a > b;
  let startString = String(start);
  let endString = String(end);
  let stepString = String(step);
  step = Math.max(Math.abs(step), 1);

  let padded = zeros(startString) || zeros(endString) || zeros(stepString);
  let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
  let toNumber = padded === false && stringify$1(start, end, options) === false;
  let format = options.transform || transform(toNumber);

  if (options.toRegex && step === 1) {
    return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
  }

  let parts = { negatives: [], positives: [] };
  let push = num => parts[num < 0 ? 'negatives' : 'positives'].push(Math.abs(num));
  let range = [];
  let index = 0;

  while (descending ? a >= b : a <= b) {
    if (options.toRegex === true && step > 1) {
      push(a);
    } else {
      range.push(pad(format(a, index), maxLen, toNumber));
    }
    a = descending ? a - step : a + step;
    index++;
  }

  if (options.toRegex === true) {
    return step > 1
      ? toSequence(parts, options)
      : toRegex(range, null, { wrap: false, ...options });
  }

  return range;
};

const fillLetters = (start, end, step = 1, options = {}) => {
  if ((!isNumber$1(start) && start.length > 1) || (!isNumber$1(end) && end.length > 1)) {
    return invalidRange(start, end, options);
  }


  let format = options.transform || (val => String.fromCharCode(val));
  let a = `${start}`.charCodeAt(0);
  let b = `${end}`.charCodeAt(0);

  let descending = a > b;
  let min = Math.min(a, b);
  let max = Math.max(a, b);

  if (options.toRegex && step === 1) {
    return toRange(min, max, false, options);
  }

  let range = [];
  let index = 0;

  while (descending ? a >= b : a <= b) {
    range.push(format(a, index));
    a = descending ? a - step : a + step;
    index++;
  }

  if (options.toRegex === true) {
    return toRegex(range, null, { wrap: false, options });
  }

  return range;
};

const fill = (start, end, step, options = {}) => {
  if (end == null && isValidValue(start)) {
    return [start];
  }

  if (!isValidValue(start) || !isValidValue(end)) {
    return invalidRange(start, end, options);
  }

  if (typeof step === 'function') {
    return fill(start, end, 1, { transform: step });
  }

  if (isObject$1(step)) {
    return fill(start, end, 0, step);
  }

  let opts = { ...options };
  if (opts.capture === true) opts.wrap = true;
  step = step || opts.step || 1;

  if (!isNumber$1(step)) {
    if (step != null && !isObject$1(step)) return invalidStep(step, opts);
    return fill(start, end, 1, step);
  }

  if (isNumber$1(start) && isNumber$1(end)) {
    return fillNumbers(start, end, step, opts);
  }

  return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
};

var fillRange = fill;

const compile = (ast, options = {}) => {
  let walk = (node, parent = {}) => {
    let invalidBlock = utils$1.isInvalidBrace(parent);
    let invalidNode = node.invalid === true && options.escapeInvalid === true;
    let invalid = invalidBlock === true || invalidNode === true;
    let prefix = options.escapeInvalid === true ? '\\' : '';
    let output = '';

    if (node.isOpen === true) {
      return prefix + node.value;
    }
    if (node.isClose === true) {
      return prefix + node.value;
    }

    if (node.type === 'open') {
      return invalid ? (prefix + node.value) : '(';
    }

    if (node.type === 'close') {
      return invalid ? (prefix + node.value) : ')';
    }

    if (node.type === 'comma') {
      return node.prev.type === 'comma' ? '' : (invalid ? node.value : '|');
    }

    if (node.value) {
      return node.value;
    }

    if (node.nodes && node.ranges > 0) {
      let args = utils$1.reduce(node.nodes);
      let range = fillRange(...args, { ...options, wrap: false, toRegex: true });

      if (range.length !== 0) {
        return args.length > 1 && range.length > 1 ? `(${range})` : range;
      }
    }

    if (node.nodes) {
      for (let child of node.nodes) {
        output += walk(child, node);
      }
    }
    return output;
  };

  return walk(ast);
};

var compile_1 = compile;

const append = (queue = '', stash = '', enclose = false) => {
  let result = [];

  queue = [].concat(queue);
  stash = [].concat(stash);

  if (!stash.length) return queue;
  if (!queue.length) {
    return enclose ? utils$1.flatten(stash).map(ele => `{${ele}}`) : stash;
  }

  for (let item of queue) {
    if (Array.isArray(item)) {
      for (let value of item) {
        result.push(append(value, stash, enclose));
      }
    } else {
      for (let ele of stash) {
        if (enclose === true && typeof ele === 'string') ele = `{${ele}}`;
        result.push(Array.isArray(ele) ? append(item, ele, enclose) : (item + ele));
      }
    }
  }
  return utils$1.flatten(result);
};

const expand = (ast, options = {}) => {
  let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;

  let walk = (node, parent = {}) => {
    node.queue = [];

    let p = parent;
    let q = parent.queue;

    while (p.type !== 'brace' && p.type !== 'root' && p.parent) {
      p = p.parent;
      q = p.queue;
    }

    if (node.invalid || node.dollar) {
      q.push(append(q.pop(), stringify(node, options)));
      return;
    }

    if (node.type === 'brace' && node.invalid !== true && node.nodes.length === 2) {
      q.push(append(q.pop(), ['{}']));
      return;
    }

    if (node.nodes && node.ranges > 0) {
      let args = utils$1.reduce(node.nodes);

      if (utils$1.exceedsLimit(...args, options.step, rangeLimit)) {
        throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
      }

      let range = fillRange(...args, options);
      if (range.length === 0) {
        range = stringify(node, options);
      }

      q.push(append(q.pop(), range));
      node.nodes = [];
      return;
    }

    let enclose = utils$1.encloseBrace(node);
    let queue = node.queue;
    let block = node;

    while (block.type !== 'brace' && block.type !== 'root' && block.parent) {
      block = block.parent;
      queue = block.queue;
    }

    for (let i = 0; i < node.nodes.length; i++) {
      let child = node.nodes[i];

      if (child.type === 'comma' && node.type === 'brace') {
        if (i === 1) queue.push('');
        queue.push('');
        continue;
      }

      if (child.type === 'close') {
        q.push(append(q.pop(), queue, enclose));
        continue;
      }

      if (child.value && child.type !== 'open') {
        queue.push(append(queue.pop(), child.value));
        continue;
      }

      if (child.nodes) {
        walk(child, node);
      }
    }

    return queue;
  };

  return utils$1.flatten(walk(ast));
};

var expand_1 = expand;

var constants$1 = {
  MAX_LENGTH: 1024 * 64,

  // Digits
  CHAR_0: '0', /* 0 */
  CHAR_9: '9', /* 9 */

  // Alphabet chars.
  CHAR_UPPERCASE_A: 'A', /* A */
  CHAR_LOWERCASE_A: 'a', /* a */
  CHAR_UPPERCASE_Z: 'Z', /* Z */
  CHAR_LOWERCASE_Z: 'z', /* z */

  CHAR_LEFT_PARENTHESES: '(', /* ( */
  CHAR_RIGHT_PARENTHESES: ')', /* ) */

  CHAR_ASTERISK: '*', /* * */

  // Non-alphabetic chars.
  CHAR_AMPERSAND: '&', /* & */
  CHAR_AT: '@', /* @ */
  CHAR_BACKSLASH: '\\', /* \ */
  CHAR_BACKTICK: '`', /* ` */
  CHAR_CARRIAGE_RETURN: '\r', /* \r */
  CHAR_CIRCUMFLEX_ACCENT: '^', /* ^ */
  CHAR_COLON: ':', /* : */
  CHAR_COMMA: ',', /* , */
  CHAR_DOLLAR: '$', /* . */
  CHAR_DOT: '.', /* . */
  CHAR_DOUBLE_QUOTE: '"', /* " */
  CHAR_EQUAL: '=', /* = */
  CHAR_EXCLAMATION_MARK: '!', /* ! */
  CHAR_FORM_FEED: '\f', /* \f */
  CHAR_FORWARD_SLASH: '/', /* / */
  CHAR_HASH: '#', /* # */
  CHAR_HYPHEN_MINUS: '-', /* - */
  CHAR_LEFT_ANGLE_BRACKET: '<', /* < */
  CHAR_LEFT_CURLY_BRACE: '{', /* { */
  CHAR_LEFT_SQUARE_BRACKET: '[', /* [ */
  CHAR_LINE_FEED: '\n', /* \n */
  CHAR_NO_BREAK_SPACE: '\u00A0', /* \u00A0 */
  CHAR_PERCENT: '%', /* % */
  CHAR_PLUS: '+', /* + */
  CHAR_QUESTION_MARK: '?', /* ? */
  CHAR_RIGHT_ANGLE_BRACKET: '>', /* > */
  CHAR_RIGHT_CURLY_BRACE: '}', /* } */
  CHAR_RIGHT_SQUARE_BRACKET: ']', /* ] */
  CHAR_SEMICOLON: ';', /* ; */
  CHAR_SINGLE_QUOTE: '\'', /* ' */
  CHAR_SPACE: ' ', /*   */
  CHAR_TAB: '\t', /* \t */
  CHAR_UNDERSCORE: '_', /* _ */
  CHAR_VERTICAL_LINE: '|', /* | */
  CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
};

/**
 * Constants
 */

const {
  MAX_LENGTH: MAX_LENGTH$1,
  CHAR_BACKSLASH, /* \ */
  CHAR_BACKTICK, /* ` */
  CHAR_COMMA: CHAR_COMMA$1, /* , */
  CHAR_DOT: CHAR_DOT$1, /* . */
  CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1, /* ( */
  CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1, /* ) */
  CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1, /* { */
  CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1, /* } */
  CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1, /* [ */
  CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1, /* ] */
  CHAR_DOUBLE_QUOTE, /* " */
  CHAR_SINGLE_QUOTE, /* ' */
  CHAR_NO_BREAK_SPACE,
  CHAR_ZERO_WIDTH_NOBREAK_SPACE
} = constants$1;

/**
 * parse
 */

const parse$1 = (input, options = {}) => {
  if (typeof input !== 'string') {
    throw new TypeError('Expected a string');
  }

  let opts = options || {};
  let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;
  if (input.length > max) {
    throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
  }

  let ast = { type: 'root', input, nodes: [] };
  let stack = [ast];
  let block = ast;
  let prev = ast;
  let brackets = 0;
  let length = input.length;
  let index = 0;
  let depth = 0;
  let value;

  /**
   * Helpers
   */

  const advance = () => input[index++];
  const push = node => {
    if (node.type === 'text' && prev.type === 'dot') {
      prev.type = 'text';
    }

    if (prev && prev.type === 'text' && node.type === 'text') {
      prev.value += node.value;
      return;
    }

    block.nodes.push(node);
    node.parent = block;
    node.prev = prev;
    prev = node;
    return node;
  };

  push({ type: 'bos' });

  while (index < length) {
    block = stack[stack.length - 1];
    value = advance();

    /**
     * Invalid chars
     */

    if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
      continue;
    }

    /**
     * Escaped chars
     */

    if (value === CHAR_BACKSLASH) {
      push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });
      continue;
    }

    /**
     * Right square bracket (literal): ']'
     */

    if (value === CHAR_RIGHT_SQUARE_BRACKET$1) {
      push({ type: 'text', value: '\\' + value });
      continue;
    }

    /**
     * Left square bracket: '['
     */

    if (value === CHAR_LEFT_SQUARE_BRACKET$1) {
      brackets++;
      let next;

      while (index < length && (next = advance())) {
        value += next;

        if (next === CHAR_LEFT_SQUARE_BRACKET$1) {
          brackets++;
          continue;
        }

        if (next === CHAR_BACKSLASH) {
          value += advance();
          continue;
        }

        if (next === CHAR_RIGHT_SQUARE_BRACKET$1) {
          brackets--;

          if (brackets === 0) {
            break;
          }
        }
      }

      push({ type: 'text', value });
      continue;
    }

    /**
     * Parentheses
     */

    if (value === CHAR_LEFT_PARENTHESES$1) {
      block = push({ type: 'paren', nodes: [] });
      stack.push(block);
      push({ type: 'text', value });
      continue;
    }

    if (value === CHAR_RIGHT_PARENTHESES$1) {
      if (block.type !== 'paren') {
        push({ type: 'text', value });
        continue;
      }
      block = stack.pop();
      push({ type: 'text', value });
      block = stack[stack.length - 1];
      continue;
    }

    /**
     * Quotes: '|"|`
     */

    if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
      let open = value;
      let next;

      if (options.keepQuotes !== true) {
        value = '';
      }

      while (index < length && (next = advance())) {
        if (next === CHAR_BACKSLASH) {
          value += next + advance();
          continue;
        }

        if (next === open) {
          if (options.keepQuotes === true) value += next;
          break;
        }

        value += next;
      }

      push({ type: 'text', value });
      continue;
    }

    /**
     * Left curly brace: '{'
     */

    if (value === CHAR_LEFT_CURLY_BRACE$1) {
      depth++;

      let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
      let brace = {
        type: 'brace',
        open: true,
        close: false,
        dollar,
        depth,
        commas: 0,
        ranges: 0,
        nodes: []
      };

      block = push(brace);
      stack.push(block);
      push({ type: 'open', value });
      continue;
    }

    /**
     * Right curly brace: '}'
     */

    if (value === CHAR_RIGHT_CURLY_BRACE$1) {
      if (block.type !== 'brace') {
        push({ type: 'text', value });
        continue;
      }

      let type = 'close';
      block = stack.pop();
      block.close = true;

      push({ type, value });
      depth--;

      block = stack[stack.length - 1];
      continue;
    }

    /**
     * Comma: ','
     */

    if (value === CHAR_COMMA$1 && depth > 0) {
      if (block.ranges > 0) {
        block.ranges = 0;
        let open = block.nodes.shift();
        block.nodes = [open, { type: 'text', value: stringify(block) }];
      }

      push({ type: 'comma', value });
      block.commas++;
      continue;
    }

    /**
     * Dot: '.'
     */

    if (value === CHAR_DOT$1 && depth > 0 && block.commas === 0) {
      let siblings = block.nodes;

      if (depth === 0 || siblings.length === 0) {
        push({ type: 'text', value });
        continue;
      }

      if (prev.type === 'dot') {
        block.range = [];
        prev.value += value;
        prev.type = 'range';

        if (block.nodes.length !== 3 && block.nodes.length !== 5) {
          block.invalid = true;
          block.ranges = 0;
          prev.type = 'text';
          continue;
        }

        block.ranges++;
        block.args = [];
        continue;
      }

      if (prev.type === 'range') {
        siblings.pop();

        let before = siblings[siblings.length - 1];
        before.value += prev.value + value;
        prev = before;
        block.ranges--;
        continue;
      }

      push({ type: 'dot', value });
      continue;
    }

    /**
     * Text
     */

    push({ type: 'text', value });
  }

  // Mark imbalanced braces and brackets as invalid
  do {
    block = stack.pop();

    if (block.type !== 'root') {
      block.nodes.forEach(node => {
        if (!node.nodes) {
          if (node.type === 'open') node.isOpen = true;
          if (node.type === 'close') node.isClose = true;
          if (!node.nodes) node.type = 'text';
          node.invalid = true;
        }
      });

      // get the location of the block on parent.nodes (block's siblings)
      let parent = stack[stack.length - 1];
      let index = parent.nodes.indexOf(block);
      // replace the (invalid) block with it's nodes
      parent.nodes.splice(index, 1, ...block.nodes);
    }
  } while (stack.length > 0);

  push({ type: 'eos' });
  return ast;
};

var parse_1$1 = parse$1;

/**
 * Expand the given pattern or create a regex-compatible string.
 *
 * ```js
 * const braces = require('braces');
 * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
 * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
 * ```
 * @param {String} `str`
 * @param {Object} `options`
 * @return {String}
 * @api public
 */

const braces = (input, options = {}) => {
  let output = [];

  if (Array.isArray(input)) {
    for (let pattern of input) {
      let result = braces.create(pattern, options);
      if (Array.isArray(result)) {
        output.push(...result);
      } else {
        output.push(result);
      }
    }
  } else {
    output = [].concat(braces.create(input, options));
  }

  if (options && options.expand === true && options.nodupes === true) {
    output = [...new Set(output)];
  }
  return output;
};

/**
 * Parse the given `str` with the given `options`.
 *
 * ```js
 * // braces.parse(pattern, [, options]);
 * const ast = braces.parse('a/{b,c}/d');
 * console.log(ast);
 * ```
 * @param {String} pattern Brace pattern to parse
 * @param {Object} options
 * @return {Object} Returns an AST
 * @api public
 */

braces.parse = (input, options = {}) => parse_1$1(input, options);

/**
 * Creates a braces string from an AST, or an AST node.
 *
 * ```js
 * const braces = require('braces');
 * let ast = braces.parse('foo/{a,b}/bar');
 * console.log(stringify(ast.nodes[2])); //=> '{a,b}'
 * ```
 * @param {String} `input` Brace pattern or AST.
 * @param {Object} `options`
 * @return {Array} Returns an array of expanded values.
 * @api public
 */

braces.stringify = (input, options = {}) => {
  if (typeof input === 'string') {
    return stringify(braces.parse(input, options), options);
  }
  return stringify(input, options);
};

/**
 * Compiles a brace pattern into a regex-compatible, optimized string.
 * This method is called by the main [braces](#braces) function by default.
 *
 * ```js
 * const braces = require('braces');
 * console.log(braces.compile('a/{b,c}/d'));
 * //=> ['a/(b|c)/d']
 * ```
 * @param {String} `input` Brace pattern or AST.
 * @param {Object} `options`
 * @return {Array} Returns an array of expanded values.
 * @api public
 */

braces.compile = (input, options = {}) => {
  if (typeof input === 'string') {
    input = braces.parse(input, options);
  }
  return compile_1(input, options);
};

/**
 * Expands a brace pattern into an array. This method is called by the
 * main [braces](#braces) function when `options.expand` is true. Before
 * using this method it's recommended that you read the [performance notes](#performance))
 * and advantages of using [.compile](#compile) instead.
 *
 * ```js
 * const braces = require('braces');
 * console.log(braces.expand('a/{b,c}/d'));
 * //=> ['a/b/d', 'a/c/d'];
 * ```
 * @param {String} `pattern` Brace pattern
 * @param {Object} `options`
 * @return {Array} Returns an array of expanded values.
 * @api public
 */

braces.expand = (input, options = {}) => {
  if (typeof input === 'string') {
    input = braces.parse(input, options);
  }

  let result = expand_1(input, options);

  // filter out empty strings if specified
  if (options.noempty === true) {
    result = result.filter(Boolean);
  }

  // filter out duplicates if specified
  if (options.nodupes === true) {
    result = [...new Set(result)];
  }

  return result;
};

/**
 * Processes a brace pattern and returns either an expanded array
 * (if `options.expand` is true), a highly optimized regex-compatible string.
 * This method is called by the main [braces](#braces) function.
 *
 * ```js
 * const braces = require('braces');
 * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
 * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
 * ```
 * @param {String} `pattern` Brace pattern
 * @param {Object} `options`
 * @return {Array} Returns an array of expanded values.
 * @api public
 */

braces.create = (input, options = {}) => {
  if (input === '' || input.length < 3) {
    return [input];
  }

 return options.expand !== true
    ? braces.compile(input, options)
    : braces.expand(input, options);
};

/**
 * Expose "braces"
 */

var braces_1 = braces;

var require$$0 = [
	"3dm",
	"3ds",
	"3g2",
	"3gp",
	"7z",
	"a",
	"aac",
	"adp",
	"ai",
	"aif",
	"aiff",
	"alz",
	"ape",
	"apk",
	"appimage",
	"ar",
	"arj",
	"asf",
	"au",
	"avi",
	"bak",
	"baml",
	"bh",
	"bin",
	"bk",
	"bmp",
	"btif",
	"bz2",
	"bzip2",
	"cab",
	"caf",
	"cgm",
	"class",
	"cmx",
	"cpio",
	"cr2",
	"cur",
	"dat",
	"dcm",
	"deb",
	"dex",
	"djvu",
	"dll",
	"dmg",
	"dng",
	"doc",
	"docm",
	"docx",
	"dot",
	"dotm",
	"dra",
	"DS_Store",
	"dsk",
	"dts",
	"dtshd",
	"dvb",
	"dwg",
	"dxf",
	"ecelp4800",
	"ecelp7470",
	"ecelp9600",
	"egg",
	"eol",
	"eot",
	"epub",
	"exe",
	"f4v",
	"fbs",
	"fh",
	"fla",
	"flac",
	"flatpak",
	"fli",
	"flv",
	"fpx",
	"fst",
	"fvt",
	"g3",
	"gh",
	"gif",
	"graffle",
	"gz",
	"gzip",
	"h261",
	"h263",
	"h264",
	"icns",
	"ico",
	"ief",
	"img",
	"ipa",
	"iso",
	"jar",
	"jpeg",
	"jpg",
	"jpgv",
	"jpm",
	"jxr",
	"key",
	"ktx",
	"lha",
	"lib",
	"lvp",
	"lz",
	"lzh",
	"lzma",
	"lzo",
	"m3u",
	"m4a",
	"m4v",
	"mar",
	"mdi",
	"mht",
	"mid",
	"midi",
	"mj2",
	"mka",
	"mkv",
	"mmr",
	"mng",
	"mobi",
	"mov",
	"movie",
	"mp3",
	"mp4",
	"mp4a",
	"mpeg",
	"mpg",
	"mpga",
	"mxu",
	"nef",
	"npx",
	"numbers",
	"nupkg",
	"o",
	"odp",
	"ods",
	"odt",
	"oga",
	"ogg",
	"ogv",
	"otf",
	"ott",
	"pages",
	"pbm",
	"pcx",
	"pdb",
	"pdf",
	"pea",
	"pgm",
	"pic",
	"png",
	"pnm",
	"pot",
	"potm",
	"potx",
	"ppa",
	"ppam",
	"ppm",
	"pps",
	"ppsm",
	"ppsx",
	"ppt",
	"pptm",
	"pptx",
	"psd",
	"pya",
	"pyc",
	"pyo",
	"pyv",
	"qt",
	"rar",
	"ras",
	"raw",
	"resources",
	"rgb",
	"rip",
	"rlc",
	"rmf",
	"rmvb",
	"rpm",
	"rtf",
	"rz",
	"s3m",
	"s7z",
	"scpt",
	"sgi",
	"shar",
	"snap",
	"sil",
	"sketch",
	"slk",
	"smv",
	"snk",
	"so",
	"stl",
	"suo",
	"sub",
	"swf",
	"tar",
	"tbz",
	"tbz2",
	"tga",
	"tgz",
	"thmx",
	"tif",
	"tiff",
	"tlz",
	"ttc",
	"ttf",
	"txz",
	"udf",
	"uvh",
	"uvi",
	"uvm",
	"uvp",
	"uvs",
	"uvu",
	"viv",
	"vob",
	"war",
	"wav",
	"wax",
	"wbmp",
	"wdp",
	"weba",
	"webm",
	"webp",
	"whl",
	"wim",
	"wm",
	"wma",
	"wmv",
	"wmx",
	"woff",
	"woff2",
	"wrm",
	"wvx",
	"xbm",
	"xif",
	"xla",
	"xlam",
	"xls",
	"xlsb",
	"xlsm",
	"xlsx",
	"xlt",
	"xltm",
	"xltx",
	"xm",
	"xmind",
	"xpi",
	"xpm",
	"xwd",
	"xz",
	"z",
	"zip",
	"zipx"
];

var binaryExtensions = require$$0;

const extensions = new Set(binaryExtensions);

var isBinaryPath = filePath => extensions.has(sysPath__default['default'].extname(filePath).slice(1).toLowerCase());

var constants$2 = createCommonjsModule(function (module, exports) {

const {sep} = sysPath__default['default'];
const {platform} = process;

exports.EV_ALL = 'all';
exports.EV_READY = 'ready';
exports.EV_ADD = 'add';
exports.EV_CHANGE = 'change';
exports.EV_ADD_DIR = 'addDir';
exports.EV_UNLINK = 'unlink';
exports.EV_UNLINK_DIR = 'unlinkDir';
exports.EV_RAW = 'raw';
exports.EV_ERROR = 'error';

exports.STR_DATA = 'data';
exports.STR_END = 'end';
exports.STR_CLOSE = 'close';

exports.FSEVENT_CREATED = 'created';
exports.FSEVENT_MODIFIED = 'modified';
exports.FSEVENT_DELETED = 'deleted';
exports.FSEVENT_MOVED = 'moved';
exports.FSEVENT_CLONED = 'cloned';
exports.FSEVENT_UNKNOWN = 'unknown';
exports.FSEVENT_TYPE_FILE = 'file';
exports.FSEVENT_TYPE_DIRECTORY = 'directory';
exports.FSEVENT_TYPE_SYMLINK = 'symlink';

exports.KEY_LISTENERS = 'listeners';
exports.KEY_ERR = 'errHandlers';
exports.KEY_RAW = 'rawEmitters';
exports.HANDLER_KEYS = [exports.KEY_LISTENERS, exports.KEY_ERR, exports.KEY_RAW];

exports.DOT_SLASH = `.${sep}`;

exports.BACK_SLASH_RE = /\\/g;
exports.DOUBLE_SLASH_RE = /\/\//;
exports.SLASH_OR_BACK_SLASH_RE = /[/\\]/;
exports.DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
exports.REPLACER_RE = /^\.[/\\]/;

exports.SLASH = '/';
exports.SLASH_SLASH = '//';
exports.BRACE_START = '{';
exports.BANG = '!';
exports.ONE_DOT = '.';
exports.TWO_DOTS = '..';
exports.STAR = '*';
exports.GLOBSTAR = '**';
exports.ROOT_GLOBSTAR = '/**/*';
exports.SLASH_GLOBSTAR = '/**';
exports.DIR_SUFFIX = 'Dir';
exports.ANYMATCH_OPTS = {dot: true};
exports.STRING_TYPE = 'string';
exports.FUNCTION_TYPE = 'function';
exports.EMPTY_STR = '';
exports.EMPTY_FN = () => {};
exports.IDENTITY_FN = val => val;

exports.isWindows = platform === 'win32';
exports.isMacos = platform === 'darwin';
exports.isLinux = platform === 'linux';
});

const fs = require('original-fs');

const { promisify: promisify$1 } = require$$0__default['default'];

const {
  isWindows,
  isLinux,
  EMPTY_FN,
  EMPTY_STR,
  KEY_LISTENERS,
  KEY_ERR,
  KEY_RAW,
  HANDLER_KEYS,
  EV_CHANGE,
  EV_ADD,
  EV_ADD_DIR,
  EV_ERROR,
  STR_DATA,
  STR_END,
  BRACE_START,
  STAR: STAR$1
} = constants$2;

const THROTTLE_MODE_WATCH = 'watch';

const open$1 = promisify$1(fs.open);
const stat$1 = promisify$1(fs.stat);
const lstat$1 = promisify$1(fs.lstat);
const close = promisify$1(fs.close);
const fsrealpath = promisify$1(fs.realpath);

const statMethods = { lstat: lstat$1, stat: stat$1 };

// TODO: emit errors properly. Example: EMFILE on Macos.
const foreach = (val, fn) => {
  if (val instanceof Set) {
    val.forEach(fn);
  } else {
    fn(val);
  }
};

const addAndConvert = (main, prop, item) => {
  let container = main[prop];
  if (!(container instanceof Set)) {
    main[prop] = container = new Set([container]);
  }
  container.add(item);
};

const clearItem = cont => key => {
  const set = cont[key];
  if (set instanceof Set) {
    set.clear();
  } else {
    delete cont[key];
  }
};

const delFromSet = (main, prop, item) => {
  const container = main[prop];
  if (container instanceof Set) {
    container.delete(item);
  } else if (container === item) {
    delete main[prop];
  }
};

const isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;

/**
 * @typedef {String} Path
 */

// fs_watch helpers

// object to hold per-process fs_watch instances
// (may be shared across chokidar FSWatcher instances)

/**
 * @typedef {Object} FsWatchContainer
 * @property {Set} listeners
 * @property {Set} errHandlers
 * @property {Set} rawEmitters
 * @property {fs.FSWatcher=} watcher
 * @property {Boolean=} watcherUnusable
 */

/**
 * @type {Map<String,FsWatchContainer>}
 */
const FsWatchInstances = new Map();

/**
 * Instantiates the fs_watch interface
 * @param {String} path to be watched
 * @param {Object} options to be passed to fs_watch
 * @param {Function} listener main event handler
 * @param {Function} errHandler emits info about errors
 * @param {Function} emitRaw emits raw event data
 * @returns {fs.FSWatcher} new fsevents instance
 */
function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
  const handleEvent = (rawEvent, evPath) => {
    listener(path);
    emitRaw(rawEvent, evPath, {watchedPath: path});

    // emit based on events occurring for files from a directory's watcher in
    // case the file's watcher misses it (and rely on throttling to de-dupe)
    if (evPath && path !== evPath) {
      fsWatchBroadcast(
        sysPath__default['default'].resolve(path, evPath), KEY_LISTENERS, sysPath__default['default'].join(path, evPath)
      );
    }
  };
  try {
    return fs.watch(path, options, handleEvent);
  } catch (error) {
    errHandler(error);
  }
}

/**
 * Helper for passing fs_watch event data to a collection of listeners
 * @param {Path} fullPath absolute path bound to fs_watch instance
 * @param {String} type listener type
 * @param {*=} val1 arguments to be passed to listeners
 * @param {*=} val2
 * @param {*=} val3
 */
const fsWatchBroadcast = (fullPath, type, val1, val2, val3) => {
  const cont = FsWatchInstances.get(fullPath);
  if (!cont) return;
  foreach(cont[type], (listener) => {
    listener(val1, val2, val3);
  });
};

/**
 * Instantiates the fs_watch interface or binds listeners
 * to an existing one covering the same file system entry
 * @param {String} path
 * @param {String} fullPath absolute path
 * @param {Object} options to be passed to fs_watch
 * @param {Object} handlers container for event listener functions
 */
const setFsWatchListener = (path, fullPath, options, handlers) => {
  const {listener, errHandler, rawEmitter} = handlers;
  let cont = FsWatchInstances.get(fullPath);

  /** @type {fs.FSWatcher=} */
  let watcher;
  if (!options.persistent) {
    watcher = createFsWatchInstance(
      path, options, listener, errHandler, rawEmitter
    );
    return watcher.close.bind(watcher);
  }
  if (cont) {
    addAndConvert(cont, KEY_LISTENERS, listener);
    addAndConvert(cont, KEY_ERR, errHandler);
    addAndConvert(cont, KEY_RAW, rawEmitter);
  } else {
    watcher = createFsWatchInstance(
      path,
      options,
      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
      errHandler, // no need to use broadcast here
      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
    );
    if (!watcher) return;
    watcher.on(EV_ERROR, async (error) => {
      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
      cont.watcherUnusable = true; // documented since Node 10.4.1
      // Workaround for https://github.com/joyent/node/issues/4337
      if (isWindows && error.code === 'EPERM') {
        try {
          const fd = await open$1(path, 'r');
          await close(fd);
          broadcastErr(error);
        } catch (err) {}
      } else {
        broadcastErr(error);
      }
    });
    cont = {
      listeners: listener,
      errHandlers: errHandler,
      rawEmitters: rawEmitter,
      watcher
    };
    FsWatchInstances.set(fullPath, cont);
  }
  // const index = cont.listeners.indexOf(listener);

  // removes this instance's listeners and closes the underlying fs_watch
  // instance if there are no more listeners left
  return () => {
    delFromSet(cont, KEY_LISTENERS, listener);
    delFromSet(cont, KEY_ERR, errHandler);
    delFromSet(cont, KEY_RAW, rawEmitter);
    if (isEmptySet(cont.listeners)) {
      // Check to protect against issue gh-730.
      // if (cont.watcherUnusable) {
      cont.watcher.close();
      // }
      FsWatchInstances.delete(fullPath);
      HANDLER_KEYS.forEach(clearItem(cont));
      cont.watcher = undefined;
      Object.freeze(cont);
    }
  };
};

// fs_watchFile helpers

// object to hold per-process fs_watchFile instances
// (may be shared across chokidar FSWatcher instances)
const FsWatchFileInstances = new Map();

/**
 * Instantiates the fs_watchFile interface or binds listeners
 * to an existing one covering the same file system entry
 * @param {String} path to be watched
 * @param {String} fullPath absolute path
 * @param {Object} options options to be passed to fs_watchFile
 * @param {Object} handlers container for event listener functions
 * @returns {Function} closer
 */
const setFsWatchFileListener = (path, fullPath, options, handlers) => {
  const {listener, rawEmitter} = handlers;
  let cont = FsWatchFileInstances.get(fullPath);

  /* eslint-disable no-unused-vars, prefer-destructuring */
  let listeners = new Set();
  let rawEmitters = new Set();

  const copts = cont && cont.options;
  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
    // "Upgrade" the watcher to persistence or a quicker interval.
    // This creates some unlikely edge case issues if the user mixes
    // settings in a very weird way, but solving for those cases
    // doesn't seem worthwhile for the added complexity.
    listeners = cont.listeners;
    rawEmitters = cont.rawEmitters;
    fs.unwatchFile(fullPath);
    cont = undefined;
  }

  /* eslint-enable no-unused-vars, prefer-destructuring */

  if (cont) {
    addAndConvert(cont, KEY_LISTENERS, listener);
    addAndConvert(cont, KEY_RAW, rawEmitter);
  } else {
    // TODO
    // listeners.add(listener);
    // rawEmitters.add(rawEmitter);
    cont = {
      listeners: listener,
      rawEmitters: rawEmitter,
      options,
      watcher: fs.watchFile(fullPath, options, (curr, prev) => {
        foreach(cont.rawEmitters, (rawEmitter) => {
          rawEmitter(EV_CHANGE, fullPath, {curr, prev});
        });
        const currmtime = curr.mtimeMs;
        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
          foreach(cont.listeners, (listener) => listener(path, curr));
        }
      })
    };
    FsWatchFileInstances.set(fullPath, cont);
  }
  // const index = cont.listeners.indexOf(listener);

  // Removes this instance's listeners and closes the underlying fs_watchFile
  // instance if there are no more listeners left.
  return () => {
    delFromSet(cont, KEY_LISTENERS, listener);
    delFromSet(cont, KEY_RAW, rawEmitter);
    if (isEmptySet(cont.listeners)) {
      FsWatchFileInstances.delete(fullPath);
      fs.unwatchFile(fullPath);
      cont.options = cont.watcher = undefined;
      Object.freeze(cont);
    }
  };
};

/**
 * @mixin
 */
class NodeFsHandler {

/**
 * @param {import("../index").FSWatcher} fsW
 */
constructor(fsW) {
  this.fsw = fsW;
  this._boundHandleError = (error) => fsW._handleError(error);
}

/**
 * Watch file for changes with fs_watchFile or fs_watch.
 * @param {String} path to file or dir
 * @param {Function} listener on fs change
 * @returns {Function} closer for the watcher instance
 */
_watchWithNodeFs(path, listener) {
  const opts = this.fsw.options;
  const directory = sysPath__default['default'].dirname(path);
  const basename = sysPath__default['default'].basename(path);
  const parent = this.fsw._getWatchedDir(directory);
  parent.add(basename);
  const absolutePath = sysPath__default['default'].resolve(path);
  const options = {persistent: opts.persistent};
  if (!listener) listener = EMPTY_FN;

  let closer;
  if (opts.usePolling) {
    options.interval = opts.enableBinaryInterval && isBinaryPath(basename) ?
      opts.binaryInterval : opts.interval;
    closer = setFsWatchFileListener(path, absolutePath, options, {
      listener,
      rawEmitter: this.fsw._emitRaw
    });
  } else {
    closer = setFsWatchListener(path, absolutePath, options, {
      listener,
      errHandler: this._boundHandleError,
      rawEmitter: this.fsw._emitRaw
    });
  }
  return closer;
}

/**
 * Watch a file and emit add event if warranted.
 * @param {Path} file Path
 * @param {fs.Stats} stats result of fs_stat
 * @param {Boolean} initialAdd was the file added at watch instantiation?
 * @returns {Function} closer for the watcher instance
 */
_handleFile(file, stats, initialAdd) {
  if (this.fsw.closed) {
    return;
  }
  const dirname = sysPath__default['default'].dirname(file);
  const basename = sysPath__default['default'].basename(file);
  const parent = this.fsw._getWatchedDir(dirname);
  // stats is always present
  let prevStats = stats;

  // if the file is already being watched, do nothing
  if (parent.has(basename)) return;

  const listener = async (path, newStats) => {
    if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
    if (!newStats || newStats.mtimeMs === 0) {
      try {
        const newStats = await stat$1(file);
        if (this.fsw.closed) return;
        // Check that change event was not fired because of changed only accessTime.
        const at = newStats.atimeMs;
        const mt = newStats.mtimeMs;
        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
          this.fsw._emit(EV_CHANGE, file, newStats);
        }
        if (isLinux && prevStats.ino !== newStats.ino) {
          this.fsw._closeFile(path);
          prevStats = newStats;
          this.fsw._addPathCloser(path, this._watchWithNodeFs(file, listener));
        } else {
          prevStats = newStats;
        }
      } catch (error) {
        // Fix issues where mtime is null but file is still present
        this.fsw._remove(dirname, basename);
      }
      // add is about to be emitted if file not already tracked in parent
    } else if (parent.has(basename)) {
      // Check that change event was not fired because of changed only accessTime.
      const at = newStats.atimeMs;
      const mt = newStats.mtimeMs;
      if (!at || at <= mt || mt !== prevStats.mtimeMs) {
        this.fsw._emit(EV_CHANGE, file, newStats);
      }
      prevStats = newStats;
    }
  };
  // kick off the watcher
  const closer = this._watchWithNodeFs(file, listener);

  // emit an add event if we're supposed to
  if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
    if (!this.fsw._throttle(EV_ADD, file, 0)) return;
    this.fsw._emit(EV_ADD, file, stats);
  }

  return closer;
}

/**
 * Handle symlinks encountered while reading a dir.
 * @param {Object} entry returned by readdirp
 * @param {String} directory path of dir being read
 * @param {String} path of this item
 * @param {String} item basename of this item
 * @returns {Promise<Boolean>} true if no more processing is needed for this entry.
 */
async _handleSymlink(entry, directory, path, item) {
  if (this.fsw.closed) {
    return;
  }
  const full = entry.fullPath;
  const dir = this.fsw._getWatchedDir(directory);

  if (!this.fsw.options.followSymlinks) {
    // watch symlink directly (don't follow) and detect changes
    this.fsw._incrReadyCount();
    const linkPath = await fsrealpath(path);
    if (this.fsw.closed) return;
    if (dir.has(item)) {
      if (this.fsw._symlinkPaths.get(full) !== linkPath) {
        this.fsw._symlinkPaths.set(full, linkPath);
        this.fsw._emit(EV_CHANGE, path, entry.stats);
      }
    } else {
      dir.add(item);
      this.fsw._symlinkPaths.set(full, linkPath);
      this.fsw._emit(EV_ADD, path, entry.stats);
    }
    this.fsw._emitReady();
    return true;
  }

  // don't follow the same symlink more than once
  if (this.fsw._symlinkPaths.has(full)) {
    return true;
  }

  this.fsw._symlinkPaths.set(full, true);
}

_handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
  // Normalize the directory name on Windows
  directory = sysPath__default['default'].join(directory, EMPTY_STR);

  if (!wh.hasGlob) {
    throttler = this.fsw._throttle('readdir', directory, 1000);
    if (!throttler) return;
  }

  const previous = this.fsw._getWatchedDir(wh.path);
  const current = new Set();

  let stream = this.fsw._readdirp(directory, {
    fileFilter: entry => wh.filterPath(entry),
    directoryFilter: entry => wh.filterDir(entry),
    depth: 0
  }).on(STR_DATA, async (entry) => {
    if (this.fsw.closed) {
      stream = undefined;
      return;
    }
    const item = entry.path;
    let path = sysPath__default['default'].join(directory, item);
    current.add(item);

    if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
      return;
    }

    if (this.fsw.closed) {
      stream = undefined;
      return;
    }
    // Files that present in current directory snapshot
    // but absent in previous are added to watch list and
    // emit `add` event.
    if (item === target || !target && !previous.has(item)) {
      this.fsw._incrReadyCount();

      // ensure relativeness of path is preserved in case of watcher reuse
      path = sysPath__default['default'].join(dir, sysPath__default['default'].relative(dir, path));

      this._addToNodeFs(path, initialAdd, wh, depth + 1);
    }
  }).on(EV_ERROR, this._boundHandleError);

  return new Promise(resolve =>
    stream.once(STR_END, () => {
      if (this.fsw.closed) {
        stream = undefined;
        return;
      }
      const wasThrottled = throttler ? throttler.clear() : false;

      resolve();

      // Files that absent in current directory snapshot
      // but present in previous emit `remove` event
      // and are removed from @watched[directory].
      previous.getChildren().filter((item) => {
        return item !== directory &&
          !current.has(item) &&
          // in case of intersecting globs;
          // a path may have been filtered out of this readdir, but
          // shouldn't be removed because it matches a different glob
          (!wh.hasGlob || wh.filterPath({
            fullPath: sysPath__default['default'].resolve(directory, item)
          }));
      }).forEach((item) => {
        this.fsw._remove(directory, item);
      });

      stream = undefined;

      // one more time for any missed in case changes came in extremely quickly
      if (wasThrottled) this._handleRead(directory, false, wh, target, dir, depth, throttler);
    })
  );
}

/**
 * Read directory to add / remove files from `@watched` list and re-read it on change.
 * @param {String} dir fs path
 * @param {fs.Stats} stats
 * @param {Boolean} initialAdd
 * @param {Number} depth relative to user-supplied path
 * @param {String} target child path targeted for watch
 * @param {Object} wh Common watch helpers for this path
 * @param {String} realpath
 * @returns {Promise<Function>} closer for the watcher instance.
 */
async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
  const parentDir = this.fsw._getWatchedDir(sysPath__default['default'].dirname(dir));
  const tracked = parentDir.has(sysPath__default['default'].basename(dir));
  if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
    if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR, dir, stats);
  }

  // ensure dir is tracked (harmless if redundant)
  parentDir.add(sysPath__default['default'].basename(dir));
  this.fsw._getWatchedDir(dir);
  let throttler;
  let closer;

  const oDepth = this.fsw.options.depth;
  if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath)) {
    if (!target) {
      await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
      if (this.fsw.closed) return;
    }

    closer = this._watchWithNodeFs(dir, (dirPath, stats) => {
      // if current directory is removed, do nothing
      if (stats && stats.mtimeMs === 0) return;

      this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
    });
  }
  return closer;
}

/**
 * Handle added file, directory, or glob pattern.
 * Delegates call to _handleFile / _handleDir after checks.
 * @param {String} path to file or ir
 * @param {Boolean} initialAdd was the file added at watch instantiation?
 * @param {Object} priorWh depth relative to user-supplied path
 * @param {Number} depth Child path actually targeted for watch
 * @param {String=} target Child path actually targeted for watch
 * @returns {Promise}
 */
async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
  const ready = this.fsw._emitReady;
  if (this.fsw._isIgnored(path) || this.fsw.closed) {
    ready();
    return false;
  }

  const wh = this.fsw._getWatchHelpers(path, depth);
  if (!wh.hasGlob && priorWh) {
    wh.hasGlob = priorWh.hasGlob;
    wh.globFilter = priorWh.globFilter;
    wh.filterPath = entry => priorWh.filterPath(entry);
    wh.filterDir = entry => priorWh.filterDir(entry);
  }

  // evaluate what is at the path we're being asked to watch
  try {
    const stats = await statMethods[wh.statMethod](wh.watchPath);
    if (this.fsw.closed) return;
    if (this.fsw._isIgnored(wh.watchPath, stats)) {
      ready();
      return false;
    }

    const follow = this.fsw.options.followSymlinks && !path.includes(STAR$1) && !path.includes(BRACE_START);
    let closer;
    if (stats.isDirectory()) {
      const targetPath = follow ? await fsrealpath(path) : path;
      if (this.fsw.closed) return;
      closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
      if (this.fsw.closed) return;
      // preserve this symlink's target path
      if (path !== targetPath && targetPath !== undefined) {
        this.fsw._symlinkPaths.set(targetPath, true);
      }
    } else if (stats.isSymbolicLink()) {
      const targetPath = follow ? await fsrealpath(path) : path;
      if (this.fsw.closed) return;
      const parent = sysPath__default['default'].dirname(wh.watchPath);
      this.fsw._getWatchedDir(parent).add(wh.watchPath);
      this.fsw._emit(EV_ADD, wh.watchPath, stats);
      closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
      if (this.fsw.closed) return;

      // preserve this symlink's target path
      if (targetPath !== undefined) {
        this.fsw._symlinkPaths.set(sysPath__default['default'].resolve(path), targetPath);
      }
    } else {
      closer = this._handleFile(wh.watchPath, stats, initialAdd);
    }
    ready();

    this.fsw._addPathCloser(path, closer);
    return false;

  } catch (error) {
    if (this.fsw._handleError(error)) {
      ready();
      return path;
    }
  }
}

}

var nodefsHandler = NodeFsHandler;

const fs$1 = require('original-fs');

const { promisify: promisify$2 } = require$$0__default['default'];

let fsevents;
try {
  fsevents = null;
} catch (error) {
  if (process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR) console.error(error);
}

if (fsevents) {
  // TODO: real check
  const mtch = process.version.match(/v(\d+)\.(\d+)/);
  if (mtch && mtch[1] && mtch[2]) {
    const maj = Number.parseInt(mtch[1], 10);
    const min = Number.parseInt(mtch[2], 10);
    if (maj === 8 && min < 16) {
      fsevents = undefined;
    }
  }
}

const {
  EV_ADD: EV_ADD$1,
  EV_CHANGE: EV_CHANGE$1,
  EV_ADD_DIR: EV_ADD_DIR$1,
  EV_UNLINK,
  EV_ERROR: EV_ERROR$1,
  STR_DATA: STR_DATA$1,
  STR_END: STR_END$1,
  FSEVENT_CREATED,
  FSEVENT_MODIFIED,
  FSEVENT_DELETED,
  FSEVENT_MOVED,
  // FSEVENT_CLONED,
  FSEVENT_UNKNOWN,
  FSEVENT_TYPE_FILE,
  FSEVENT_TYPE_DIRECTORY,
  FSEVENT_TYPE_SYMLINK,

  ROOT_GLOBSTAR,
  DIR_SUFFIX,
  DOT_SLASH,
  FUNCTION_TYPE,
  EMPTY_FN: EMPTY_FN$1,
  IDENTITY_FN
} = constants$2;

const Depth = (value) => isNaN(value) ? {} : {depth: value};

const stat$2 = promisify$2(fs$1.stat);
const lstat$2 = promisify$2(fs$1.lstat);
const realpath$1 = promisify$2(fs$1.realpath);

const statMethods$1 = { stat: stat$2, lstat: lstat$2 };

/**
 * @typedef {String} Path
 */

/**
 * @typedef {Object} FsEventsWatchContainer
 * @property {Set<Function>} listeners
 * @property {Function} rawEmitter
 * @property {{stop: Function}} watcher
 */

// fsevents instance helper functions
/**
 * Object to hold per-process fsevents instances (may be shared across chokidar FSWatcher instances)
 * @type {Map<Path,FsEventsWatchContainer>}
 */
const FSEventsWatchers = new Map();

// Threshold of duplicate path prefixes at which to start
// consolidating going forward
const consolidateThreshhold = 10;

const wrongEventFlags = new Set([
  69888, 70400, 71424, 72704, 73472, 131328, 131840, 262912
]);

/**
 * Instantiates the fsevents interface
 * @param {Path} path path to be watched
 * @param {Function} callback called when fsevents is bound and ready
 * @returns {{stop: Function}} new fsevents instance
 */
const createFSEventsInstance = (path, callback) => {
  const stop = fsevents.watch(path, callback);
  return {stop};
};

/**
 * Instantiates the fsevents interface or binds listeners to an existing one covering
 * the same file tree.
 * @param {Path} path           - to be watched
 * @param {Path} realPath       - real path for symlinks
 * @param {Function} listener   - called when fsevents emits events
 * @param {Function} rawEmitter - passes data to listeners of the 'raw' event
 * @returns {Function} closer
 */
function setFSEventsListener(path, realPath, listener, rawEmitter) {
  let watchPath = sysPath__default['default'].extname(path) ? sysPath__default['default'].dirname(path) : path;
  const parentPath = sysPath__default['default'].dirname(watchPath);
  let cont = FSEventsWatchers.get(watchPath);

  // If we've accumulated a substantial number of paths that
  // could have been consolidated by watching one directory
  // above the current one, create a watcher on the parent
  // path instead, so that we do consolidate going forward.
  if (couldConsolidate(parentPath)) {
    watchPath = parentPath;
  }

  const resolvedPath = sysPath__default['default'].resolve(path);
  const hasSymlink = resolvedPath !== realPath;

  const filteredListener = (fullPath, flags, info) => {
    if (hasSymlink) fullPath = fullPath.replace(realPath, resolvedPath);
    if (
      fullPath === resolvedPath ||
      !fullPath.indexOf(resolvedPath + sysPath__default['default'].sep)
    ) listener(fullPath, flags, info);
  };

  // check if there is already a watcher on a parent path
  // modifies `watchPath` to the parent path when it finds a match
  let watchedParent = false;
  for (const watchedPath of FSEventsWatchers.keys()) {
    if (realPath.indexOf(sysPath__default['default'].resolve(watchedPath) + sysPath__default['default'].sep) === 0) {
      watchPath = watchedPath;
      cont = FSEventsWatchers.get(watchPath);
      watchedParent = true;
      break;
    }
  }

  if (cont || watchedParent) {
    cont.listeners.add(filteredListener);
  } else {
    cont = {
      listeners: new Set([filteredListener]),
      rawEmitter,
      watcher: createFSEventsInstance(watchPath, (fullPath, flags) => {
        if (!cont.listeners.size) return;
        const info = fsevents.getInfo(fullPath, flags);
        cont.listeners.forEach(list => {
          list(fullPath, flags, info);
        });

        cont.rawEmitter(info.event, fullPath, info);
      })
    };
    FSEventsWatchers.set(watchPath, cont);
  }

  // removes this instance's listeners and closes the underlying fsevents
  // instance if there are no more listeners left
  return () => {
    const lst = cont.listeners;

    lst.delete(filteredListener);
    if (!lst.size) {
      FSEventsWatchers.delete(watchPath);
      if (cont.watcher) return cont.watcher.stop().then(() => {
        cont.rawEmitter = cont.watcher = undefined;
        Object.freeze(cont);
      });
    }
  };
}

// Decide whether or not we should start a new higher-level
// parent watcher
const couldConsolidate = (path) => {
  let count = 0;
  for (const watchPath of FSEventsWatchers.keys()) {
    if (watchPath.indexOf(path) === 0) {
      count++;
      if (count >= consolidateThreshhold) {
        return true;
      }
    }
  }

  return false;
};

// returns boolean indicating whether fsevents can be used
const canUse = () => fsevents && FSEventsWatchers.size < 128;

// determines subdirectory traversal levels from root to path
const calcDepth = (path, root) => {
  let i = 0;
  while (!path.indexOf(root) && (path = sysPath__default['default'].dirname(path)) !== root) i++;
  return i;
};

// returns boolean indicating whether the fsevents' event info has the same type
// as the one returned by fs.stat
const sameTypes = (info, stats) => (
  info.type === FSEVENT_TYPE_DIRECTORY && stats.isDirectory() ||
  info.type === FSEVENT_TYPE_SYMLINK && stats.isSymbolicLink() ||
  info.type === FSEVENT_TYPE_FILE && stats.isFile()
);

/**
 * @mixin
 */
class FsEventsHandler {

/**
 * @param {import('../index').FSWatcher} fsw
 */
constructor(fsw) {
  this.fsw = fsw;
}
checkIgnored(path, stats) {
  const ipaths = this.fsw._ignoredPaths;
  if (this.fsw._isIgnored(path, stats)) {
    ipaths.add(path);
    if (stats && stats.isDirectory()) {
      ipaths.add(path + ROOT_GLOBSTAR);
    }
    return true;
  }

  ipaths.delete(path);
  ipaths.delete(path + ROOT_GLOBSTAR);
}

addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
  const event = watchedDir.has(item) ? EV_CHANGE$1 : EV_ADD$1;
  this.handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts);
}

async checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
  try {
    const stats = await stat$2(path);
    if (this.fsw.closed) return;
    if (sameTypes(info, stats)) {
      this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
    } else {
      this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
    }
  } catch (error) {
    if (error.code === 'EACCES') {
      this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
    } else {
      this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
    }
  }
}

handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts) {
  if (this.fsw.closed || this.checkIgnored(path)) return;

  if (event === EV_UNLINK) {
    const isDirectory = info.type === FSEVENT_TYPE_DIRECTORY;
    // suppress unlink events on never before seen files
    if (isDirectory || watchedDir.has(item)) {
      this.fsw._remove(parent, item, isDirectory);
    }
  } else {
    if (event === EV_ADD$1) {
      // track new directories
      if (info.type === FSEVENT_TYPE_DIRECTORY) this.fsw._getWatchedDir(path);

      if (info.type === FSEVENT_TYPE_SYMLINK && opts.followSymlinks) {
        // push symlinks back to the top of the stack to get handled
        const curDepth = opts.depth === undefined ?
          undefined : calcDepth(fullPath, realPath) + 1;
        return this._addToFsEvents(path, false, true, curDepth);
      }

      // track new paths
      // (other than symlinks being followed, which will be tracked soon)
      this.fsw._getWatchedDir(parent).add(item);
    }
    /**
     * @type {'add'|'addDir'|'unlink'|'unlinkDir'}
     */
    const eventName = info.type === FSEVENT_TYPE_DIRECTORY ? event + DIR_SUFFIX : event;
    this.fsw._emit(eventName, path);
    if (eventName === EV_ADD_DIR$1) this._addToFsEvents(path, false, true);
  }
}

/**
 * Handle symlinks encountered during directory scan
 * @param {String} watchPath  - file/dir path to be watched with fsevents
 * @param {String} realPath   - real path (in case of symlinks)
 * @param {Function} transform  - path transformer
 * @param {Function} globFilter - path filter in case a glob pattern was provided
 * @returns {Function} closer for the watcher instance
*/
_watchWithFsEvents(watchPath, realPath, transform, globFilter) {
  if (this.fsw.closed || this.fsw._isIgnored(watchPath)) return;
  const opts = this.fsw.options;
  const watchCallback = async (fullPath, flags, info) => {
    if (this.fsw.closed) return;
    if (
      opts.depth !== undefined &&
      calcDepth(fullPath, realPath) > opts.depth
    ) return;
    const path = transform(sysPath__default['default'].join(
      watchPath, sysPath__default['default'].relative(watchPath, fullPath)
    ));
    if (globFilter && !globFilter(path)) return;
    // ensure directories are tracked
    const parent = sysPath__default['default'].dirname(path);
    const item = sysPath__default['default'].basename(path);
    const watchedDir = this.fsw._getWatchedDir(
      info.type === FSEVENT_TYPE_DIRECTORY ? path : parent
    );

    // correct for wrong events emitted
    if (wrongEventFlags.has(flags) || info.event === FSEVENT_UNKNOWN) {
      if (typeof opts.ignored === FUNCTION_TYPE) {
        let stats;
        try {
          stats = await stat$2(path);
        } catch (error) {}
        if (this.fsw.closed) return;
        if (this.checkIgnored(path, stats)) return;
        if (sameTypes(info, stats)) {
          this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
        } else {
          this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
        }
      } else {
        this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
      }
    } else {
      switch (info.event) {
      case FSEVENT_CREATED:
      case FSEVENT_MODIFIED:
        return this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
      case FSEVENT_DELETED:
      case FSEVENT_MOVED:
        return this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
      }
    }
  };

  const closer = setFSEventsListener(
    watchPath,
    realPath,
    watchCallback,
    this.fsw._emitRaw
  );

  this.fsw._emitReady();
  return closer;
}

/**
 * Handle symlinks encountered during directory scan
 * @param {String} linkPath path to symlink
 * @param {String} fullPath absolute path to the symlink
 * @param {Function} transform pre-existing path transformer
 * @param {Number} curDepth level of subdirectories traversed to where symlink is
 * @returns {Promise<void>}
 */
async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
  // don't follow the same symlink more than once
  if (this.fsw.closed || this.fsw._symlinkPaths.has(fullPath)) return;

  this.fsw._symlinkPaths.set(fullPath, true);
  this.fsw._incrReadyCount();

  try {
    const linkTarget = await realpath$1(linkPath);
    if (this.fsw.closed) return;
    if (this.fsw._isIgnored(linkTarget)) {
      return this.fsw._emitReady();
    }

    this.fsw._incrReadyCount();

    // add the linkTarget for watching with a wrapper for transform
    // that causes emitted paths to incorporate the link's path
    this._addToFsEvents(linkTarget || linkPath, (path) => {
      let aliasedPath = linkPath;
      if (linkTarget && linkTarget !== DOT_SLASH) {
        aliasedPath = path.replace(linkTarget, linkPath);
      } else if (path !== DOT_SLASH) {
        aliasedPath = sysPath__default['default'].join(linkPath, path);
      }
      return transform(aliasedPath);
    }, false, curDepth);
  } catch(error) {
    if (this.fsw._handleError(error)) {
      return this.fsw._emitReady();
    }
  }
}

/**
 *
 * @param {Path} newPath
 * @param {fs.Stats} stats
 */
emitAdd(newPath, stats, processPath, opts, forceAdd) {
  const pp = processPath(newPath);
  const isDir = stats.isDirectory();
  const dirObj = this.fsw._getWatchedDir(sysPath__default['default'].dirname(pp));
  const base = sysPath__default['default'].basename(pp);

  // ensure empty dirs get tracked
  if (isDir) this.fsw._getWatchedDir(pp);
  if (dirObj.has(base)) return;
  dirObj.add(base);

  if (!opts.ignoreInitial || forceAdd === true) {
    this.fsw._emit(isDir ? EV_ADD_DIR$1 : EV_ADD$1, pp, stats);
  }
}

initWatch(realPath, path, wh, processPath) {
  if (this.fsw.closed) return;
  const closer = this._watchWithFsEvents(
    wh.watchPath,
    sysPath__default['default'].resolve(realPath || wh.watchPath),
    processPath,
    wh.globFilter
  );
  this.fsw._addPathCloser(path, closer);
}

/**
 * Handle added path with fsevents
 * @param {String} path file/dir path or glob pattern
 * @param {Function|Boolean=} transform converts working path to what the user expects
 * @param {Boolean=} forceAdd ensure add is emitted
 * @param {Number=} priorDepth Level of subdirectories already traversed.
 * @returns {Promise<void>}
 */
async _addToFsEvents(path, transform, forceAdd, priorDepth) {
  if (this.fsw.closed) {
    return;
  }
  const opts = this.fsw.options;
  const processPath = typeof transform === FUNCTION_TYPE ? transform : IDENTITY_FN;

  const wh = this.fsw._getWatchHelpers(path);

  // evaluate what is at the path we're being asked to watch
  try {
    const stats = await statMethods$1[wh.statMethod](wh.watchPath);
    if (this.fsw.closed) return;
    if (this.fsw._isIgnored(wh.watchPath, stats)) {
      throw null;
    }
    if (stats.isDirectory()) {
      // emit addDir unless this is a glob parent
      if (!wh.globFilter) this.emitAdd(processPath(path), stats, processPath, opts, forceAdd);

      // don't recurse further if it would exceed depth setting
      if (priorDepth && priorDepth > opts.depth) return;

      // scan the contents of the dir
      this.fsw._readdirp(wh.watchPath, {
        fileFilter: entry => wh.filterPath(entry),
        directoryFilter: entry => wh.filterDir(entry),
        ...Depth(opts.depth - (priorDepth || 0))
      }).on(STR_DATA$1, (entry) => {
        // need to check filterPath on dirs b/c filterDir is less restrictive
        if (this.fsw.closed) {
          return;
        }
        if (entry.stats.isDirectory() && !wh.filterPath(entry)) return;

        const joinedPath = sysPath__default['default'].join(wh.watchPath, entry.path);
        const {fullPath} = entry;

        if (wh.followSymlinks && entry.stats.isSymbolicLink()) {
          // preserve the current depth here since it can't be derived from
          // real paths past the symlink
          const curDepth = opts.depth === undefined ?
            undefined : calcDepth(joinedPath, sysPath__default['default'].resolve(wh.watchPath)) + 1;

          this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
        } else {
          this.emitAdd(joinedPath, entry.stats, processPath, opts, forceAdd);
        }
      }).on(EV_ERROR$1, EMPTY_FN$1).on(STR_END$1, () => {
        this.fsw._emitReady();
      });
    } else {
      this.emitAdd(wh.watchPath, stats, processPath, opts, forceAdd);
      this.fsw._emitReady();
    }
  } catch (error) {
    if (!error || this.fsw._handleError(error)) {
      // TODO: Strange thing: "should not choke on an ignored watch path" will be failed without 2 ready calls -__-
      this.fsw._emitReady();
      this.fsw._emitReady();
    }
  }

  if (opts.persistent && forceAdd !== true) {
    if (typeof transform === FUNCTION_TYPE) {
      // realpath has already been resolved
      this.initWatch(undefined, path, wh, processPath);
    } else {
      let realPath;
      try {
        realPath = await realpath$1(wh.watchPath);
      } catch (e) {}
      this.initWatch(realPath, path, wh, processPath);
    }
  }
}

}

var fseventsHandler = FsEventsHandler;
var canUse_1 = canUse;
fseventsHandler.canUse = canUse_1;

const { EventEmitter } = require$$0__default$2['default'];
const fs$2 = require('original-fs');

const { promisify: promisify$3 } = require$$0__default['default'];

const anymatch = anymatch_1.default;







const {
  EV_ALL,
  EV_READY,
  EV_ADD: EV_ADD$2,
  EV_CHANGE: EV_CHANGE$2,
  EV_UNLINK: EV_UNLINK$1,
  EV_ADD_DIR: EV_ADD_DIR$2,
  EV_UNLINK_DIR,
  EV_RAW,
  EV_ERROR: EV_ERROR$2,

  STR_CLOSE,
  STR_END: STR_END$2,

  BACK_SLASH_RE,
  DOUBLE_SLASH_RE,
  SLASH_OR_BACK_SLASH_RE,
  DOT_RE,
  REPLACER_RE,

  SLASH,
  SLASH_SLASH,
  BRACE_START: BRACE_START$1,
  BANG: BANG$1,
  ONE_DOT,
  TWO_DOTS,
  GLOBSTAR,
  SLASH_GLOBSTAR,
  ANYMATCH_OPTS,
  STRING_TYPE,
  FUNCTION_TYPE: FUNCTION_TYPE$1,
  EMPTY_STR: EMPTY_STR$1,
  EMPTY_FN: EMPTY_FN$2,

  isWindows: isWindows$1,
  isMacos
} = constants$2;

const stat$3 = promisify$3(fs$2.stat);
const readdir$1 = promisify$3(fs$2.readdir);

/**
 * @typedef {String} Path
 * @typedef {'all'|'add'|'addDir'|'change'|'unlink'|'unlinkDir'|'raw'|'error'|'ready'} EventName
 * @typedef {'readdir'|'watch'|'add'|'remove'|'change'} ThrottleType
 */

/**
 *
 * @typedef {Object} WatchHelpers
 * @property {Boolean} followSymlinks
 * @property {'stat'|'lstat'} statMethod
 * @property {Path} path
 * @property {Path} watchPath
 * @property {Function} entryPath
 * @property {Boolean} hasGlob
 * @property {Object} globFilter
 * @property {Function} filterPath
 * @property {Function} filterDir
 */

const arrify = (value = []) => Array.isArray(value) ? value : [value];
const flatten = (list, result = []) => {
  list.forEach(item => {
    if (Array.isArray(item)) {
      flatten(item, result);
    } else {
      result.push(item);
    }
  });
  return result;
};

const unifyPaths = (paths_) => {
  /**
   * @type {Array<String>}
   */
  const paths = flatten(arrify(paths_));
  if (!paths.every(p => typeof p === STRING_TYPE)) {
    throw new TypeError(`Non-string provided as watch path: ${paths}`);
  }
  return paths.map(normalizePathToUnix);
};

// If SLASH_SLASH occurs at the beginning of path, it is not replaced
//     because "//StoragePC/DrivePool/Movies" is a valid network path
const toUnix = (string) => {
  let str = string.replace(BACK_SLASH_RE, SLASH);
  let prepend = false;
  if (str.startsWith(SLASH_SLASH)) {
    prepend = true;
  }
  while (str.match(DOUBLE_SLASH_RE)) {
    str = str.replace(DOUBLE_SLASH_RE, SLASH);
  }
  if (prepend) {
    str = SLASH + str;
  }
  return str;
};

// Our version of upath.normalize
// TODO: this is not equal to path-normalize module - investigate why
const normalizePathToUnix = (path) => toUnix(sysPath__default['default'].normalize(toUnix(path)));

const normalizeIgnored = (cwd = EMPTY_STR$1) => (path) => {
  if (typeof path !== STRING_TYPE) return path;
  return normalizePathToUnix(sysPath__default['default'].isAbsolute(path) ? path : sysPath__default['default'].join(cwd, path));
};

const getAbsolutePath = (path, cwd) => {
  if (sysPath__default['default'].isAbsolute(path)) {
    return path;
  }
  if (path.startsWith(BANG$1)) {
    return BANG$1 + sysPath__default['default'].join(cwd, path.slice(1));
  }
  return sysPath__default['default'].join(cwd, path);
};

const undef = (opts, key) => opts[key] === undefined;

/**
 * Directory entry.
 * @property {Path} path
 * @property {Set<Path>} items
 */
class DirEntry {
  /**
   * @param {Path} dir
   * @param {Function} removeWatcher
   */
  constructor(dir, removeWatcher) {
    this.path = dir;
    this._removeWatcher = removeWatcher;
    /** @type {Set<Path>} */
    this.items = new Set();
  }

  add(item) {
    const {items} = this;
    if (!items) return;
    if (item !== ONE_DOT && item !== TWO_DOTS) items.add(item);
  }

  async remove(item) {
    const {items} = this;
    if (!items) return;
    items.delete(item);
    if (items.size > 0) return;

    const dir = this.path;
    try {
      await readdir$1(dir);
    } catch (err) {
      if (this._removeWatcher) {
        this._removeWatcher(sysPath__default['default'].dirname(dir), sysPath__default['default'].basename(dir));
      }
    }
  }

  has(item) {
    const {items} = this;
    if (!items) return;
    return items.has(item);
  }

  /**
   * @returns {Array<String>}
   */
  getChildren() {
    const {items} = this;
    if (!items) return;
    return [...items.values()];
  }

  dispose() {
    this.items.clear();
    delete this.path;
    delete this._removeWatcher;
    delete this.items;
    Object.freeze(this);
  }
}

const STAT_METHOD_F = 'stat';
const STAT_METHOD_L = 'lstat';
class WatchHelper {
  constructor(path, watchPath, follow, fsw) {
    this.fsw = fsw;
    this.path = path = path.replace(REPLACER_RE, EMPTY_STR$1);
    this.watchPath = watchPath;
    this.fullWatchPath = sysPath__default['default'].resolve(watchPath);
    this.hasGlob = watchPath !== path;
    /** @type {object|boolean} */
    if (path === EMPTY_STR$1) this.hasGlob = false;
    this.globSymlink = this.hasGlob && follow ? undefined : false;
    this.globFilter = this.hasGlob ? anymatch(path, undefined, ANYMATCH_OPTS) : false;
    this.dirParts = this.getDirParts(path);
    this.dirParts.forEach((parts) => {
      if (parts.length > 1) parts.pop();
    });
    this.followSymlinks = follow;
    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
  }

  checkGlobSymlink(entry) {
    // only need to resolve once
    // first entry should always have entry.parentDir === EMPTY_STR
    if (this.globSymlink === undefined) {
      this.globSymlink = entry.fullParentDir === this.fullWatchPath ?
        false : {realPath: entry.fullParentDir, linkPath: this.fullWatchPath};
    }

    if (this.globSymlink) {
      return entry.fullPath.replace(this.globSymlink.realPath, this.globSymlink.linkPath);
    }

    return entry.fullPath;
  }

  entryPath(entry) {
    return sysPath__default['default'].join(this.watchPath,
      sysPath__default['default'].relative(this.watchPath, this.checkGlobSymlink(entry))
    );
  }

  filterPath(entry) {
    const {stats} = entry;
    if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
    const resolvedPath = this.entryPath(entry);
    const matchesGlob = this.hasGlob && typeof this.globFilter === FUNCTION_TYPE$1 ?
      this.globFilter(resolvedPath) : true;
    return matchesGlob &&
      this.fsw._isntIgnored(resolvedPath, stats) &&
      this.fsw._hasReadPermissions(stats);
  }

  getDirParts(path) {
    if (!this.hasGlob) return [];
    const parts = [];
    const expandedPath = path.includes(BRACE_START$1) ? braces_1.expand(path) : [path];
    expandedPath.forEach((path) => {
      parts.push(sysPath__default['default'].relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
    });
    return parts;
  }

  filterDir(entry) {
    if (this.hasGlob) {
      const entryParts = this.getDirParts(this.checkGlobSymlink(entry));
      let globstar = false;
      this.unmatchedGlob = !this.dirParts.some((parts) => {
        return parts.every((part, i) => {
          if (part === GLOBSTAR) globstar = true;
          return globstar || !entryParts[0][i] || anymatch(part, entryParts[0][i], ANYMATCH_OPTS);
        });
      });
    }
    return !this.unmatchedGlob && this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
  }
}

/**
 * Watches files & directories for changes. Emitted events:
 * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
 *
 *     new FSWatcher()
 *       .add(directories)
 *       .on('add', path => log('File', path, 'was added'))
 */
class FSWatcher extends EventEmitter {
// Not indenting methods for history sake; for now.
constructor(_opts) {
  super();

  const opts = {};
  if (_opts) Object.assign(opts, _opts); // for frozen objects

  /** @type {Map<String, DirEntry>} */
  this._watched = new Map();
  /** @type {Map<String, Array>} */
  this._closers = new Map();
  /** @type {Set<String>} */
  this._ignoredPaths = new Set();

  /** @type {Map<ThrottleType, Map>} */
  this._throttled = new Map();

  /** @type {Map<Path, String|Boolean>} */
  this._symlinkPaths = new Map();

  this._streams = new Set();
  this.closed = false;

  // Set up default options.
  if (undef(opts, 'persistent')) opts.persistent = true;
  if (undef(opts, 'ignoreInitial')) opts.ignoreInitial = false;
  if (undef(opts, 'ignorePermissionErrors')) opts.ignorePermissionErrors = false;
  if (undef(opts, 'interval')) opts.interval = 100;
  if (undef(opts, 'binaryInterval')) opts.binaryInterval = 300;
  if (undef(opts, 'disableGlobbing')) opts.disableGlobbing = false;
  opts.enableBinaryInterval = opts.binaryInterval !== opts.interval;

  // Enable fsevents on OS X when polling isn't explicitly enabled.
  if (undef(opts, 'useFsEvents')) opts.useFsEvents = !opts.usePolling;

  // If we can't use fsevents, ensure the options reflect it's disabled.
  const canUseFsEvents = fseventsHandler.canUse();
  if (!canUseFsEvents) opts.useFsEvents = false;

  // Use polling on Mac if not using fsevents.
  // Other platforms use non-polling fs_watch.
  if (undef(opts, 'usePolling') && !opts.useFsEvents) {
    opts.usePolling = isMacos;
  }

  // Global override (useful for end-developers that need to force polling for all
  // instances of chokidar, regardless of usage/dependency depth)
  const envPoll = process.env.CHOKIDAR_USEPOLLING;
  if (envPoll !== undefined) {
    const envLower = envPoll.toLowerCase();

    if (envLower === 'false' || envLower === '0') {
      opts.usePolling = false;
    } else if (envLower === 'true' || envLower === '1') {
      opts.usePolling = true;
    } else {
      opts.usePolling = !!envLower;
    }
  }
  const envInterval = process.env.CHOKIDAR_INTERVAL;
  if (envInterval) {
    opts.interval = Number.parseInt(envInterval, 10);
  }

  // Editor atomic write normalization enabled by default with fs.watch
  if (undef(opts, 'atomic')) opts.atomic = !opts.usePolling && !opts.useFsEvents;
  if (opts.atomic) this._pendingUnlinks = new Map();

  if (undef(opts, 'followSymlinks')) opts.followSymlinks = true;

  if (undef(opts, 'awaitWriteFinish')) opts.awaitWriteFinish = false;
  if (opts.awaitWriteFinish === true) opts.awaitWriteFinish = {};
  const awf = opts.awaitWriteFinish;
  if (awf) {
    if (!awf.stabilityThreshold) awf.stabilityThreshold = 2000;
    if (!awf.pollInterval) awf.pollInterval = 100;
    this._pendingWrites = new Map();
  }
  if (opts.ignored) opts.ignored = arrify(opts.ignored);

  let readyCalls = 0;
  this._emitReady = () => {
    readyCalls++;
    if (readyCalls >= this._readyCount) {
      this._emitReady = EMPTY_FN$2;
      this._readyEmitted = true;
      // use process.nextTick to allow time for listener to be bound
      process.nextTick(() => this.emit(EV_READY));
    }
  };
  this._emitRaw = (...args) => this.emit(EV_RAW, ...args);
  this._readyEmitted = false;
  this.options = opts;

  // Initialize with proper watcher.
  if (opts.useFsEvents) {
    this._fsEventsHandler = new fseventsHandler(this);
  } else {
    this._nodeFsHandler = new nodefsHandler(this);
  }

  // You’re frozen when your heart’s not open.
  Object.freeze(opts);
}

// Public methods

/**
 * Adds paths to be watched on an existing FSWatcher instance
 * @param {Path|Array<Path>} paths_
 * @param {String=} _origAdd private; for handling non-existent paths to be watched
 * @param {Boolean=} _internal private; indicates a non-user add
 * @returns {FSWatcher} for chaining
 */
add(paths_, _origAdd, _internal) {
  const {cwd, disableGlobbing} = this.options;
  this.closed = false;
  let paths = unifyPaths(paths_);
  if (cwd) {
    paths = paths.map((path) => {
      const absPath = getAbsolutePath(path, cwd);

      // Check `path` instead of `absPath` because the cwd portion can't be a glob
      if (disableGlobbing || !isGlob(path)) {
        return absPath;
      }
      return normalizePath(absPath);
    });
  }

  // set aside negated glob strings
  paths = paths.filter((path) => {
    if (path.startsWith(BANG$1)) {
      this._ignoredPaths.add(path.slice(1));
      return false;
    }

    // if a path is being added that was previously ignored, stop ignoring it
    this._ignoredPaths.delete(path);
    this._ignoredPaths.delete(path + SLASH_GLOBSTAR);

    // reset the cached userIgnored anymatch fn
    // to make ignoredPaths changes effective
    this._userIgnored = undefined;

    return true;
  });

  if (this.options.useFsEvents && this._fsEventsHandler) {
    if (!this._readyCount) this._readyCount = paths.length;
    if (this.options.persistent) this._readyCount *= 2;
    paths.forEach((path) => this._fsEventsHandler._addToFsEvents(path));
  } else {
    if (!this._readyCount) this._readyCount = 0;
    this._readyCount += paths.length;
    Promise.all(
      paths.map(async path => {
        const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, 0, 0, _origAdd);
        if (res) this._emitReady();
        return res;
      })
    ).then(results => {
      if (this.closed) return;
      results.filter(item => item).forEach(item => {
        this.add(sysPath__default['default'].dirname(item), sysPath__default['default'].basename(_origAdd || item));
      });
    });
  }

  return this;
}

/**
 * Close watchers or start ignoring events from specified paths.
 * @param {Path|Array<Path>} paths_ - string or array of strings, file/directory paths and/or globs
 * @returns {FSWatcher} for chaining
*/
unwatch(paths_) {
  if (this.closed) return this;
  const paths = unifyPaths(paths_);
  const {cwd} = this.options;

  paths.forEach((path) => {
    // convert to absolute path unless relative path already matches
    if (!sysPath__default['default'].isAbsolute(path) && !this._closers.has(path)) {
      if (cwd) path = sysPath__default['default'].join(cwd, path);
      path = sysPath__default['default'].resolve(path);
    }

    this._closePath(path);

    this._ignoredPaths.add(path);
    if (this._watched.has(path)) {
      this._ignoredPaths.add(path + SLASH_GLOBSTAR);
    }

    // reset the cached userIgnored anymatch fn
    // to make ignoredPaths changes effective
    this._userIgnored = undefined;
  });

  return this;
}

/**
 * Close watchers and remove all listeners from watched paths.
 * @returns {Promise<void>}.
*/
close() {
  if (this.closed) return this._closePromise;
  this.closed = true;

  // Memory management.
  this.removeAllListeners();
  const closers = [];
  this._closers.forEach(closerList => closerList.forEach(closer => {
    const promise = closer();
    if (promise instanceof Promise) closers.push(promise);
  }));
  this._streams.forEach(stream => stream.destroy());
  this._userIgnored = undefined;
  this._readyCount = 0;
  this._readyEmitted = false;
  this._watched.forEach(dirent => dirent.dispose());
  ['closers', 'watched', 'streams', 'symlinkPaths', 'throttled'].forEach(key => {
    this[`_${key}`].clear();
  });

  this._closePromise = closers.length ? Promise.all(closers).then(() => undefined) : Promise.resolve();
  return this._closePromise;
}

/**
 * Expose list of watched paths
 * @returns {Object} for chaining
*/
getWatched() {
  const watchList = {};
  this._watched.forEach((entry, dir) => {
    const key = this.options.cwd ? sysPath__default['default'].relative(this.options.cwd, dir) : dir;
    watchList[key || ONE_DOT] = entry.getChildren().sort();
  });
  return watchList;
}

emitWithAll(event, args) {
  this.emit(...args);
  if (event !== EV_ERROR$2) this.emit(EV_ALL, ...args);
}

// Common helpers
// --------------

/**
 * Normalize and emit events.
 * Calling _emit DOES NOT MEAN emit() would be called!
 * @param {EventName} event Type of event
 * @param {Path} path File or directory path
 * @param {*=} val1 arguments to be passed with event
 * @param {*=} val2
 * @param {*=} val3
 * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
 */
async _emit(event, path, val1, val2, val3) {
  if (this.closed) return;

  const opts = this.options;
  if (isWindows$1) path = sysPath__default['default'].normalize(path);
  if (opts.cwd) path = sysPath__default['default'].relative(opts.cwd, path);
  /** @type Array<any> */
  const args = [event, path];
  if (val3 !== undefined) args.push(val1, val2, val3);
  else if (val2 !== undefined) args.push(val1, val2);
  else if (val1 !== undefined) args.push(val1);

  const awf = opts.awaitWriteFinish;
  let pw;
  if (awf && (pw = this._pendingWrites.get(path))) {
    pw.lastChange = new Date();
    return this;
  }

  if (opts.atomic) {
    if (event === EV_UNLINK$1) {
      this._pendingUnlinks.set(path, args);
      setTimeout(() => {
        this._pendingUnlinks.forEach((entry, path) => {
          this.emit(...entry);
          this.emit(EV_ALL, ...entry);
          this._pendingUnlinks.delete(path);
        });
      }, typeof opts.atomic === 'number' ? opts.atomic : 100);
      return this;
    }
    if (event === EV_ADD$2 && this._pendingUnlinks.has(path)) {
      event = args[0] = EV_CHANGE$2;
      this._pendingUnlinks.delete(path);
    }
  }

  if (awf && (event === EV_ADD$2 || event === EV_CHANGE$2) && this._readyEmitted) {
    const awfEmit = (err, stats) => {
      if (err) {
        event = args[0] = EV_ERROR$2;
        args[1] = err;
        this.emitWithAll(event, args);
      } else if (stats) {
        // if stats doesn't exist the file must have been deleted
        if (args.length > 2) {
          args[2] = stats;
        } else {
          args.push(stats);
        }
        this.emitWithAll(event, args);
      }
    };

    this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);
    return this;
  }

  if (event === EV_CHANGE$2) {
    const isThrottled = !this._throttle(EV_CHANGE$2, path, 50);
    if (isThrottled) return this;
  }

  if (opts.alwaysStat && val1 === undefined &&
    (event === EV_ADD$2 || event === EV_ADD_DIR$2 || event === EV_CHANGE$2)
  ) {
    const fullPath = opts.cwd ? sysPath__default['default'].join(opts.cwd, path) : path;
    let stats;
    try {
      stats = await stat$3(fullPath);
    } catch (err) {}
    // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
    if (!stats || this.closed) return;
    args.push(stats);
  }
  this.emitWithAll(event, args);

  return this;
}

/**
 * Common handler for errors
 * @param {Error} error
 * @returns {Error|Boolean} The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
 */
_handleError(error) {
  const code = error && error.code;
  if (error && code !== 'ENOENT' && code !== 'ENOTDIR' &&
    (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))
  ) {
    this.emit(EV_ERROR$2, error);
  }
  return error || this.closed;
}

/**
 * Helper utility for throttling
 * @param {ThrottleType} actionType type being throttled
 * @param {Path} path being acted upon
 * @param {Number} timeout duration of time to suppress duplicate actions
 * @returns {Object|false} tracking object or false if action should be suppressed
 */
_throttle(actionType, path, timeout) {
  if (!this._throttled.has(actionType)) {
    this._throttled.set(actionType, new Map());
  }

  /** @type {Map<Path, Object>} */
  const action = this._throttled.get(actionType);
  /** @type {Object} */
  const actionPath = action.get(path);

  if (actionPath) {
    actionPath.count++;
    return false;
  }

  let timeoutObject;
  const clear = () => {
    const item = action.get(path);
    const count = item ? item.count : 0;
    action.delete(path);
    clearTimeout(timeoutObject);
    if (item) clearTimeout(item.timeoutObject);
    return count;
  };
  timeoutObject = setTimeout(clear, timeout);
  const thr = {timeoutObject, clear, count: 0};
  action.set(path, thr);
  return thr;
}

_incrReadyCount() {
  return this._readyCount++;
}

/**
 * Awaits write operation to finish.
 * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
 * @param {Path} path being acted upon
 * @param {Number} threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
 * @param {EventName} event
 * @param {Function} awfEmit Callback to be called when ready for event to be emitted.
 */
_awaitWriteFinish(path, threshold, event, awfEmit) {
  let timeoutHandler;

  let fullPath = path;
  if (this.options.cwd && !sysPath__default['default'].isAbsolute(path)) {
    fullPath = sysPath__default['default'].join(this.options.cwd, path);
  }

  const now = new Date();

  const awaitWriteFinish = (prevStat) => {
    fs$2.stat(fullPath, (err, curStat) => {
      if (err || !this._pendingWrites.has(path)) {
        if (err && err.code !== 'ENOENT') awfEmit(err);
        return;
      }

      const now = Number(new Date());

      if (prevStat && curStat.size !== prevStat.size) {
        this._pendingWrites.get(path).lastChange = now;
      }
      const pw = this._pendingWrites.get(path);
      const df = now - pw.lastChange;

      if (df >= threshold) {
        this._pendingWrites.delete(path);
        awfEmit(undefined, curStat);
      } else {
        timeoutHandler = setTimeout(
          awaitWriteFinish,
          this.options.awaitWriteFinish.pollInterval,
          curStat
        );
      }
    });
  };

  if (!this._pendingWrites.has(path)) {
    this._pendingWrites.set(path, {
      lastChange: now,
      cancelWait: () => {
        this._pendingWrites.delete(path);
        clearTimeout(timeoutHandler);
        return event;
      }
    });
    timeoutHandler = setTimeout(
      awaitWriteFinish,
      this.options.awaitWriteFinish.pollInterval
    );
  }
}

_getGlobIgnored() {
  return [...this._ignoredPaths.values()];
}

/**
 * Determines whether user has asked to ignore this path.
 * @param {Path} path filepath or dir
 * @param {fs.Stats=} stats result of fs.stat
 * @returns {Boolean}
 */
_isIgnored(path, stats) {
  if (this.options.atomic && DOT_RE.test(path)) return true;
  if (!this._userIgnored) {
    const {cwd} = this.options;
    const ign = this.options.ignored;

    const ignored = ign && ign.map(normalizeIgnored(cwd));
    const paths = arrify(ignored)
      .filter((path) => typeof path === STRING_TYPE && !isGlob(path))
      .map((path) => path + SLASH_GLOBSTAR);
    const list = this._getGlobIgnored().map(normalizeIgnored(cwd)).concat(ignored, paths);
    this._userIgnored = anymatch(list, undefined, ANYMATCH_OPTS);
  }

  return this._userIgnored([path, stats]);
}

_isntIgnored(path, stat) {
  return !this._isIgnored(path, stat);
}

/**
 * Provides a set of common helpers and properties relating to symlink and glob handling.
 * @param {Path} path file, directory, or glob pattern being watched
 * @param {Number=} depth at any depth > 0, this isn't a glob
 * @returns {WatchHelper} object containing helpers for this path
 */
_getWatchHelpers(path, depth) {
  const watchPath = depth || this.options.disableGlobbing || !isGlob(path) ? path : globParent(path);
  const follow = this.options.followSymlinks;

  return new WatchHelper(path, watchPath, follow, this);
}

// Directory helpers
// -----------------

/**
 * Provides directory tracking objects
 * @param {String} directory path of the directory
 * @returns {DirEntry} the directory's tracking object
 */
_getWatchedDir(directory) {
  if (!this._boundRemove) this._boundRemove = this._remove.bind(this);
  const dir = sysPath__default['default'].resolve(directory);
  if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
  return this._watched.get(dir);
}

// File helpers
// ------------

/**
 * Check for read permissions.
 * Based on this answer on SO: https://stackoverflow.com/a/11781404/1358405
 * @param {fs.Stats} stats - object, result of fs_stat
 * @returns {Boolean} indicates whether the file can be read
*/
_hasReadPermissions(stats) {
  if (this.options.ignorePermissionErrors) return true;

  // stats.mode may be bigint
  const md = stats && Number.parseInt(stats.mode, 10);
  const st = md & 0o777;
  const it = Number.parseInt(st.toString(8)[0], 10);
  return Boolean(4 & it);
}

/**
 * Handles emitting unlink events for
 * files and directories, and via recursion, for
 * files and directories within directories that are unlinked
 * @param {String} directory within which the following item is located
 * @param {String} item      base path of item/directory
 * @returns {void}
*/
_remove(directory, item, isDirectory) {
  // if what is being deleted is a directory, get that directory's paths
  // for recursive deleting and cleaning of watched object
  // if it is not a directory, nestedDirectoryChildren will be empty array
  const path = sysPath__default['default'].join(directory, item);
  const fullPath = sysPath__default['default'].resolve(path);
  isDirectory = isDirectory != null
    ? isDirectory
    : this._watched.has(path) || this._watched.has(fullPath);

  // prevent duplicate handling in case of arriving here nearly simultaneously
  // via multiple paths (such as _handleFile and _handleDir)
  if (!this._throttle('remove', path, 100)) return;

  // if the only watched file is removed, watch for its return
  if (!isDirectory && !this.options.useFsEvents && this._watched.size === 1) {
    this.add(directory, item, true);
  }

  // This will create a new entry in the watched object in either case
  // so we got to do the directory check beforehand
  const wp = this._getWatchedDir(path);
  const nestedDirectoryChildren = wp.getChildren();

  // Recursively remove children directories / files.
  nestedDirectoryChildren.forEach(nested => this._remove(path, nested));

  // Check if item was on the watched list and remove it
  const parent = this._getWatchedDir(directory);
  const wasTracked = parent.has(item);
  parent.remove(item);

  // Fixes issue #1042 -> Relative paths were detected and added as symlinks
  // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612),
  // but never removed from the map in case the path was deleted.
  // This leads to an incorrect state if the path was recreated:
  // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553
  if (this._symlinkPaths.has(fullPath)) {
    this._symlinkPaths.delete(fullPath);
  }

  // If we wait for this file to be fully written, cancel the wait.
  let relPath = path;
  if (this.options.cwd) relPath = sysPath__default['default'].relative(this.options.cwd, path);
  if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
    const event = this._pendingWrites.get(relPath).cancelWait();
    if (event === EV_ADD$2) return;
  }

  // The Entry will either be a directory that just got removed
  // or a bogus entry to a file, in either case we have to remove it
  this._watched.delete(path);
  this._watched.delete(fullPath);
  const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK$1;
  if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);

  // Avoid conflicts if we later create another file with the same name
  if (!this.options.useFsEvents) {
    this._closePath(path);
  }
}

/**
 * Closes all watchers for a path
 * @param {Path} path
 */
_closePath(path) {
  this._closeFile(path);
  const dir = sysPath__default['default'].dirname(path);
  this._getWatchedDir(dir).remove(sysPath__default['default'].basename(path));
}

/**
 * Closes only file-specific watchers
 * @param {Path} path
 */
_closeFile(path) {
  const closers = this._closers.get(path);
  if (!closers) return;
  closers.forEach(closer => closer());
  this._closers.delete(path);
}

/**
 *
 * @param {Path} path
 * @param {Function} closer
 */
_addPathCloser(path, closer) {
  if (!closer) return;
  let list = this._closers.get(path);
  if (!list) {
    list = [];
    this._closers.set(path, list);
  }
  list.push(closer);
}

_readdirp(root, opts) {
  if (this.closed) return;
  const options = {type: EV_ALL, alwaysStat: true, lstat: true, ...opts};
  let stream = readdirp_1(root, options);
  this._streams.add(stream);
  stream.once(STR_CLOSE, () => {
    stream = undefined;
  });
  stream.once(STR_END$2, () => {
    if (stream) {
      this._streams.delete(stream);
      stream = undefined;
    }
  });
  return stream;
}

}

/**
 * Instantiates watcher with paths to be tracked.
 * @param {String|Array<String>} paths file/directory paths and/or globs
 * @param {Object=} options chokidar opts
 * @returns an instance of FSWatcher for chaining.
 */
const watch = (paths, options) => {
  const watcher = new FSWatcher(options);
  watcher.add(paths);
  return watcher;
};

var watch_1 = watch;

var utils$2 = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
exports.extend = extend;
exports.indexOf = indexOf;
exports.escapeExpression = escapeExpression;
exports.isEmpty = isEmpty;
exports.createFrame = createFrame;
exports.blockParams = blockParams;
exports.appendContextPath = appendContextPath;
var escape = {
  '&': '&amp;',
  '<': '&lt;',
  '>': '&gt;',
  '"': '&quot;',
  "'": '&#x27;',
  '`': '&#x60;',
  '=': '&#x3D;'
};

var badChars = /[&<>"'`=]/g,
    possible = /[&<>"'`=]/;

function escapeChar(chr) {
  return escape[chr];
}

function extend(obj /* , ...source */) {
  for (var i = 1; i < arguments.length; i++) {
    for (var key in arguments[i]) {
      if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
        obj[key] = arguments[i][key];
      }
    }
  }

  return obj;
}

var toString = Object.prototype.toString;

exports.toString = toString;
// Sourced from lodash
// https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
/* eslint-disable func-style */
var isFunction = function isFunction(value) {
  return typeof value === 'function';
};
// fallback for older versions of Chrome and Safari
/* istanbul ignore next */
if (isFunction(/x/)) {
  exports.isFunction = isFunction = function (value) {
    return typeof value === 'function' && toString.call(value) === '[object Function]';
  };
}
exports.isFunction = isFunction;

/* eslint-enable func-style */

/* istanbul ignore next */
var isArray = Array.isArray || function (value) {
  return value && typeof value === 'object' ? toString.call(value) === '[object Array]' : false;
};

exports.isArray = isArray;
// Older IE versions do not directly support indexOf so we must implement our own, sadly.

function indexOf(array, value) {
  for (var i = 0, len = array.length; i < len; i++) {
    if (array[i] === value) {
      return i;
    }
  }
  return -1;
}

function escapeExpression(string) {
  if (typeof string !== 'string') {
    // don't escape SafeStrings, since they're already safe
    if (string && string.toHTML) {
      return string.toHTML();
    } else if (string == null) {
      return '';
    } else if (!string) {
      return string + '';
    }

    // Force a string conversion as this will be done by the append regardless and
    // the regex test will do this transparently behind the scenes, causing issues if
    // an object's to string has escaped characters in it.
    string = '' + string;
  }

  if (!possible.test(string)) {
    return string;
  }
  return string.replace(badChars, escapeChar);
}

function isEmpty(value) {
  if (!value && value !== 0) {
    return true;
  } else if (isArray(value) && value.length === 0) {
    return true;
  } else {
    return false;
  }
}

function createFrame(object) {
  var frame = extend({}, object);
  frame._parent = object;
  return frame;
}

function blockParams(params, ids) {
  params.path = ids;
  return params;
}

function appendContextPath(contextPath, id) {
  return (contextPath ? contextPath + '.' : '') + id;
}

});

var exception = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
var errorProps = ['description', 'fileName', 'lineNumber', 'endLineNumber', 'message', 'name', 'number', 'stack'];

function Exception(message, node) {
  var loc = node && node.loc,
      line = undefined,
      endLineNumber = undefined,
      column = undefined,
      endColumn = undefined;

  if (loc) {
    line = loc.start.line;
    endLineNumber = loc.end.line;
    column = loc.start.column;
    endColumn = loc.end.column;

    message += ' - ' + line + ':' + column;
  }

  var tmp = Error.prototype.constructor.call(this, message);

  // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
  for (var idx = 0; idx < errorProps.length; idx++) {
    this[errorProps[idx]] = tmp[errorProps[idx]];
  }

  /* istanbul ignore else */
  if (Error.captureStackTrace) {
    Error.captureStackTrace(this, Exception);
  }

  try {
    if (loc) {
      this.lineNumber = line;
      this.endLineNumber = endLineNumber;

      // Work around issue under safari where we can't directly set the column value
      /* istanbul ignore next */
      if (Object.defineProperty) {
        Object.defineProperty(this, 'column', {
          value: column,
          enumerable: true
        });
        Object.defineProperty(this, 'endColumn', {
          value: endColumn,
          enumerable: true
        });
      } else {
        this.column = column;
        this.endColumn = endColumn;
      }
    }
  } catch (nop) {
    /* Ignore if the browser is very particular */
  }
}

Exception.prototype = new Error();

exports['default'] = Exception;
module.exports = exports['default'];

});

var blockHelperMissing = createCommonjsModule(function (module, exports) {

exports.__esModule = true;



exports['default'] = function (instance) {
  instance.registerHelper('blockHelperMissing', function (context, options) {
    var inverse = options.inverse,
        fn = options.fn;

    if (context === true) {
      return fn(this);
    } else if (context === false || context == null) {
      return inverse(this);
    } else if (utils$2.isArray(context)) {
      if (context.length > 0) {
        if (options.ids) {
          options.ids = [options.name];
        }

        return instance.helpers.each(context, options);
      } else {
        return inverse(this);
      }
    } else {
      if (options.data && options.ids) {
        var data = utils$2.createFrame(options.data);
        data.contextPath = utils$2.appendContextPath(options.data.contextPath, options.name);
        options = { data: data };
      }

      return fn(context, options);
    }
  });
};

module.exports = exports['default'];

});

var each = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }





var _exception2 = _interopRequireDefault(exception);

exports['default'] = function (instance) {
  instance.registerHelper('each', function (context, options) {
    if (!options) {
      throw new _exception2['default']('Must pass iterator to #each');
    }

    var fn = options.fn,
        inverse = options.inverse,
        i = 0,
        ret = '',
        data = undefined,
        contextPath = undefined;

    if (options.data && options.ids) {
      contextPath = utils$2.appendContextPath(options.data.contextPath, options.ids[0]) + '.';
    }

    if (utils$2.isFunction(context)) {
      context = context.call(this);
    }

    if (options.data) {
      data = utils$2.createFrame(options.data);
    }

    function execIteration(field, index, last) {
      if (data) {
        data.key = field;
        data.index = index;
        data.first = index === 0;
        data.last = !!last;

        if (contextPath) {
          data.contextPath = contextPath + field;
        }
      }

      ret = ret + fn(context[field], {
        data: data,
        blockParams: utils$2.blockParams([context[field], field], [contextPath + field, null])
      });
    }

    if (context && typeof context === 'object') {
      if (utils$2.isArray(context)) {
        for (var j = context.length; i < j; i++) {
          if (i in context) {
            execIteration(i, i, i === context.length - 1);
          }
        }
      } else if (commonjsGlobal.Symbol && context[commonjsGlobal.Symbol.iterator]) {
        var newContext = [];
        var iterator = context[commonjsGlobal.Symbol.iterator]();
        for (var it = iterator.next(); !it.done; it = iterator.next()) {
          newContext.push(it.value);
        }
        context = newContext;
        for (var j = context.length; i < j; i++) {
          execIteration(i, i, i === context.length - 1);
        }
      } else {
        (function () {
          var priorKey = undefined;

          Object.keys(context).forEach(function (key) {
            // We're running the iterations one step out of sync so we can detect
            // the last iteration without have to scan the object twice and create
            // an itermediate keys array.
            if (priorKey !== undefined) {
              execIteration(priorKey, i - 1);
            }
            priorKey = key;
            i++;
          });
          if (priorKey !== undefined) {
            execIteration(priorKey, i - 1, true);
          }
        })();
      }
    }

    if (i === 0) {
      ret = inverse(this);
    }

    return ret;
  });
};

module.exports = exports['default'];

});

var helperMissing = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }



var _exception2 = _interopRequireDefault(exception);

exports['default'] = function (instance) {
  instance.registerHelper('helperMissing', function () /* [args, ]options */{
    if (arguments.length === 1) {
      // A missing field in a {{foo}} construct.
      return undefined;
    } else {
      // Someone is actually trying to call something, blow up.
      throw new _exception2['default']('Missing helper: "' + arguments[arguments.length - 1].name + '"');
    }
  });
};

module.exports = exports['default'];

});

var _if = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }





var _exception2 = _interopRequireDefault(exception);

exports['default'] = function (instance) {
  instance.registerHelper('if', function (conditional, options) {
    if (arguments.length != 2) {
      throw new _exception2['default']('#if requires exactly one argument');
    }
    if (utils$2.isFunction(conditional)) {
      conditional = conditional.call(this);
    }

    // Default behavior is to render the positive path if the value is truthy and not empty.
    // The `includeZero` option may be set to treat the condtional as purely not empty based on the
    // behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.
    if (!options.hash.includeZero && !conditional || utils$2.isEmpty(conditional)) {
      return options.inverse(this);
    } else {
      return options.fn(this);
    }
  });

  instance.registerHelper('unless', function (conditional, options) {
    if (arguments.length != 2) {
      throw new _exception2['default']('#unless requires exactly one argument');
    }
    return instance.helpers['if'].call(this, conditional, {
      fn: options.inverse,
      inverse: options.fn,
      hash: options.hash
    });
  });
};

module.exports = exports['default'];

});

var log = createCommonjsModule(function (module, exports) {

exports.__esModule = true;

exports['default'] = function (instance) {
  instance.registerHelper('log', function () /* message, options */{
    var args = [undefined],
        options = arguments[arguments.length - 1];
    for (var i = 0; i < arguments.length - 1; i++) {
      args.push(arguments[i]);
    }

    var level = 1;
    if (options.hash.level != null) {
      level = options.hash.level;
    } else if (options.data && options.data.level != null) {
      level = options.data.level;
    }
    args[0] = level;

    instance.log.apply(instance, args);
  });
};

module.exports = exports['default'];

});

var lookup = createCommonjsModule(function (module, exports) {

exports.__esModule = true;

exports['default'] = function (instance) {
  instance.registerHelper('lookup', function (obj, field, options) {
    if (!obj) {
      // Note for 5.0: Change to "obj == null" in 5.0
      return obj;
    }
    return options.lookupProperty(obj, field);
  });
};

module.exports = exports['default'];

});

var _with = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }





var _exception2 = _interopRequireDefault(exception);

exports['default'] = function (instance) {
  instance.registerHelper('with', function (context, options) {
    if (arguments.length != 2) {
      throw new _exception2['default']('#with requires exactly one argument');
    }
    if (utils$2.isFunction(context)) {
      context = context.call(this);
    }

    var fn = options.fn;

    if (!utils$2.isEmpty(context)) {
      var data = options.data;
      if (options.data && options.ids) {
        data = utils$2.createFrame(options.data);
        data.contextPath = utils$2.appendContextPath(options.data.contextPath, options.ids[0]);
      }

      return fn(context, {
        data: data,
        blockParams: utils$2.blockParams([context], [data && data.contextPath])
      });
    } else {
      return options.inverse(this);
    }
  });
};

module.exports = exports['default'];

});

var helpers = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
exports.registerDefaultHelpers = registerDefaultHelpers;
exports.moveHelperToHooks = moveHelperToHooks;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }



var _helpersBlockHelperMissing2 = _interopRequireDefault(blockHelperMissing);



var _helpersEach2 = _interopRequireDefault(each);



var _helpersHelperMissing2 = _interopRequireDefault(helperMissing);



var _helpersIf2 = _interopRequireDefault(_if);



var _helpersLog2 = _interopRequireDefault(log);



var _helpersLookup2 = _interopRequireDefault(lookup);



var _helpersWith2 = _interopRequireDefault(_with);

function registerDefaultHelpers(instance) {
  _helpersBlockHelperMissing2['default'](instance);
  _helpersEach2['default'](instance);
  _helpersHelperMissing2['default'](instance);
  _helpersIf2['default'](instance);
  _helpersLog2['default'](instance);
  _helpersLookup2['default'](instance);
  _helpersWith2['default'](instance);
}

function moveHelperToHooks(instance, helperName, keepHelper) {
  if (instance.helpers[helperName]) {
    instance.hooks[helperName] = instance.helpers[helperName];
    if (!keepHelper) {
      delete instance.helpers[helperName];
    }
  }
}

});

var inline = createCommonjsModule(function (module, exports) {

exports.__esModule = true;



exports['default'] = function (instance) {
  instance.registerDecorator('inline', function (fn, props, container, options) {
    var ret = fn;
    if (!props.partials) {
      props.partials = {};
      ret = function (context, options) {
        // Create a new partials stack frame prior to exec.
        var original = container.partials;
        container.partials = utils$2.extend({}, original, props.partials);
        var ret = fn(context, options);
        container.partials = original;
        return ret;
      };
    }

    props.partials[options.args[0]] = options.fn;

    return ret;
  });
};

module.exports = exports['default'];

});

var decorators = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
exports.registerDefaultDecorators = registerDefaultDecorators;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }



var _decoratorsInline2 = _interopRequireDefault(inline);

function registerDefaultDecorators(instance) {
  _decoratorsInline2['default'](instance);
}

});

var logger_1 = createCommonjsModule(function (module, exports) {

exports.__esModule = true;



var logger = {
  methodMap: ['debug', 'info', 'warn', 'error'],
  level: 'info',

  // Maps a given level value to the `methodMap` indexes above.
  lookupLevel: function lookupLevel(level) {
    if (typeof level === 'string') {
      var levelMap = utils$2.indexOf(logger.methodMap, level.toLowerCase());
      if (levelMap >= 0) {
        level = levelMap;
      } else {
        level = parseInt(level, 10);
      }
    }

    return level;
  },

  // Can be overridden in the host environment
  log: function log(level) {
    level = logger.lookupLevel(level);

    if (typeof console !== 'undefined' && logger.lookupLevel(logger.level) <= level) {
      var method = logger.methodMap[level];
      // eslint-disable-next-line no-console
      if (!console[method]) {
        method = 'log';
      }

      for (var _len = arguments.length, message = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        message[_key - 1] = arguments[_key];
      }

      console[method].apply(console, message); // eslint-disable-line no-console
    }
  }
};

exports['default'] = logger;
module.exports = exports['default'];

});

var createNewLookupObject_1 = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
exports.createNewLookupObject = createNewLookupObject;



/**
 * Create a new object with "null"-prototype to avoid truthy results on prototype properties.
 * The resulting object can be used with "object[property]" to check if a property exists
 * @param {...object} sources a varargs parameter of source objects that will be merged
 * @returns {object}
 */

function createNewLookupObject() {
  for (var _len = arguments.length, sources = Array(_len), _key = 0; _key < _len; _key++) {
    sources[_key] = arguments[_key];
  }

  return utils$2.extend.apply(undefined, [Object.create(null)].concat(sources));
}

});

var protoAccess = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
exports.createProtoAccessControl = createProtoAccessControl;
exports.resultIsAllowed = resultIsAllowed;
exports.resetLoggedProperties = resetLoggedProperties;
// istanbul ignore next

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }





var logger = _interopRequireWildcard(logger_1);

var loggedProperties = Object.create(null);

function createProtoAccessControl(runtimeOptions) {
  var defaultMethodWhiteList = Object.create(null);
  defaultMethodWhiteList['constructor'] = false;
  defaultMethodWhiteList['__defineGetter__'] = false;
  defaultMethodWhiteList['__defineSetter__'] = false;
  defaultMethodWhiteList['__lookupGetter__'] = false;

  var defaultPropertyWhiteList = Object.create(null);
  // eslint-disable-next-line no-proto
  defaultPropertyWhiteList['__proto__'] = false;

  return {
    properties: {
      whitelist: createNewLookupObject_1.createNewLookupObject(defaultPropertyWhiteList, runtimeOptions.allowedProtoProperties),
      defaultValue: runtimeOptions.allowProtoPropertiesByDefault
    },
    methods: {
      whitelist: createNewLookupObject_1.createNewLookupObject(defaultMethodWhiteList, runtimeOptions.allowedProtoMethods),
      defaultValue: runtimeOptions.allowProtoMethodsByDefault
    }
  };
}

function resultIsAllowed(result, protoAccessControl, propertyName) {
  if (typeof result === 'function') {
    return checkWhiteList(protoAccessControl.methods, propertyName);
  } else {
    return checkWhiteList(protoAccessControl.properties, propertyName);
  }
}

function checkWhiteList(protoAccessControlForType, propertyName) {
  if (protoAccessControlForType.whitelist[propertyName] !== undefined) {
    return protoAccessControlForType.whitelist[propertyName] === true;
  }
  if (protoAccessControlForType.defaultValue !== undefined) {
    return protoAccessControlForType.defaultValue;
  }
  logUnexpecedPropertyAccessOnce(propertyName);
  return false;
}

function logUnexpecedPropertyAccessOnce(propertyName) {
  if (loggedProperties[propertyName] !== true) {
    loggedProperties[propertyName] = true;
    logger.log('error', 'Handlebars: Access has been denied to resolve the property "' + propertyName + '" because it is not an "own property" of its parent.\n' + 'You can add a runtime option to disable the check or this warning:\n' + 'See https://handlebarsjs.com/api-reference/runtime-options.html#options-to-control-prototype-access for details');
  }
}

function resetLoggedProperties() {
  Object.keys(loggedProperties).forEach(function (propertyName) {
    delete loggedProperties[propertyName];
  });
}

});

var base = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
exports.HandlebarsEnvironment = HandlebarsEnvironment;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }





var _exception2 = _interopRequireDefault(exception);







var _logger2 = _interopRequireDefault(logger_1);



var VERSION = '4.7.6';
exports.VERSION = VERSION;
var COMPILER_REVISION = 8;
exports.COMPILER_REVISION = COMPILER_REVISION;
var LAST_COMPATIBLE_COMPILER_REVISION = 7;

exports.LAST_COMPATIBLE_COMPILER_REVISION = LAST_COMPATIBLE_COMPILER_REVISION;
var REVISION_CHANGES = {
  1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
  2: '== 1.0.0-rc.3',
  3: '== 1.0.0-rc.4',
  4: '== 1.x.x',
  5: '== 2.0.0-alpha.x',
  6: '>= 2.0.0-beta.1',
  7: '>= 4.0.0 <4.3.0',
  8: '>= 4.3.0'
};

exports.REVISION_CHANGES = REVISION_CHANGES;
var objectType = '[object Object]';

function HandlebarsEnvironment(helpers$1, partials, decorators$1) {
  this.helpers = helpers$1 || {};
  this.partials = partials || {};
  this.decorators = decorators$1 || {};

  helpers.registerDefaultHelpers(this);
  decorators.registerDefaultDecorators(this);
}

HandlebarsEnvironment.prototype = {
  constructor: HandlebarsEnvironment,

  logger: _logger2['default'],
  log: _logger2['default'].log,

  registerHelper: function registerHelper(name, fn) {
    if (utils$2.toString.call(name) === objectType) {
      if (fn) {
        throw new _exception2['default']('Arg not supported with multiple helpers');
      }
      utils$2.extend(this.helpers, name);
    } else {
      this.helpers[name] = fn;
    }
  },
  unregisterHelper: function unregisterHelper(name) {
    delete this.helpers[name];
  },

  registerPartial: function registerPartial(name, partial) {
    if (utils$2.toString.call(name) === objectType) {
      utils$2.extend(this.partials, name);
    } else {
      if (typeof partial === 'undefined') {
        throw new _exception2['default']('Attempting to register a partial called "' + name + '" as undefined');
      }
      this.partials[name] = partial;
    }
  },
  unregisterPartial: function unregisterPartial(name) {
    delete this.partials[name];
  },

  registerDecorator: function registerDecorator(name, fn) {
    if (utils$2.toString.call(name) === objectType) {
      if (fn) {
        throw new _exception2['default']('Arg not supported with multiple decorators');
      }
      utils$2.extend(this.decorators, name);
    } else {
      this.decorators[name] = fn;
    }
  },
  unregisterDecorator: function unregisterDecorator(name) {
    delete this.decorators[name];
  },
  /**
   * Reset the memory of illegal property accesses that have already been logged.
   * @deprecated should only be used in handlebars test-cases
   */
  resetLoggedPropertyAccesses: function resetLoggedPropertyAccesses() {
    protoAccess.resetLoggedProperties();
  }
};

var log = _logger2['default'].log;

exports.log = log;
exports.createFrame = utils$2.createFrame;
exports.logger = _logger2['default'];

});

var safeString = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
function SafeString(string) {
  this.string = string;
}

SafeString.prototype.toString = SafeString.prototype.toHTML = function () {
  return '' + this.string;
};

exports['default'] = SafeString;
module.exports = exports['default'];

});

var wrapHelper_1 = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
exports.wrapHelper = wrapHelper;

function wrapHelper(helper, transformOptionsFn) {
  if (typeof helper !== 'function') {
    // This should not happen, but apparently it does in https://github.com/wycats/handlebars.js/issues/1639
    // We try to make the wrapper least-invasive by not wrapping it, if the helper is not a function.
    return helper;
  }
  var wrapper = function wrapper() /* dynamic arguments */{
    var options = arguments[arguments.length - 1];
    arguments[arguments.length - 1] = transformOptionsFn(options);
    return helper.apply(this, arguments);
  };
  return wrapper;
}

});

var runtime = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
exports.checkRevision = checkRevision;
exports.template = template;
exports.wrapProgram = wrapProgram;
exports.resolvePartial = resolvePartial;
exports.invokePartial = invokePartial;
exports.noop = noop;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

// istanbul ignore next

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }



var Utils = _interopRequireWildcard(utils$2);



var _exception2 = _interopRequireDefault(exception);









function checkRevision(compilerInfo) {
  var compilerRevision = compilerInfo && compilerInfo[0] || 1,
      currentRevision = base.COMPILER_REVISION;

  if (compilerRevision >= base.LAST_COMPATIBLE_COMPILER_REVISION && compilerRevision <= base.COMPILER_REVISION) {
    return;
  }

  if (compilerRevision < base.LAST_COMPATIBLE_COMPILER_REVISION) {
    var runtimeVersions = base.REVISION_CHANGES[currentRevision],
        compilerVersions = base.REVISION_CHANGES[compilerRevision];
    throw new _exception2['default']('Template was precompiled with an older version of Handlebars than the current runtime. ' + 'Please update your precompiler to a newer version (' + runtimeVersions + ') or downgrade your runtime to an older version (' + compilerVersions + ').');
  } else {
    // Use the embedded version info since the runtime doesn't know about this revision yet
    throw new _exception2['default']('Template was precompiled with a newer version of Handlebars than the current runtime. ' + 'Please update your runtime to a newer version (' + compilerInfo[1] + ').');
  }
}

function template(templateSpec, env) {
  /* istanbul ignore next */
  if (!env) {
    throw new _exception2['default']('No environment passed to template');
  }
  if (!templateSpec || !templateSpec.main) {
    throw new _exception2['default']('Unknown template object: ' + typeof templateSpec);
  }

  templateSpec.main.decorator = templateSpec.main_d;

  // Note: Using env.VM references rather than local var references throughout this section to allow
  // for external users to override these as pseudo-supported APIs.
  env.VM.checkRevision(templateSpec.compiler);

  // backwards compatibility for precompiled templates with compiler-version 7 (<4.3.0)
  var templateWasPrecompiledWithCompilerV7 = templateSpec.compiler && templateSpec.compiler[0] === 7;

  function invokePartialWrapper(partial, context, options) {
    if (options.hash) {
      context = Utils.extend({}, context, options.hash);
      if (options.ids) {
        options.ids[0] = true;
      }
    }
    partial = env.VM.resolvePartial.call(this, partial, context, options);

    var extendedOptions = Utils.extend({}, options, {
      hooks: this.hooks,
      protoAccessControl: this.protoAccessControl
    });

    var result = env.VM.invokePartial.call(this, partial, context, extendedOptions);

    if (result == null && env.compile) {
      options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);
      result = options.partials[options.name](context, extendedOptions);
    }
    if (result != null) {
      if (options.indent) {
        var lines = result.split('\n');
        for (var i = 0, l = lines.length; i < l; i++) {
          if (!lines[i] && i + 1 === l) {
            break;
          }

          lines[i] = options.indent + lines[i];
        }
        result = lines.join('\n');
      }
      return result;
    } else {
      throw new _exception2['default']('The partial ' + options.name + ' could not be compiled when running in runtime-only mode');
    }
  }

  // Just add water
  var container = {
    strict: function strict(obj, name, loc) {
      if (!obj || !(name in obj)) {
        throw new _exception2['default']('"' + name + '" not defined in ' + obj, {
          loc: loc
        });
      }
      return obj[name];
    },
    lookupProperty: function lookupProperty(parent, propertyName) {
      var result = parent[propertyName];
      if (result == null) {
        return result;
      }
      if (Object.prototype.hasOwnProperty.call(parent, propertyName)) {
        return result;
      }

      if (protoAccess.resultIsAllowed(result, container.protoAccessControl, propertyName)) {
        return result;
      }
      return undefined;
    },
    lookup: function lookup(depths, name) {
      var len = depths.length;
      for (var i = 0; i < len; i++) {
        var result = depths[i] && container.lookupProperty(depths[i], name);
        if (result != null) {
          return depths[i][name];
        }
      }
    },
    lambda: function lambda(current, context) {
      return typeof current === 'function' ? current.call(context) : current;
    },

    escapeExpression: Utils.escapeExpression,
    invokePartial: invokePartialWrapper,

    fn: function fn(i) {
      var ret = templateSpec[i];
      ret.decorator = templateSpec[i + '_d'];
      return ret;
    },

    programs: [],
    program: function program(i, data, declaredBlockParams, blockParams, depths) {
      var programWrapper = this.programs[i],
          fn = this.fn(i);
      if (data || depths || blockParams || declaredBlockParams) {
        programWrapper = wrapProgram(this, i, fn, data, declaredBlockParams, blockParams, depths);
      } else if (!programWrapper) {
        programWrapper = this.programs[i] = wrapProgram(this, i, fn);
      }
      return programWrapper;
    },

    data: function data(value, depth) {
      while (value && depth--) {
        value = value._parent;
      }
      return value;
    },
    mergeIfNeeded: function mergeIfNeeded(param, common) {
      var obj = param || common;

      if (param && common && param !== common) {
        obj = Utils.extend({}, common, param);
      }

      return obj;
    },
    // An empty object to use as replacement for null-contexts
    nullContext: Object.seal({}),

    noop: env.VM.noop,
    compilerInfo: templateSpec.compiler
  };

  function ret(context) {
    var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

    var data = options.data;

    ret._setup(options);
    if (!options.partial && templateSpec.useData) {
      data = initData(context, data);
    }
    var depths = undefined,
        blockParams = templateSpec.useBlockParams ? [] : undefined;
    if (templateSpec.useDepths) {
      if (options.depths) {
        depths = context != options.depths[0] ? [context].concat(options.depths) : options.depths;
      } else {
        depths = [context];
      }
    }

    function main(context /*, options*/) {
      return '' + templateSpec.main(container, context, container.helpers, container.partials, data, blockParams, depths);
    }

    main = executeDecorators(templateSpec.main, main, container, options.depths || [], data, blockParams);
    return main(context, options);
  }

  ret.isTop = true;

  ret._setup = function (options) {
    if (!options.partial) {
      var mergedHelpers = Utils.extend({}, env.helpers, options.helpers);
      wrapHelpersToPassLookupProperty(mergedHelpers, container);
      container.helpers = mergedHelpers;

      if (templateSpec.usePartial) {
        // Use mergeIfNeeded here to prevent compiling global partials multiple times
        container.partials = container.mergeIfNeeded(options.partials, env.partials);
      }
      if (templateSpec.usePartial || templateSpec.useDecorators) {
        container.decorators = Utils.extend({}, env.decorators, options.decorators);
      }

      container.hooks = {};
      container.protoAccessControl = protoAccess.createProtoAccessControl(options);

      var keepHelperInHelpers = options.allowCallsToHelperMissing || templateWasPrecompiledWithCompilerV7;
      helpers.moveHelperToHooks(container, 'helperMissing', keepHelperInHelpers);
      helpers.moveHelperToHooks(container, 'blockHelperMissing', keepHelperInHelpers);
    } else {
      container.protoAccessControl = options.protoAccessControl; // internal option
      container.helpers = options.helpers;
      container.partials = options.partials;
      container.decorators = options.decorators;
      container.hooks = options.hooks;
    }
  };

  ret._child = function (i, data, blockParams, depths) {
    if (templateSpec.useBlockParams && !blockParams) {
      throw new _exception2['default']('must pass block params');
    }
    if (templateSpec.useDepths && !depths) {
      throw new _exception2['default']('must pass parent depths');
    }

    return wrapProgram(container, i, templateSpec[i], data, 0, blockParams, depths);
  };
  return ret;
}

function wrapProgram(container, i, fn, data, declaredBlockParams, blockParams, depths) {
  function prog(context) {
    var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

    var currentDepths = depths;
    if (depths && context != depths[0] && !(context === container.nullContext && depths[0] === null)) {
      currentDepths = [context].concat(depths);
    }

    return fn(container, context, container.helpers, container.partials, options.data || data, blockParams && [options.blockParams].concat(blockParams), currentDepths);
  }

  prog = executeDecorators(fn, prog, container, depths, data, blockParams);

  prog.program = i;
  prog.depth = depths ? depths.length : 0;
  prog.blockParams = declaredBlockParams || 0;
  return prog;
}

/**
 * This is currently part of the official API, therefore implementation details should not be changed.
 */

function resolvePartial(partial, context, options) {
  if (!partial) {
    if (options.name === '@partial-block') {
      partial = options.data['partial-block'];
    } else {
      partial = options.partials[options.name];
    }
  } else if (!partial.call && !options.name) {
    // This is a dynamic partial that returned a string
    options.name = partial;
    partial = options.partials[partial];
  }
  return partial;
}

function invokePartial(partial, context, options) {
  // Use the current closure context to save the partial-block if this partial
  var currentPartialBlock = options.data && options.data['partial-block'];
  options.partial = true;
  if (options.ids) {
    options.data.contextPath = options.ids[0] || options.data.contextPath;
  }

  var partialBlock = undefined;
  if (options.fn && options.fn !== noop) {
    (function () {
      options.data = base.createFrame(options.data);
      // Wrapper function to get access to currentPartialBlock from the closure
      var fn = options.fn;
      partialBlock = options.data['partial-block'] = function partialBlockWrapper(context) {
        var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

        // Restore the partial-block from the closure for the execution of the block
        // i.e. the part inside the block of the partial call.
        options.data = base.createFrame(options.data);
        options.data['partial-block'] = currentPartialBlock;
        return fn(context, options);
      };
      if (fn.partials) {
        options.partials = Utils.extend({}, options.partials, fn.partials);
      }
    })();
  }

  if (partial === undefined && partialBlock) {
    partial = partialBlock;
  }

  if (partial === undefined) {
    throw new _exception2['default']('The partial ' + options.name + ' could not be found');
  } else if (partial instanceof Function) {
    return partial(context, options);
  }
}

function noop() {
  return '';
}

function initData(context, data) {
  if (!data || !('root' in data)) {
    data = data ? base.createFrame(data) : {};
    data.root = context;
  }
  return data;
}

function executeDecorators(fn, prog, container, depths, data, blockParams) {
  if (fn.decorator) {
    var props = {};
    prog = fn.decorator(prog, props, container, depths && depths[0], data, blockParams, depths);
    Utils.extend(prog, props);
  }
  return prog;
}

function wrapHelpersToPassLookupProperty(mergedHelpers, container) {
  Object.keys(mergedHelpers).forEach(function (helperName) {
    var helper = mergedHelpers[helperName];
    mergedHelpers[helperName] = passLookupPropertyOption(helper, container);
  });
}

function passLookupPropertyOption(helper, container) {
  var lookupProperty = container.lookupProperty;
  return wrapHelper_1.wrapHelper(helper, function (options) {
    return Utils.extend({ lookupProperty: lookupProperty }, options);
  });
}

});

var noConflict = createCommonjsModule(function (module, exports) {

exports.__esModule = true;

exports['default'] = function (Handlebars) {
  /* istanbul ignore next */
  var root = typeof commonjsGlobal !== 'undefined' ? commonjsGlobal : window,
      $Handlebars = root.Handlebars;
  /* istanbul ignore next */
  Handlebars.noConflict = function () {
    if (root.Handlebars === Handlebars) {
      root.Handlebars = $Handlebars;
    }
    return Handlebars;
  };
};

module.exports = exports['default'];

});

var handlebars_runtime = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

// istanbul ignore next

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }



var base$1 = _interopRequireWildcard(base);

// Each of these augment the Handlebars object. No need to setup here.
// (This is done to easily share code between commonjs and browse envs)



var _handlebarsSafeString2 = _interopRequireDefault(safeString);



var _handlebarsException2 = _interopRequireDefault(exception);



var Utils = _interopRequireWildcard(utils$2);



var runtime$1 = _interopRequireWildcard(runtime);



var _handlebarsNoConflict2 = _interopRequireDefault(noConflict);

// For compatibility and usage outside of module systems, make the Handlebars object a namespace
function create() {
  var hb = new base$1.HandlebarsEnvironment();

  Utils.extend(hb, base$1);
  hb.SafeString = _handlebarsSafeString2['default'];
  hb.Exception = _handlebarsException2['default'];
  hb.Utils = Utils;
  hb.escapeExpression = Utils.escapeExpression;

  hb.VM = runtime$1;
  hb.template = function (spec) {
    return runtime$1.template(spec, hb);
  };

  return hb;
}

var inst = create();
inst.create = create;

_handlebarsNoConflict2['default'](inst);

inst['default'] = inst;

exports['default'] = inst;
module.exports = exports['default'];

});

var ast = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
var AST = {
  // Public API used to evaluate derived attributes regarding AST nodes
  helpers: {
    // a mustache is definitely a helper if:
    // * it is an eligible helper, and
    // * it has at least one parameter or hash segment
    helperExpression: function helperExpression(node) {
      return node.type === 'SubExpression' || (node.type === 'MustacheStatement' || node.type === 'BlockStatement') && !!(node.params && node.params.length || node.hash);
    },

    scopedId: function scopedId(path) {
      return (/^\.|this\b/.test(path.original)
      );
    },

    // an ID is simple if it only has one part, and that part is not
    // `..` or `this`.
    simpleId: function simpleId(path) {
      return path.parts.length === 1 && !AST.helpers.scopedId(path) && !path.depth;
    }
  }
};

// Must be exported as an object rather than the root of the module as the jison lexer
// must modify the object to operate properly.
exports['default'] = AST;
module.exports = exports['default'];

});

var parser = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
var handlebars = (function () {
    var parser = { trace: function trace() {},
        yy: {},
        symbols_: { "error": 2, "root": 3, "program": 4, "EOF": 5, "program_repetition0": 6, "statement": 7, "mustache": 8, "block": 9, "rawBlock": 10, "partial": 11, "partialBlock": 12, "content": 13, "COMMENT": 14, "CONTENT": 15, "openRawBlock": 16, "rawBlock_repetition0": 17, "END_RAW_BLOCK": 18, "OPEN_RAW_BLOCK": 19, "helperName": 20, "openRawBlock_repetition0": 21, "openRawBlock_option0": 22, "CLOSE_RAW_BLOCK": 23, "openBlock": 24, "block_option0": 25, "closeBlock": 26, "openInverse": 27, "block_option1": 28, "OPEN_BLOCK": 29, "openBlock_repetition0": 30, "openBlock_option0": 31, "openBlock_option1": 32, "CLOSE": 33, "OPEN_INVERSE": 34, "openInverse_repetition0": 35, "openInverse_option0": 36, "openInverse_option1": 37, "openInverseChain": 38, "OPEN_INVERSE_CHAIN": 39, "openInverseChain_repetition0": 40, "openInverseChain_option0": 41, "openInverseChain_option1": 42, "inverseAndProgram": 43, "INVERSE": 44, "inverseChain": 45, "inverseChain_option0": 46, "OPEN_ENDBLOCK": 47, "OPEN": 48, "mustache_repetition0": 49, "mustache_option0": 50, "OPEN_UNESCAPED": 51, "mustache_repetition1": 52, "mustache_option1": 53, "CLOSE_UNESCAPED": 54, "OPEN_PARTIAL": 55, "partialName": 56, "partial_repetition0": 57, "partial_option0": 58, "openPartialBlock": 59, "OPEN_PARTIAL_BLOCK": 60, "openPartialBlock_repetition0": 61, "openPartialBlock_option0": 62, "param": 63, "sexpr": 64, "OPEN_SEXPR": 65, "sexpr_repetition0": 66, "sexpr_option0": 67, "CLOSE_SEXPR": 68, "hash": 69, "hash_repetition_plus0": 70, "hashSegment": 71, "ID": 72, "EQUALS": 73, "blockParams": 74, "OPEN_BLOCK_PARAMS": 75, "blockParams_repetition_plus0": 76, "CLOSE_BLOCK_PARAMS": 77, "path": 78, "dataName": 79, "STRING": 80, "NUMBER": 81, "BOOLEAN": 82, "UNDEFINED": 83, "NULL": 84, "DATA": 85, "pathSegments": 86, "SEP": 87, "$accept": 0, "$end": 1 },
        terminals_: { 2: "error", 5: "EOF", 14: "COMMENT", 15: "CONTENT", 18: "END_RAW_BLOCK", 19: "OPEN_RAW_BLOCK", 23: "CLOSE_RAW_BLOCK", 29: "OPEN_BLOCK", 33: "CLOSE", 34: "OPEN_INVERSE", 39: "OPEN_INVERSE_CHAIN", 44: "INVERSE", 47: "OPEN_ENDBLOCK", 48: "OPEN", 51: "OPEN_UNESCAPED", 54: "CLOSE_UNESCAPED", 55: "OPEN_PARTIAL", 60: "OPEN_PARTIAL_BLOCK", 65: "OPEN_SEXPR", 68: "CLOSE_SEXPR", 72: "ID", 73: "EQUALS", 75: "OPEN_BLOCK_PARAMS", 77: "CLOSE_BLOCK_PARAMS", 80: "STRING", 81: "NUMBER", 82: "BOOLEAN", 83: "UNDEFINED", 84: "NULL", 85: "DATA", 87: "SEP" },
        productions_: [0, [3, 2], [4, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [7, 1], [13, 1], [10, 3], [16, 5], [9, 4], [9, 4], [24, 6], [27, 6], [38, 6], [43, 2], [45, 3], [45, 1], [26, 3], [8, 5], [8, 5], [11, 5], [12, 3], [59, 5], [63, 1], [63, 1], [64, 5], [69, 1], [71, 3], [74, 3], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [20, 1], [56, 1], [56, 1], [79, 2], [78, 1], [86, 3], [86, 1], [6, 0], [6, 2], [17, 0], [17, 2], [21, 0], [21, 2], [22, 0], [22, 1], [25, 0], [25, 1], [28, 0], [28, 1], [30, 0], [30, 2], [31, 0], [31, 1], [32, 0], [32, 1], [35, 0], [35, 2], [36, 0], [36, 1], [37, 0], [37, 1], [40, 0], [40, 2], [41, 0], [41, 1], [42, 0], [42, 1], [46, 0], [46, 1], [49, 0], [49, 2], [50, 0], [50, 1], [52, 0], [52, 2], [53, 0], [53, 1], [57, 0], [57, 2], [58, 0], [58, 1], [61, 0], [61, 2], [62, 0], [62, 1], [66, 0], [66, 2], [67, 0], [67, 1], [70, 1], [70, 2], [76, 1], [76, 2]],
        performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {

            var $0 = $$.length - 1;
            switch (yystate) {
                case 1:
                    return $$[$0 - 1];
                case 2:
                    this.$ = yy.prepareProgram($$[$0]);
                    break;
                case 3:
                    this.$ = $$[$0];
                    break;
                case 4:
                    this.$ = $$[$0];
                    break;
                case 5:
                    this.$ = $$[$0];
                    break;
                case 6:
                    this.$ = $$[$0];
                    break;
                case 7:
                    this.$ = $$[$0];
                    break;
                case 8:
                    this.$ = $$[$0];
                    break;
                case 9:
                    this.$ = {
                        type: 'CommentStatement',
                        value: yy.stripComment($$[$0]),
                        strip: yy.stripFlags($$[$0], $$[$0]),
                        loc: yy.locInfo(this._$)
                    };

                    break;
                case 10:
                    this.$ = {
                        type: 'ContentStatement',
                        original: $$[$0],
                        value: $$[$0],
                        loc: yy.locInfo(this._$)
                    };

                    break;
                case 11:
                    this.$ = yy.prepareRawBlock($$[$0 - 2], $$[$0 - 1], $$[$0], this._$);
                    break;
                case 12:
                    this.$ = { path: $$[$0 - 3], params: $$[$0 - 2], hash: $$[$0 - 1] };
                    break;
                case 13:
                    this.$ = yy.prepareBlock($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0], false, this._$);
                    break;
                case 14:
                    this.$ = yy.prepareBlock($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0], true, this._$);
                    break;
                case 15:
                    this.$ = { open: $$[$0 - 5], path: $$[$0 - 4], params: $$[$0 - 3], hash: $$[$0 - 2], blockParams: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 5], $$[$0]) };
                    break;
                case 16:
                    this.$ = { path: $$[$0 - 4], params: $$[$0 - 3], hash: $$[$0 - 2], blockParams: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 5], $$[$0]) };
                    break;
                case 17:
                    this.$ = { path: $$[$0 - 4], params: $$[$0 - 3], hash: $$[$0 - 2], blockParams: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 5], $$[$0]) };
                    break;
                case 18:
                    this.$ = { strip: yy.stripFlags($$[$0 - 1], $$[$0 - 1]), program: $$[$0] };
                    break;
                case 19:
                    var inverse = yy.prepareBlock($$[$0 - 2], $$[$0 - 1], $$[$0], $$[$0], false, this._$),
                        program = yy.prepareProgram([inverse], $$[$0 - 1].loc);
                    program.chained = true;

                    this.$ = { strip: $$[$0 - 2].strip, program: program, chain: true };

                    break;
                case 20:
                    this.$ = $$[$0];
                    break;
                case 21:
                    this.$ = { path: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 2], $$[$0]) };
                    break;
                case 22:
                    this.$ = yy.prepareMustache($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0 - 4], yy.stripFlags($$[$0 - 4], $$[$0]), this._$);
                    break;
                case 23:
                    this.$ = yy.prepareMustache($$[$0 - 3], $$[$0 - 2], $$[$0 - 1], $$[$0 - 4], yy.stripFlags($$[$0 - 4], $$[$0]), this._$);
                    break;
                case 24:
                    this.$ = {
                        type: 'PartialStatement',
                        name: $$[$0 - 3],
                        params: $$[$0 - 2],
                        hash: $$[$0 - 1],
                        indent: '',
                        strip: yy.stripFlags($$[$0 - 4], $$[$0]),
                        loc: yy.locInfo(this._$)
                    };

                    break;
                case 25:
                    this.$ = yy.preparePartialBlock($$[$0 - 2], $$[$0 - 1], $$[$0], this._$);
                    break;
                case 26:
                    this.$ = { path: $$[$0 - 3], params: $$[$0 - 2], hash: $$[$0 - 1], strip: yy.stripFlags($$[$0 - 4], $$[$0]) };
                    break;
                case 27:
                    this.$ = $$[$0];
                    break;
                case 28:
                    this.$ = $$[$0];
                    break;
                case 29:
                    this.$ = {
                        type: 'SubExpression',
                        path: $$[$0 - 3],
                        params: $$[$0 - 2],
                        hash: $$[$0 - 1],
                        loc: yy.locInfo(this._$)
                    };

                    break;
                case 30:
                    this.$ = { type: 'Hash', pairs: $$[$0], loc: yy.locInfo(this._$) };
                    break;
                case 31:
                    this.$ = { type: 'HashPair', key: yy.id($$[$0 - 2]), value: $$[$0], loc: yy.locInfo(this._$) };
                    break;
                case 32:
                    this.$ = yy.id($$[$0 - 1]);
                    break;
                case 33:
                    this.$ = $$[$0];
                    break;
                case 34:
                    this.$ = $$[$0];
                    break;
                case 35:
                    this.$ = { type: 'StringLiteral', value: $$[$0], original: $$[$0], loc: yy.locInfo(this._$) };
                    break;
                case 36:
                    this.$ = { type: 'NumberLiteral', value: Number($$[$0]), original: Number($$[$0]), loc: yy.locInfo(this._$) };
                    break;
                case 37:
                    this.$ = { type: 'BooleanLiteral', value: $$[$0] === 'true', original: $$[$0] === 'true', loc: yy.locInfo(this._$) };
                    break;
                case 38:
                    this.$ = { type: 'UndefinedLiteral', original: undefined, value: undefined, loc: yy.locInfo(this._$) };
                    break;
                case 39:
                    this.$ = { type: 'NullLiteral', original: null, value: null, loc: yy.locInfo(this._$) };
                    break;
                case 40:
                    this.$ = $$[$0];
                    break;
                case 41:
                    this.$ = $$[$0];
                    break;
                case 42:
                    this.$ = yy.preparePath(true, $$[$0], this._$);
                    break;
                case 43:
                    this.$ = yy.preparePath(false, $$[$0], this._$);
                    break;
                case 44:
                    $$[$0 - 2].push({ part: yy.id($$[$0]), original: $$[$0], separator: $$[$0 - 1] });this.$ = $$[$0 - 2];
                    break;
                case 45:
                    this.$ = [{ part: yy.id($$[$0]), original: $$[$0] }];
                    break;
                case 46:
                    this.$ = [];
                    break;
                case 47:
                    $$[$0 - 1].push($$[$0]);
                    break;
                case 48:
                    this.$ = [];
                    break;
                case 49:
                    $$[$0 - 1].push($$[$0]);
                    break;
                case 50:
                    this.$ = [];
                    break;
                case 51:
                    $$[$0 - 1].push($$[$0]);
                    break;
                case 58:
                    this.$ = [];
                    break;
                case 59:
                    $$[$0 - 1].push($$[$0]);
                    break;
                case 64:
                    this.$ = [];
                    break;
                case 65:
                    $$[$0 - 1].push($$[$0]);
                    break;
                case 70:
                    this.$ = [];
                    break;
                case 71:
                    $$[$0 - 1].push($$[$0]);
                    break;
                case 78:
                    this.$ = [];
                    break;
                case 79:
                    $$[$0 - 1].push($$[$0]);
                    break;
                case 82:
                    this.$ = [];
                    break;
                case 83:
                    $$[$0 - 1].push($$[$0]);
                    break;
                case 86:
                    this.$ = [];
                    break;
                case 87:
                    $$[$0 - 1].push($$[$0]);
                    break;
                case 90:
                    this.$ = [];
                    break;
                case 91:
                    $$[$0 - 1].push($$[$0]);
                    break;
                case 94:
                    this.$ = [];
                    break;
                case 95:
                    $$[$0 - 1].push($$[$0]);
                    break;
                case 98:
                    this.$ = [$$[$0]];
                    break;
                case 99:
                    $$[$0 - 1].push($$[$0]);
                    break;
                case 100:
                    this.$ = [$$[$0]];
                    break;
                case 101:
                    $$[$0 - 1].push($$[$0]);
                    break;
            }
        },
        table: [{ 3: 1, 4: 2, 5: [2, 46], 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 1: [3] }, { 5: [1, 4] }, { 5: [2, 2], 7: 5, 8: 6, 9: 7, 10: 8, 11: 9, 12: 10, 13: 11, 14: [1, 12], 15: [1, 20], 16: 17, 19: [1, 23], 24: 15, 27: 16, 29: [1, 21], 34: [1, 22], 39: [2, 2], 44: [2, 2], 47: [2, 2], 48: [1, 13], 51: [1, 14], 55: [1, 18], 59: 19, 60: [1, 24] }, { 1: [2, 1] }, { 5: [2, 47], 14: [2, 47], 15: [2, 47], 19: [2, 47], 29: [2, 47], 34: [2, 47], 39: [2, 47], 44: [2, 47], 47: [2, 47], 48: [2, 47], 51: [2, 47], 55: [2, 47], 60: [2, 47] }, { 5: [2, 3], 14: [2, 3], 15: [2, 3], 19: [2, 3], 29: [2, 3], 34: [2, 3], 39: [2, 3], 44: [2, 3], 47: [2, 3], 48: [2, 3], 51: [2, 3], 55: [2, 3], 60: [2, 3] }, { 5: [2, 4], 14: [2, 4], 15: [2, 4], 19: [2, 4], 29: [2, 4], 34: [2, 4], 39: [2, 4], 44: [2, 4], 47: [2, 4], 48: [2, 4], 51: [2, 4], 55: [2, 4], 60: [2, 4] }, { 5: [2, 5], 14: [2, 5], 15: [2, 5], 19: [2, 5], 29: [2, 5], 34: [2, 5], 39: [2, 5], 44: [2, 5], 47: [2, 5], 48: [2, 5], 51: [2, 5], 55: [2, 5], 60: [2, 5] }, { 5: [2, 6], 14: [2, 6], 15: [2, 6], 19: [2, 6], 29: [2, 6], 34: [2, 6], 39: [2, 6], 44: [2, 6], 47: [2, 6], 48: [2, 6], 51: [2, 6], 55: [2, 6], 60: [2, 6] }, { 5: [2, 7], 14: [2, 7], 15: [2, 7], 19: [2, 7], 29: [2, 7], 34: [2, 7], 39: [2, 7], 44: [2, 7], 47: [2, 7], 48: [2, 7], 51: [2, 7], 55: [2, 7], 60: [2, 7] }, { 5: [2, 8], 14: [2, 8], 15: [2, 8], 19: [2, 8], 29: [2, 8], 34: [2, 8], 39: [2, 8], 44: [2, 8], 47: [2, 8], 48: [2, 8], 51: [2, 8], 55: [2, 8], 60: [2, 8] }, { 5: [2, 9], 14: [2, 9], 15: [2, 9], 19: [2, 9], 29: [2, 9], 34: [2, 9], 39: [2, 9], 44: [2, 9], 47: [2, 9], 48: [2, 9], 51: [2, 9], 55: [2, 9], 60: [2, 9] }, { 20: 25, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 36, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 4: 37, 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 39: [2, 46], 44: [2, 46], 47: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 4: 38, 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 44: [2, 46], 47: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 15: [2, 48], 17: 39, 18: [2, 48] }, { 20: 41, 56: 40, 64: 42, 65: [1, 43], 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 4: 44, 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 47: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 5: [2, 10], 14: [2, 10], 15: [2, 10], 18: [2, 10], 19: [2, 10], 29: [2, 10], 34: [2, 10], 39: [2, 10], 44: [2, 10], 47: [2, 10], 48: [2, 10], 51: [2, 10], 55: [2, 10], 60: [2, 10] }, { 20: 45, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 46, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 47, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 41, 56: 48, 64: 42, 65: [1, 43], 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 33: [2, 78], 49: 49, 65: [2, 78], 72: [2, 78], 80: [2, 78], 81: [2, 78], 82: [2, 78], 83: [2, 78], 84: [2, 78], 85: [2, 78] }, { 23: [2, 33], 33: [2, 33], 54: [2, 33], 65: [2, 33], 68: [2, 33], 72: [2, 33], 75: [2, 33], 80: [2, 33], 81: [2, 33], 82: [2, 33], 83: [2, 33], 84: [2, 33], 85: [2, 33] }, { 23: [2, 34], 33: [2, 34], 54: [2, 34], 65: [2, 34], 68: [2, 34], 72: [2, 34], 75: [2, 34], 80: [2, 34], 81: [2, 34], 82: [2, 34], 83: [2, 34], 84: [2, 34], 85: [2, 34] }, { 23: [2, 35], 33: [2, 35], 54: [2, 35], 65: [2, 35], 68: [2, 35], 72: [2, 35], 75: [2, 35], 80: [2, 35], 81: [2, 35], 82: [2, 35], 83: [2, 35], 84: [2, 35], 85: [2, 35] }, { 23: [2, 36], 33: [2, 36], 54: [2, 36], 65: [2, 36], 68: [2, 36], 72: [2, 36], 75: [2, 36], 80: [2, 36], 81: [2, 36], 82: [2, 36], 83: [2, 36], 84: [2, 36], 85: [2, 36] }, { 23: [2, 37], 33: [2, 37], 54: [2, 37], 65: [2, 37], 68: [2, 37], 72: [2, 37], 75: [2, 37], 80: [2, 37], 81: [2, 37], 82: [2, 37], 83: [2, 37], 84: [2, 37], 85: [2, 37] }, { 23: [2, 38], 33: [2, 38], 54: [2, 38], 65: [2, 38], 68: [2, 38], 72: [2, 38], 75: [2, 38], 80: [2, 38], 81: [2, 38], 82: [2, 38], 83: [2, 38], 84: [2, 38], 85: [2, 38] }, { 23: [2, 39], 33: [2, 39], 54: [2, 39], 65: [2, 39], 68: [2, 39], 72: [2, 39], 75: [2, 39], 80: [2, 39], 81: [2, 39], 82: [2, 39], 83: [2, 39], 84: [2, 39], 85: [2, 39] }, { 23: [2, 43], 33: [2, 43], 54: [2, 43], 65: [2, 43], 68: [2, 43], 72: [2, 43], 75: [2, 43], 80: [2, 43], 81: [2, 43], 82: [2, 43], 83: [2, 43], 84: [2, 43], 85: [2, 43], 87: [1, 50] }, { 72: [1, 35], 86: 51 }, { 23: [2, 45], 33: [2, 45], 54: [2, 45], 65: [2, 45], 68: [2, 45], 72: [2, 45], 75: [2, 45], 80: [2, 45], 81: [2, 45], 82: [2, 45], 83: [2, 45], 84: [2, 45], 85: [2, 45], 87: [2, 45] }, { 52: 52, 54: [2, 82], 65: [2, 82], 72: [2, 82], 80: [2, 82], 81: [2, 82], 82: [2, 82], 83: [2, 82], 84: [2, 82], 85: [2, 82] }, { 25: 53, 38: 55, 39: [1, 57], 43: 56, 44: [1, 58], 45: 54, 47: [2, 54] }, { 28: 59, 43: 60, 44: [1, 58], 47: [2, 56] }, { 13: 62, 15: [1, 20], 18: [1, 61] }, { 33: [2, 86], 57: 63, 65: [2, 86], 72: [2, 86], 80: [2, 86], 81: [2, 86], 82: [2, 86], 83: [2, 86], 84: [2, 86], 85: [2, 86] }, { 33: [2, 40], 65: [2, 40], 72: [2, 40], 80: [2, 40], 81: [2, 40], 82: [2, 40], 83: [2, 40], 84: [2, 40], 85: [2, 40] }, { 33: [2, 41], 65: [2, 41], 72: [2, 41], 80: [2, 41], 81: [2, 41], 82: [2, 41], 83: [2, 41], 84: [2, 41], 85: [2, 41] }, { 20: 64, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 26: 65, 47: [1, 66] }, { 30: 67, 33: [2, 58], 65: [2, 58], 72: [2, 58], 75: [2, 58], 80: [2, 58], 81: [2, 58], 82: [2, 58], 83: [2, 58], 84: [2, 58], 85: [2, 58] }, { 33: [2, 64], 35: 68, 65: [2, 64], 72: [2, 64], 75: [2, 64], 80: [2, 64], 81: [2, 64], 82: [2, 64], 83: [2, 64], 84: [2, 64], 85: [2, 64] }, { 21: 69, 23: [2, 50], 65: [2, 50], 72: [2, 50], 80: [2, 50], 81: [2, 50], 82: [2, 50], 83: [2, 50], 84: [2, 50], 85: [2, 50] }, { 33: [2, 90], 61: 70, 65: [2, 90], 72: [2, 90], 80: [2, 90], 81: [2, 90], 82: [2, 90], 83: [2, 90], 84: [2, 90], 85: [2, 90] }, { 20: 74, 33: [2, 80], 50: 71, 63: 72, 64: 75, 65: [1, 43], 69: 73, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 72: [1, 79] }, { 23: [2, 42], 33: [2, 42], 54: [2, 42], 65: [2, 42], 68: [2, 42], 72: [2, 42], 75: [2, 42], 80: [2, 42], 81: [2, 42], 82: [2, 42], 83: [2, 42], 84: [2, 42], 85: [2, 42], 87: [1, 50] }, { 20: 74, 53: 80, 54: [2, 84], 63: 81, 64: 75, 65: [1, 43], 69: 82, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 26: 83, 47: [1, 66] }, { 47: [2, 55] }, { 4: 84, 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 39: [2, 46], 44: [2, 46], 47: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 47: [2, 20] }, { 20: 85, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 4: 86, 6: 3, 14: [2, 46], 15: [2, 46], 19: [2, 46], 29: [2, 46], 34: [2, 46], 47: [2, 46], 48: [2, 46], 51: [2, 46], 55: [2, 46], 60: [2, 46] }, { 26: 87, 47: [1, 66] }, { 47: [2, 57] }, { 5: [2, 11], 14: [2, 11], 15: [2, 11], 19: [2, 11], 29: [2, 11], 34: [2, 11], 39: [2, 11], 44: [2, 11], 47: [2, 11], 48: [2, 11], 51: [2, 11], 55: [2, 11], 60: [2, 11] }, { 15: [2, 49], 18: [2, 49] }, { 20: 74, 33: [2, 88], 58: 88, 63: 89, 64: 75, 65: [1, 43], 69: 90, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 65: [2, 94], 66: 91, 68: [2, 94], 72: [2, 94], 80: [2, 94], 81: [2, 94], 82: [2, 94], 83: [2, 94], 84: [2, 94], 85: [2, 94] }, { 5: [2, 25], 14: [2, 25], 15: [2, 25], 19: [2, 25], 29: [2, 25], 34: [2, 25], 39: [2, 25], 44: [2, 25], 47: [2, 25], 48: [2, 25], 51: [2, 25], 55: [2, 25], 60: [2, 25] }, { 20: 92, 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 74, 31: 93, 33: [2, 60], 63: 94, 64: 75, 65: [1, 43], 69: 95, 70: 76, 71: 77, 72: [1, 78], 75: [2, 60], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 74, 33: [2, 66], 36: 96, 63: 97, 64: 75, 65: [1, 43], 69: 98, 70: 76, 71: 77, 72: [1, 78], 75: [2, 66], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 74, 22: 99, 23: [2, 52], 63: 100, 64: 75, 65: [1, 43], 69: 101, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 20: 74, 33: [2, 92], 62: 102, 63: 103, 64: 75, 65: [1, 43], 69: 104, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 33: [1, 105] }, { 33: [2, 79], 65: [2, 79], 72: [2, 79], 80: [2, 79], 81: [2, 79], 82: [2, 79], 83: [2, 79], 84: [2, 79], 85: [2, 79] }, { 33: [2, 81] }, { 23: [2, 27], 33: [2, 27], 54: [2, 27], 65: [2, 27], 68: [2, 27], 72: [2, 27], 75: [2, 27], 80: [2, 27], 81: [2, 27], 82: [2, 27], 83: [2, 27], 84: [2, 27], 85: [2, 27] }, { 23: [2, 28], 33: [2, 28], 54: [2, 28], 65: [2, 28], 68: [2, 28], 72: [2, 28], 75: [2, 28], 80: [2, 28], 81: [2, 28], 82: [2, 28], 83: [2, 28], 84: [2, 28], 85: [2, 28] }, { 23: [2, 30], 33: [2, 30], 54: [2, 30], 68: [2, 30], 71: 106, 72: [1, 107], 75: [2, 30] }, { 23: [2, 98], 33: [2, 98], 54: [2, 98], 68: [2, 98], 72: [2, 98], 75: [2, 98] }, { 23: [2, 45], 33: [2, 45], 54: [2, 45], 65: [2, 45], 68: [2, 45], 72: [2, 45], 73: [1, 108], 75: [2, 45], 80: [2, 45], 81: [2, 45], 82: [2, 45], 83: [2, 45], 84: [2, 45], 85: [2, 45], 87: [2, 45] }, { 23: [2, 44], 33: [2, 44], 54: [2, 44], 65: [2, 44], 68: [2, 44], 72: [2, 44], 75: [2, 44], 80: [2, 44], 81: [2, 44], 82: [2, 44], 83: [2, 44], 84: [2, 44], 85: [2, 44], 87: [2, 44] }, { 54: [1, 109] }, { 54: [2, 83], 65: [2, 83], 72: [2, 83], 80: [2, 83], 81: [2, 83], 82: [2, 83], 83: [2, 83], 84: [2, 83], 85: [2, 83] }, { 54: [2, 85] }, { 5: [2, 13], 14: [2, 13], 15: [2, 13], 19: [2, 13], 29: [2, 13], 34: [2, 13], 39: [2, 13], 44: [2, 13], 47: [2, 13], 48: [2, 13], 51: [2, 13], 55: [2, 13], 60: [2, 13] }, { 38: 55, 39: [1, 57], 43: 56, 44: [1, 58], 45: 111, 46: 110, 47: [2, 76] }, { 33: [2, 70], 40: 112, 65: [2, 70], 72: [2, 70], 75: [2, 70], 80: [2, 70], 81: [2, 70], 82: [2, 70], 83: [2, 70], 84: [2, 70], 85: [2, 70] }, { 47: [2, 18] }, { 5: [2, 14], 14: [2, 14], 15: [2, 14], 19: [2, 14], 29: [2, 14], 34: [2, 14], 39: [2, 14], 44: [2, 14], 47: [2, 14], 48: [2, 14], 51: [2, 14], 55: [2, 14], 60: [2, 14] }, { 33: [1, 113] }, { 33: [2, 87], 65: [2, 87], 72: [2, 87], 80: [2, 87], 81: [2, 87], 82: [2, 87], 83: [2, 87], 84: [2, 87], 85: [2, 87] }, { 33: [2, 89] }, { 20: 74, 63: 115, 64: 75, 65: [1, 43], 67: 114, 68: [2, 96], 69: 116, 70: 76, 71: 77, 72: [1, 78], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 33: [1, 117] }, { 32: 118, 33: [2, 62], 74: 119, 75: [1, 120] }, { 33: [2, 59], 65: [2, 59], 72: [2, 59], 75: [2, 59], 80: [2, 59], 81: [2, 59], 82: [2, 59], 83: [2, 59], 84: [2, 59], 85: [2, 59] }, { 33: [2, 61], 75: [2, 61] }, { 33: [2, 68], 37: 121, 74: 122, 75: [1, 120] }, { 33: [2, 65], 65: [2, 65], 72: [2, 65], 75: [2, 65], 80: [2, 65], 81: [2, 65], 82: [2, 65], 83: [2, 65], 84: [2, 65], 85: [2, 65] }, { 33: [2, 67], 75: [2, 67] }, { 23: [1, 123] }, { 23: [2, 51], 65: [2, 51], 72: [2, 51], 80: [2, 51], 81: [2, 51], 82: [2, 51], 83: [2, 51], 84: [2, 51], 85: [2, 51] }, { 23: [2, 53] }, { 33: [1, 124] }, { 33: [2, 91], 65: [2, 91], 72: [2, 91], 80: [2, 91], 81: [2, 91], 82: [2, 91], 83: [2, 91], 84: [2, 91], 85: [2, 91] }, { 33: [2, 93] }, { 5: [2, 22], 14: [2, 22], 15: [2, 22], 19: [2, 22], 29: [2, 22], 34: [2, 22], 39: [2, 22], 44: [2, 22], 47: [2, 22], 48: [2, 22], 51: [2, 22], 55: [2, 22], 60: [2, 22] }, { 23: [2, 99], 33: [2, 99], 54: [2, 99], 68: [2, 99], 72: [2, 99], 75: [2, 99] }, { 73: [1, 108] }, { 20: 74, 63: 125, 64: 75, 65: [1, 43], 72: [1, 35], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 5: [2, 23], 14: [2, 23], 15: [2, 23], 19: [2, 23], 29: [2, 23], 34: [2, 23], 39: [2, 23], 44: [2, 23], 47: [2, 23], 48: [2, 23], 51: [2, 23], 55: [2, 23], 60: [2, 23] }, { 47: [2, 19] }, { 47: [2, 77] }, { 20: 74, 33: [2, 72], 41: 126, 63: 127, 64: 75, 65: [1, 43], 69: 128, 70: 76, 71: 77, 72: [1, 78], 75: [2, 72], 78: 26, 79: 27, 80: [1, 28], 81: [1, 29], 82: [1, 30], 83: [1, 31], 84: [1, 32], 85: [1, 34], 86: 33 }, { 5: [2, 24], 14: [2, 24], 15: [2, 24], 19: [2, 24], 29: [2, 24], 34: [2, 24], 39: [2, 24], 44: [2, 24], 47: [2, 24], 48: [2, 24], 51: [2, 24], 55: [2, 24], 60: [2, 24] }, { 68: [1, 129] }, { 65: [2, 95], 68: [2, 95], 72: [2, 95], 80: [2, 95], 81: [2, 95], 82: [2, 95], 83: [2, 95], 84: [2, 95], 85: [2, 95] }, { 68: [2, 97] }, { 5: [2, 21], 14: [2, 21], 15: [2, 21], 19: [2, 21], 29: [2, 21], 34: [2, 21], 39: [2, 21], 44: [2, 21], 47: [2, 21], 48: [2, 21], 51: [2, 21], 55: [2, 21], 60: [2, 21] }, { 33: [1, 130] }, { 33: [2, 63] }, { 72: [1, 132], 76: 131 }, { 33: [1, 133] }, { 33: [2, 69] }, { 15: [2, 12], 18: [2, 12] }, { 14: [2, 26], 15: [2, 26], 19: [2, 26], 29: [2, 26], 34: [2, 26], 47: [2, 26], 48: [2, 26], 51: [2, 26], 55: [2, 26], 60: [2, 26] }, { 23: [2, 31], 33: [2, 31], 54: [2, 31], 68: [2, 31], 72: [2, 31], 75: [2, 31] }, { 33: [2, 74], 42: 134, 74: 135, 75: [1, 120] }, { 33: [2, 71], 65: [2, 71], 72: [2, 71], 75: [2, 71], 80: [2, 71], 81: [2, 71], 82: [2, 71], 83: [2, 71], 84: [2, 71], 85: [2, 71] }, { 33: [2, 73], 75: [2, 73] }, { 23: [2, 29], 33: [2, 29], 54: [2, 29], 65: [2, 29], 68: [2, 29], 72: [2, 29], 75: [2, 29], 80: [2, 29], 81: [2, 29], 82: [2, 29], 83: [2, 29], 84: [2, 29], 85: [2, 29] }, { 14: [2, 15], 15: [2, 15], 19: [2, 15], 29: [2, 15], 34: [2, 15], 39: [2, 15], 44: [2, 15], 47: [2, 15], 48: [2, 15], 51: [2, 15], 55: [2, 15], 60: [2, 15] }, { 72: [1, 137], 77: [1, 136] }, { 72: [2, 100], 77: [2, 100] }, { 14: [2, 16], 15: [2, 16], 19: [2, 16], 29: [2, 16], 34: [2, 16], 44: [2, 16], 47: [2, 16], 48: [2, 16], 51: [2, 16], 55: [2, 16], 60: [2, 16] }, { 33: [1, 138] }, { 33: [2, 75] }, { 33: [2, 32] }, { 72: [2, 101], 77: [2, 101] }, { 14: [2, 17], 15: [2, 17], 19: [2, 17], 29: [2, 17], 34: [2, 17], 39: [2, 17], 44: [2, 17], 47: [2, 17], 48: [2, 17], 51: [2, 17], 55: [2, 17], 60: [2, 17] }],
        defaultActions: { 4: [2, 1], 54: [2, 55], 56: [2, 20], 60: [2, 57], 73: [2, 81], 82: [2, 85], 86: [2, 18], 90: [2, 89], 101: [2, 53], 104: [2, 93], 110: [2, 19], 111: [2, 77], 116: [2, 97], 119: [2, 63], 122: [2, 69], 135: [2, 75], 136: [2, 32] },
        parseError: function parseError(str, hash) {
            throw new Error(str);
        },
        parse: function parse(input) {
            var self = this,
                stack = [0],
                vstack = [null],
                lstack = [],
                table = this.table,
                yytext = "",
                yylineno = 0,
                yyleng = 0,
                recovering = 0;
            this.lexer.setInput(input);
            this.lexer.yy = this.yy;
            this.yy.lexer = this.lexer;
            this.yy.parser = this;
            if (typeof this.lexer.yylloc == "undefined") this.lexer.yylloc = {};
            var yyloc = this.lexer.yylloc;
            lstack.push(yyloc);
            var ranges = this.lexer.options && this.lexer.options.ranges;
            if (typeof this.yy.parseError === "function") this.parseError = this.yy.parseError;
            function lex() {
                var token;
                token = self.lexer.lex() || 1;
                if (typeof token !== "number") {
                    token = self.symbols_[token] || token;
                }
                return token;
            }
            var symbol,
                state,
                action,
                r,
                yyval = {},
                p,
                len,
                newState,
                expected;
            while (true) {
                state = stack[stack.length - 1];
                if (this.defaultActions[state]) {
                    action = this.defaultActions[state];
                } else {
                    if (symbol === null || typeof symbol == "undefined") {
                        symbol = lex();
                    }
                    action = table[state] && table[state][symbol];
                }
                if (typeof action === "undefined" || !action.length || !action[0]) {
                    var errStr = "";
                    if (!recovering) {
                        expected = [];
                        for (p in table[state]) if (this.terminals_[p] && p > 2) {
                            expected.push("'" + this.terminals_[p] + "'");
                        }
                        if (this.lexer.showPosition) {
                            errStr = "Parse error on line " + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'";
                        } else {
                            errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == 1 ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'");
                        }
                        this.parseError(errStr, { text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected });
                    }
                }
                if (action[0] instanceof Array && action.length > 1) {
                    throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol);
                }
                switch (action[0]) {
                    case 1:
                        stack.push(symbol);
                        vstack.push(this.lexer.yytext);
                        lstack.push(this.lexer.yylloc);
                        stack.push(action[1]);
                        symbol = null;
                        {
                            yyleng = this.lexer.yyleng;
                            yytext = this.lexer.yytext;
                            yylineno = this.lexer.yylineno;
                            yyloc = this.lexer.yylloc;
                            if (recovering > 0) recovering--;
                        }
                        break;
                    case 2:
                        len = this.productions_[action[1]][1];
                        yyval.$ = vstack[vstack.length - len];
                        yyval._$ = { first_line: lstack[lstack.length - (len || 1)].first_line, last_line: lstack[lstack.length - 1].last_line, first_column: lstack[lstack.length - (len || 1)].first_column, last_column: lstack[lstack.length - 1].last_column };
                        if (ranges) {
                            yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
                        }
                        r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack);
                        if (typeof r !== "undefined") {
                            return r;
                        }
                        if (len) {
                            stack = stack.slice(0, -1 * len * 2);
                            vstack = vstack.slice(0, -1 * len);
                            lstack = lstack.slice(0, -1 * len);
                        }
                        stack.push(this.productions_[action[1]][0]);
                        vstack.push(yyval.$);
                        lstack.push(yyval._$);
                        newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
                        stack.push(newState);
                        break;
                    case 3:
                        return true;
                }
            }
            return true;
        }
    };
    /* Jison generated lexer */
    var lexer = (function () {
        var lexer = { EOF: 1,
            parseError: function parseError(str, hash) {
                if (this.yy.parser) {
                    this.yy.parser.parseError(str, hash);
                } else {
                    throw new Error(str);
                }
            },
            setInput: function setInput(input) {
                this._input = input;
                this._more = this._less = this.done = false;
                this.yylineno = this.yyleng = 0;
                this.yytext = this.matched = this.match = '';
                this.conditionStack = ['INITIAL'];
                this.yylloc = { first_line: 1, first_column: 0, last_line: 1, last_column: 0 };
                if (this.options.ranges) this.yylloc.range = [0, 0];
                this.offset = 0;
                return this;
            },
            input: function input() {
                var ch = this._input[0];
                this.yytext += ch;
                this.yyleng++;
                this.offset++;
                this.match += ch;
                this.matched += ch;
                var lines = ch.match(/(?:\r\n?|\n).*/g);
                if (lines) {
                    this.yylineno++;
                    this.yylloc.last_line++;
                } else {
                    this.yylloc.last_column++;
                }
                if (this.options.ranges) this.yylloc.range[1]++;

                this._input = this._input.slice(1);
                return ch;
            },
            unput: function unput(ch) {
                var len = ch.length;
                var lines = ch.split(/(?:\r\n?|\n)/g);

                this._input = ch + this._input;
                this.yytext = this.yytext.substr(0, this.yytext.length - len - 1);
                //this.yyleng -= len;
                this.offset -= len;
                var oldLines = this.match.split(/(?:\r\n?|\n)/g);
                this.match = this.match.substr(0, this.match.length - 1);
                this.matched = this.matched.substr(0, this.matched.length - 1);

                if (lines.length - 1) this.yylineno -= lines.length - 1;
                var r = this.yylloc.range;

                this.yylloc = { first_line: this.yylloc.first_line,
                    last_line: this.yylineno + 1,
                    first_column: this.yylloc.first_column,
                    last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
                };

                if (this.options.ranges) {
                    this.yylloc.range = [r[0], r[0] + this.yyleng - len];
                }
                return this;
            },
            more: function more() {
                this._more = true;
                return this;
            },
            less: function less(n) {
                this.unput(this.match.slice(n));
            },
            pastInput: function pastInput() {
                var past = this.matched.substr(0, this.matched.length - this.match.length);
                return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, "");
            },
            upcomingInput: function upcomingInput() {
                var next = this.match;
                if (next.length < 20) {
                    next += this._input.substr(0, 20 - next.length);
                }
                return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
            },
            showPosition: function showPosition() {
                var pre = this.pastInput();
                var c = new Array(pre.length + 1).join("-");
                return pre + this.upcomingInput() + "\n" + c + "^";
            },
            next: function next() {
                if (this.done) {
                    return this.EOF;
                }
                if (!this._input) this.done = true;

                var token, match, tempMatch, index, lines;
                if (!this._more) {
                    this.yytext = '';
                    this.match = '';
                }
                var rules = this._currentRules();
                for (var i = 0; i < rules.length; i++) {
                    tempMatch = this._input.match(this.rules[rules[i]]);
                    if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
                        match = tempMatch;
                        index = i;
                        if (!this.options.flex) break;
                    }
                }
                if (match) {
                    lines = match[0].match(/(?:\r\n?|\n).*/g);
                    if (lines) this.yylineno += lines.length;
                    this.yylloc = { first_line: this.yylloc.last_line,
                        last_line: this.yylineno + 1,
                        first_column: this.yylloc.last_column,
                        last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length };
                    this.yytext += match[0];
                    this.match += match[0];
                    this.matches = match;
                    this.yyleng = this.yytext.length;
                    if (this.options.ranges) {
                        this.yylloc.range = [this.offset, this.offset += this.yyleng];
                    }
                    this._more = false;
                    this._input = this._input.slice(match[0].length);
                    this.matched += match[0];
                    token = this.performAction.call(this, this.yy, this, rules[index], this.conditionStack[this.conditionStack.length - 1]);
                    if (this.done && this._input) this.done = false;
                    if (token) return token;else return;
                }
                if (this._input === "") {
                    return this.EOF;
                } else {
                    return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), { text: "", token: null, line: this.yylineno });
                }
            },
            lex: function lex() {
                var r = this.next();
                if (typeof r !== 'undefined') {
                    return r;
                } else {
                    return this.lex();
                }
            },
            begin: function begin(condition) {
                this.conditionStack.push(condition);
            },
            popState: function popState() {
                return this.conditionStack.pop();
            },
            _currentRules: function _currentRules() {
                return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
            },
            topState: function topState() {
                return this.conditionStack[this.conditionStack.length - 2];
            },
            pushState: function begin(condition) {
                this.begin(condition);
            } };
        lexer.options = {};
        lexer.performAction = function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {

            function strip(start, end) {
                return yy_.yytext = yy_.yytext.substring(start, yy_.yyleng - end + start);
            }
            switch ($avoiding_name_collisions) {
                case 0:
                    if (yy_.yytext.slice(-2) === "\\\\") {
                        strip(0, 1);
                        this.begin("mu");
                    } else if (yy_.yytext.slice(-1) === "\\") {
                        strip(0, 1);
                        this.begin("emu");
                    } else {
                        this.begin("mu");
                    }
                    if (yy_.yytext) return 15;

                    break;
                case 1:
                    return 15;
                case 2:
                    this.popState();
                    return 15;
                case 3:
                    this.begin('raw');return 15;
                case 4:
                    this.popState();
                    // Should be using `this.topState()` below, but it currently
                    // returns the second top instead of the first top. Opened an
                    // issue about it at https://github.com/zaach/jison/issues/291
                    if (this.conditionStack[this.conditionStack.length - 1] === 'raw') {
                        return 15;
                    } else {
                        strip(5, 9);
                        return 'END_RAW_BLOCK';
                    }
                case 5:
                    return 15;
                case 6:
                    this.popState();
                    return 14;
                case 7:
                    return 65;
                case 8:
                    return 68;
                case 9:
                    return 19;
                case 10:
                    this.popState();
                    this.begin('raw');
                    return 23;
                case 11:
                    return 55;
                case 12:
                    return 60;
                case 13:
                    return 29;
                case 14:
                    return 47;
                case 15:
                    this.popState();return 44;
                case 16:
                    this.popState();return 44;
                case 17:
                    return 34;
                case 18:
                    return 39;
                case 19:
                    return 51;
                case 20:
                    return 48;
                case 21:
                    this.unput(yy_.yytext);
                    this.popState();
                    this.begin('com');

                    break;
                case 22:
                    this.popState();
                    return 14;
                case 23:
                    return 48;
                case 24:
                    return 73;
                case 25:
                    return 72;
                case 26:
                    return 72;
                case 27:
                    return 87;
                case 28:
                    // ignore whitespace
                    break;
                case 29:
                    this.popState();return 54;
                case 30:
                    this.popState();return 33;
                case 31:
                    yy_.yytext = strip(1, 2).replace(/\\"/g, '"');return 80;
                case 32:
                    yy_.yytext = strip(1, 2).replace(/\\'/g, "'");return 80;
                case 33:
                    return 85;
                case 34:
                    return 82;
                case 35:
                    return 82;
                case 36:
                    return 83;
                case 37:
                    return 84;
                case 38:
                    return 81;
                case 39:
                    return 75;
                case 40:
                    return 77;
                case 41:
                    return 72;
                case 42:
                    yy_.yytext = yy_.yytext.replace(/\\([\\\]])/g, '$1');return 72;
                case 43:
                    return 'INVALID';
                case 44:
                    return 5;
            }
        };
        lexer.rules = [/^(?:[^\x00]*?(?=(\{\{)))/, /^(?:[^\x00]+)/, /^(?:[^\x00]{2,}?(?=(\{\{|\\\{\{|\\\\\{\{|$)))/, /^(?:\{\{\{\{(?=[^\/]))/, /^(?:\{\{\{\{\/[^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=[=}\s\/.])\}\}\}\})/, /^(?:[^\x00]+?(?=(\{\{\{\{)))/, /^(?:[\s\S]*?--(~)?\}\})/, /^(?:\()/, /^(?:\))/, /^(?:\{\{\{\{)/, /^(?:\}\}\}\})/, /^(?:\{\{(~)?>)/, /^(?:\{\{(~)?#>)/, /^(?:\{\{(~)?#\*?)/, /^(?:\{\{(~)?\/)/, /^(?:\{\{(~)?\^\s*(~)?\}\})/, /^(?:\{\{(~)?\s*else\s*(~)?\}\})/, /^(?:\{\{(~)?\^)/, /^(?:\{\{(~)?\s*else\b)/, /^(?:\{\{(~)?\{)/, /^(?:\{\{(~)?&)/, /^(?:\{\{(~)?!--)/, /^(?:\{\{(~)?![\s\S]*?\}\})/, /^(?:\{\{(~)?\*?)/, /^(?:=)/, /^(?:\.\.)/, /^(?:\.(?=([=~}\s\/.)|])))/, /^(?:[\/.])/, /^(?:\s+)/, /^(?:\}(~)?\}\})/, /^(?:(~)?\}\})/, /^(?:"(\\["]|[^"])*")/, /^(?:'(\\[']|[^'])*')/, /^(?:@)/, /^(?:true(?=([~}\s)])))/, /^(?:false(?=([~}\s)])))/, /^(?:undefined(?=([~}\s)])))/, /^(?:null(?=([~}\s)])))/, /^(?:-?[0-9]+(?:\.[0-9]+)?(?=([~}\s)])))/, /^(?:as\s+\|)/, /^(?:\|)/, /^(?:([^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=([=~}\s\/.)|]))))/, /^(?:\[(\\\]|[^\]])*\])/, /^(?:.)/, /^(?:$)/];
        lexer.conditions = { "mu": { "rules": [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44], "inclusive": false }, "emu": { "rules": [2], "inclusive": false }, "com": { "rules": [6], "inclusive": false }, "raw": { "rules": [3, 4, 5], "inclusive": false }, "INITIAL": { "rules": [0, 1, 44], "inclusive": true } };
        return lexer;
    })();
    parser.lexer = lexer;
    function Parser() {
        this.yy = {};
    }Parser.prototype = parser;parser.Parser = Parser;
    return new Parser();
})();exports["default"] = handlebars;
module.exports = exports["default"];

});

var visitor = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }



var _exception2 = _interopRequireDefault(exception);

function Visitor() {
  this.parents = [];
}

Visitor.prototype = {
  constructor: Visitor,
  mutating: false,

  // Visits a given value. If mutating, will replace the value if necessary.
  acceptKey: function acceptKey(node, name) {
    var value = this.accept(node[name]);
    if (this.mutating) {
      // Hacky sanity check: This may have a few false positives for type for the helper
      // methods but will generally do the right thing without a lot of overhead.
      if (value && !Visitor.prototype[value.type]) {
        throw new _exception2['default']('Unexpected node type "' + value.type + '" found when accepting ' + name + ' on ' + node.type);
      }
      node[name] = value;
    }
  },

  // Performs an accept operation with added sanity check to ensure
  // required keys are not removed.
  acceptRequired: function acceptRequired(node, name) {
    this.acceptKey(node, name);

    if (!node[name]) {
      throw new _exception2['default'](node.type + ' requires ' + name);
    }
  },

  // Traverses a given array. If mutating, empty respnses will be removed
  // for child elements.
  acceptArray: function acceptArray(array) {
    for (var i = 0, l = array.length; i < l; i++) {
      this.acceptKey(array, i);

      if (!array[i]) {
        array.splice(i, 1);
        i--;
        l--;
      }
    }
  },

  accept: function accept(object) {
    if (!object) {
      return;
    }

    /* istanbul ignore next: Sanity code */
    if (!this[object.type]) {
      throw new _exception2['default']('Unknown type: ' + object.type, object);
    }

    if (this.current) {
      this.parents.unshift(this.current);
    }
    this.current = object;

    var ret = this[object.type](object);

    this.current = this.parents.shift();

    if (!this.mutating || ret) {
      return ret;
    } else if (ret !== false) {
      return object;
    }
  },

  Program: function Program(program) {
    this.acceptArray(program.body);
  },

  MustacheStatement: visitSubExpression,
  Decorator: visitSubExpression,

  BlockStatement: visitBlock,
  DecoratorBlock: visitBlock,

  PartialStatement: visitPartial,
  PartialBlockStatement: function PartialBlockStatement(partial) {
    visitPartial.call(this, partial);

    this.acceptKey(partial, 'program');
  },

  ContentStatement: function ContentStatement() /* content */{},
  CommentStatement: function CommentStatement() /* comment */{},

  SubExpression: visitSubExpression,

  PathExpression: function PathExpression() /* path */{},

  StringLiteral: function StringLiteral() /* string */{},
  NumberLiteral: function NumberLiteral() /* number */{},
  BooleanLiteral: function BooleanLiteral() /* bool */{},
  UndefinedLiteral: function UndefinedLiteral() /* literal */{},
  NullLiteral: function NullLiteral() /* literal */{},

  Hash: function Hash(hash) {
    this.acceptArray(hash.pairs);
  },
  HashPair: function HashPair(pair) {
    this.acceptRequired(pair, 'value');
  }
};

function visitSubExpression(mustache) {
  this.acceptRequired(mustache, 'path');
  this.acceptArray(mustache.params);
  this.acceptKey(mustache, 'hash');
}
function visitBlock(block) {
  visitSubExpression.call(this, block);

  this.acceptKey(block, 'program');
  this.acceptKey(block, 'inverse');
}
function visitPartial(partial) {
  this.acceptRequired(partial, 'name');
  this.acceptArray(partial.params);
  this.acceptKey(partial, 'hash');
}

exports['default'] = Visitor;
module.exports = exports['default'];

});

var whitespaceControl = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }



var _visitor2 = _interopRequireDefault(visitor);

function WhitespaceControl() {
  var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

  this.options = options;
}
WhitespaceControl.prototype = new _visitor2['default']();

WhitespaceControl.prototype.Program = function (program) {
  var doStandalone = !this.options.ignoreStandalone;

  var isRoot = !this.isRootSeen;
  this.isRootSeen = true;

  var body = program.body;
  for (var i = 0, l = body.length; i < l; i++) {
    var current = body[i],
        strip = this.accept(current);

    if (!strip) {
      continue;
    }

    var _isPrevWhitespace = isPrevWhitespace(body, i, isRoot),
        _isNextWhitespace = isNextWhitespace(body, i, isRoot),
        openStandalone = strip.openStandalone && _isPrevWhitespace,
        closeStandalone = strip.closeStandalone && _isNextWhitespace,
        inlineStandalone = strip.inlineStandalone && _isPrevWhitespace && _isNextWhitespace;

    if (strip.close) {
      omitRight(body, i, true);
    }
    if (strip.open) {
      omitLeft(body, i, true);
    }

    if (doStandalone && inlineStandalone) {
      omitRight(body, i);

      if (omitLeft(body, i)) {
        // If we are on a standalone node, save the indent info for partials
        if (current.type === 'PartialStatement') {
          // Pull out the whitespace from the final line
          current.indent = /([ \t]+$)/.exec(body[i - 1].original)[1];
        }
      }
    }
    if (doStandalone && openStandalone) {
      omitRight((current.program || current.inverse).body);

      // Strip out the previous content node if it's whitespace only
      omitLeft(body, i);
    }
    if (doStandalone && closeStandalone) {
      // Always strip the next node
      omitRight(body, i);

      omitLeft((current.inverse || current.program).body);
    }
  }

  return program;
};

WhitespaceControl.prototype.BlockStatement = WhitespaceControl.prototype.DecoratorBlock = WhitespaceControl.prototype.PartialBlockStatement = function (block) {
  this.accept(block.program);
  this.accept(block.inverse);

  // Find the inverse program that is involed with whitespace stripping.
  var program = block.program || block.inverse,
      inverse = block.program && block.inverse,
      firstInverse = inverse,
      lastInverse = inverse;

  if (inverse && inverse.chained) {
    firstInverse = inverse.body[0].program;

    // Walk the inverse chain to find the last inverse that is actually in the chain.
    while (lastInverse.chained) {
      lastInverse = lastInverse.body[lastInverse.body.length - 1].program;
    }
  }

  var strip = {
    open: block.openStrip.open,
    close: block.closeStrip.close,

    // Determine the standalone candiacy. Basically flag our content as being possibly standalone
    // so our parent can determine if we actually are standalone
    openStandalone: isNextWhitespace(program.body),
    closeStandalone: isPrevWhitespace((firstInverse || program).body)
  };

  if (block.openStrip.close) {
    omitRight(program.body, null, true);
  }

  if (inverse) {
    var inverseStrip = block.inverseStrip;

    if (inverseStrip.open) {
      omitLeft(program.body, null, true);
    }

    if (inverseStrip.close) {
      omitRight(firstInverse.body, null, true);
    }
    if (block.closeStrip.open) {
      omitLeft(lastInverse.body, null, true);
    }

    // Find standalone else statments
    if (!this.options.ignoreStandalone && isPrevWhitespace(program.body) && isNextWhitespace(firstInverse.body)) {
      omitLeft(program.body);
      omitRight(firstInverse.body);
    }
  } else if (block.closeStrip.open) {
    omitLeft(program.body, null, true);
  }

  return strip;
};

WhitespaceControl.prototype.Decorator = WhitespaceControl.prototype.MustacheStatement = function (mustache) {
  return mustache.strip;
};

WhitespaceControl.prototype.PartialStatement = WhitespaceControl.prototype.CommentStatement = function (node) {
  /* istanbul ignore next */
  var strip = node.strip || {};
  return {
    inlineStandalone: true,
    open: strip.open,
    close: strip.close
  };
};

function isPrevWhitespace(body, i, isRoot) {
  if (i === undefined) {
    i = body.length;
  }

  // Nodes that end with newlines are considered whitespace (but are special
  // cased for strip operations)
  var prev = body[i - 1],
      sibling = body[i - 2];
  if (!prev) {
    return isRoot;
  }

  if (prev.type === 'ContentStatement') {
    return (sibling || !isRoot ? /\r?\n\s*?$/ : /(^|\r?\n)\s*?$/).test(prev.original);
  }
}
function isNextWhitespace(body, i, isRoot) {
  if (i === undefined) {
    i = -1;
  }

  var next = body[i + 1],
      sibling = body[i + 2];
  if (!next) {
    return isRoot;
  }

  if (next.type === 'ContentStatement') {
    return (sibling || !isRoot ? /^\s*?\r?\n/ : /^\s*?(\r?\n|$)/).test(next.original);
  }
}

// Marks the node to the right of the position as omitted.
// I.e. {{foo}}' ' will mark the ' ' node as omitted.
//
// If i is undefined, then the first child will be marked as such.
//
// If mulitple is truthy then all whitespace will be stripped out until non-whitespace
// content is met.
function omitRight(body, i, multiple) {
  var current = body[i == null ? 0 : i + 1];
  if (!current || current.type !== 'ContentStatement' || !multiple && current.rightStripped) {
    return;
  }

  var original = current.value;
  current.value = current.value.replace(multiple ? /^\s+/ : /^[ \t]*\r?\n?/, '');
  current.rightStripped = current.value !== original;
}

// Marks the node to the left of the position as omitted.
// I.e. ' '{{foo}} will mark the ' ' node as omitted.
//
// If i is undefined then the last child will be marked as such.
//
// If mulitple is truthy then all whitespace will be stripped out until non-whitespace
// content is met.
function omitLeft(body, i, multiple) {
  var current = body[i == null ? body.length - 1 : i - 1];
  if (!current || current.type !== 'ContentStatement' || !multiple && current.leftStripped) {
    return;
  }

  // We omit the last node if it's whitespace only and not preceded by a non-content node.
  var original = current.value;
  current.value = current.value.replace(multiple ? /\s+$/ : /[ \t]+$/, '');
  current.leftStripped = current.value !== original;
  return current.leftStripped;
}

exports['default'] = WhitespaceControl;
module.exports = exports['default'];

});

var helpers$1 = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
exports.SourceLocation = SourceLocation;
exports.id = id;
exports.stripFlags = stripFlags;
exports.stripComment = stripComment;
exports.preparePath = preparePath;
exports.prepareMustache = prepareMustache;
exports.prepareRawBlock = prepareRawBlock;
exports.prepareBlock = prepareBlock;
exports.prepareProgram = prepareProgram;
exports.preparePartialBlock = preparePartialBlock;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }



var _exception2 = _interopRequireDefault(exception);

function validateClose(open, close) {
  close = close.path ? close.path.original : close;

  if (open.path.original !== close) {
    var errorNode = { loc: open.path.loc };

    throw new _exception2['default'](open.path.original + " doesn't match " + close, errorNode);
  }
}

function SourceLocation(source, locInfo) {
  this.source = source;
  this.start = {
    line: locInfo.first_line,
    column: locInfo.first_column
  };
  this.end = {
    line: locInfo.last_line,
    column: locInfo.last_column
  };
}

function id(token) {
  if (/^\[.*\]$/.test(token)) {
    return token.substring(1, token.length - 1);
  } else {
    return token;
  }
}

function stripFlags(open, close) {
  return {
    open: open.charAt(2) === '~',
    close: close.charAt(close.length - 3) === '~'
  };
}

function stripComment(comment) {
  return comment.replace(/^\{\{~?!-?-?/, '').replace(/-?-?~?\}\}$/, '');
}

function preparePath(data, parts, loc) {
  loc = this.locInfo(loc);

  var original = data ? '@' : '',
      dig = [],
      depth = 0;

  for (var i = 0, l = parts.length; i < l; i++) {
    var part = parts[i].part,

    // If we have [] syntax then we do not treat path references as operators,
    // i.e. foo.[this] resolves to approximately context.foo['this']
    isLiteral = parts[i].original !== part;
    original += (parts[i].separator || '') + part;

    if (!isLiteral && (part === '..' || part === '.' || part === 'this')) {
      if (dig.length > 0) {
        throw new _exception2['default']('Invalid path: ' + original, { loc: loc });
      } else if (part === '..') {
        depth++;
      }
    } else {
      dig.push(part);
    }
  }

  return {
    type: 'PathExpression',
    data: data,
    depth: depth,
    parts: dig,
    original: original,
    loc: loc
  };
}

function prepareMustache(path, params, hash, open, strip, locInfo) {
  // Must use charAt to support IE pre-10
  var escapeFlag = open.charAt(3) || open.charAt(2),
      escaped = escapeFlag !== '{' && escapeFlag !== '&';

  var decorator = /\*/.test(open);
  return {
    type: decorator ? 'Decorator' : 'MustacheStatement',
    path: path,
    params: params,
    hash: hash,
    escaped: escaped,
    strip: strip,
    loc: this.locInfo(locInfo)
  };
}

function prepareRawBlock(openRawBlock, contents, close, locInfo) {
  validateClose(openRawBlock, close);

  locInfo = this.locInfo(locInfo);
  var program = {
    type: 'Program',
    body: contents,
    strip: {},
    loc: locInfo
  };

  return {
    type: 'BlockStatement',
    path: openRawBlock.path,
    params: openRawBlock.params,
    hash: openRawBlock.hash,
    program: program,
    openStrip: {},
    inverseStrip: {},
    closeStrip: {},
    loc: locInfo
  };
}

function prepareBlock(openBlock, program, inverseAndProgram, close, inverted, locInfo) {
  if (close && close.path) {
    validateClose(openBlock, close);
  }

  var decorator = /\*/.test(openBlock.open);

  program.blockParams = openBlock.blockParams;

  var inverse = undefined,
      inverseStrip = undefined;

  if (inverseAndProgram) {
    if (decorator) {
      throw new _exception2['default']('Unexpected inverse block on decorator', inverseAndProgram);
    }

    if (inverseAndProgram.chain) {
      inverseAndProgram.program.body[0].closeStrip = close.strip;
    }

    inverseStrip = inverseAndProgram.strip;
    inverse = inverseAndProgram.program;
  }

  if (inverted) {
    inverted = inverse;
    inverse = program;
    program = inverted;
  }

  return {
    type: decorator ? 'DecoratorBlock' : 'BlockStatement',
    path: openBlock.path,
    params: openBlock.params,
    hash: openBlock.hash,
    program: program,
    inverse: inverse,
    openStrip: openBlock.strip,
    inverseStrip: inverseStrip,
    closeStrip: close && close.strip,
    loc: this.locInfo(locInfo)
  };
}

function prepareProgram(statements, loc) {
  if (!loc && statements.length) {
    var firstLoc = statements[0].loc,
        lastLoc = statements[statements.length - 1].loc;

    /* istanbul ignore else */
    if (firstLoc && lastLoc) {
      loc = {
        source: firstLoc.source,
        start: {
          line: firstLoc.start.line,
          column: firstLoc.start.column
        },
        end: {
          line: lastLoc.end.line,
          column: lastLoc.end.column
        }
      };
    }
  }

  return {
    type: 'Program',
    body: statements,
    strip: {},
    loc: loc
  };
}

function preparePartialBlock(open, program, close, locInfo) {
  validateClose(open, close);

  return {
    type: 'PartialBlockStatement',
    name: open.path,
    params: open.params,
    hash: open.hash,
    program: program,
    openStrip: open.strip,
    closeStrip: close && close.strip,
    loc: this.locInfo(locInfo)
  };
}

});

var base$1 = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
exports.parseWithoutProcessing = parseWithoutProcessing;
exports.parse = parse;
// istanbul ignore next

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }

// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }



var _parser2 = _interopRequireDefault(parser);



var _whitespaceControl2 = _interopRequireDefault(whitespaceControl);



var Helpers = _interopRequireWildcard(helpers$1);



exports.parser = _parser2['default'];

var yy = {};
utils$2.extend(yy, Helpers);

function parseWithoutProcessing(input, options) {
  // Just return if an already-compiled AST was passed in.
  if (input.type === 'Program') {
    return input;
  }

  _parser2['default'].yy = yy;

  // Altering the shared object here, but this is ok as parser is a sync operation
  yy.locInfo = function (locInfo) {
    return new yy.SourceLocation(options && options.srcName, locInfo);
  };

  var ast = _parser2['default'].parse(input);

  return ast;
}

function parse(input, options) {
  var ast = parseWithoutProcessing(input, options);
  var strip = new _whitespaceControl2['default'](options);

  return strip.accept(ast);
}

});

var compiler = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
exports.Compiler = Compiler;
exports.precompile = precompile;
exports.compile = compile;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }



var _exception2 = _interopRequireDefault(exception);





var _ast2 = _interopRequireDefault(ast);

var slice = [].slice;

function Compiler() {}

// the foundHelper register will disambiguate helper lookup from finding a
// function in a context. This is necessary for mustache compatibility, which
// requires that context functions in blocks are evaluated by blockHelperMissing,
// and then proceed as if the resulting value was provided to blockHelperMissing.

Compiler.prototype = {
  compiler: Compiler,

  equals: function equals(other) {
    var len = this.opcodes.length;
    if (other.opcodes.length !== len) {
      return false;
    }

    for (var i = 0; i < len; i++) {
      var opcode = this.opcodes[i],
          otherOpcode = other.opcodes[i];
      if (opcode.opcode !== otherOpcode.opcode || !argEquals(opcode.args, otherOpcode.args)) {
        return false;
      }
    }

    // We know that length is the same between the two arrays because they are directly tied
    // to the opcode behavior above.
    len = this.children.length;
    for (var i = 0; i < len; i++) {
      if (!this.children[i].equals(other.children[i])) {
        return false;
      }
    }

    return true;
  },

  guid: 0,

  compile: function compile(program, options) {
    this.sourceNode = [];
    this.opcodes = [];
    this.children = [];
    this.options = options;
    this.stringParams = options.stringParams;
    this.trackIds = options.trackIds;

    options.blockParams = options.blockParams || [];

    options.knownHelpers = utils$2.extend(Object.create(null), {
      helperMissing: true,
      blockHelperMissing: true,
      each: true,
      'if': true,
      unless: true,
      'with': true,
      log: true,
      lookup: true
    }, options.knownHelpers);

    return this.accept(program);
  },

  compileProgram: function compileProgram(program) {
    var childCompiler = new this.compiler(),
        // eslint-disable-line new-cap
    result = childCompiler.compile(program, this.options),
        guid = this.guid++;

    this.usePartial = this.usePartial || result.usePartial;

    this.children[guid] = result;
    this.useDepths = this.useDepths || result.useDepths;

    return guid;
  },

  accept: function accept(node) {
    /* istanbul ignore next: Sanity code */
    if (!this[node.type]) {
      throw new _exception2['default']('Unknown type: ' + node.type, node);
    }

    this.sourceNode.unshift(node);
    var ret = this[node.type](node);
    this.sourceNode.shift();
    return ret;
  },

  Program: function Program(program) {
    this.options.blockParams.unshift(program.blockParams);

    var body = program.body,
        bodyLength = body.length;
    for (var i = 0; i < bodyLength; i++) {
      this.accept(body[i]);
    }

    this.options.blockParams.shift();

    this.isSimple = bodyLength === 1;
    this.blockParams = program.blockParams ? program.blockParams.length : 0;

    return this;
  },

  BlockStatement: function BlockStatement(block) {
    transformLiteralToPath(block);

    var program = block.program,
        inverse = block.inverse;

    program = program && this.compileProgram(program);
    inverse = inverse && this.compileProgram(inverse);

    var type = this.classifySexpr(block);

    if (type === 'helper') {
      this.helperSexpr(block, program, inverse);
    } else if (type === 'simple') {
      this.simpleSexpr(block);

      // now that the simple mustache is resolved, we need to
      // evaluate it by executing `blockHelperMissing`
      this.opcode('pushProgram', program);
      this.opcode('pushProgram', inverse);
      this.opcode('emptyHash');
      this.opcode('blockValue', block.path.original);
    } else {
      this.ambiguousSexpr(block, program, inverse);

      // now that the simple mustache is resolved, we need to
      // evaluate it by executing `blockHelperMissing`
      this.opcode('pushProgram', program);
      this.opcode('pushProgram', inverse);
      this.opcode('emptyHash');
      this.opcode('ambiguousBlockValue');
    }

    this.opcode('append');
  },

  DecoratorBlock: function DecoratorBlock(decorator) {
    var program = decorator.program && this.compileProgram(decorator.program);
    var params = this.setupFullMustacheParams(decorator, program, undefined),
        path = decorator.path;

    this.useDecorators = true;
    this.opcode('registerDecorator', params.length, path.original);
  },

  PartialStatement: function PartialStatement(partial) {
    this.usePartial = true;

    var program = partial.program;
    if (program) {
      program = this.compileProgram(partial.program);
    }

    var params = partial.params;
    if (params.length > 1) {
      throw new _exception2['default']('Unsupported number of partial arguments: ' + params.length, partial);
    } else if (!params.length) {
      if (this.options.explicitPartialContext) {
        this.opcode('pushLiteral', 'undefined');
      } else {
        params.push({ type: 'PathExpression', parts: [], depth: 0 });
      }
    }

    var partialName = partial.name.original,
        isDynamic = partial.name.type === 'SubExpression';
    if (isDynamic) {
      this.accept(partial.name);
    }

    this.setupFullMustacheParams(partial, program, undefined, true);

    var indent = partial.indent || '';
    if (this.options.preventIndent && indent) {
      this.opcode('appendContent', indent);
      indent = '';
    }

    this.opcode('invokePartial', isDynamic, partialName, indent);
    this.opcode('append');
  },
  PartialBlockStatement: function PartialBlockStatement(partialBlock) {
    this.PartialStatement(partialBlock);
  },

  MustacheStatement: function MustacheStatement(mustache) {
    this.SubExpression(mustache);

    if (mustache.escaped && !this.options.noEscape) {
      this.opcode('appendEscaped');
    } else {
      this.opcode('append');
    }
  },
  Decorator: function Decorator(decorator) {
    this.DecoratorBlock(decorator);
  },

  ContentStatement: function ContentStatement(content) {
    if (content.value) {
      this.opcode('appendContent', content.value);
    }
  },

  CommentStatement: function CommentStatement() {},

  SubExpression: function SubExpression(sexpr) {
    transformLiteralToPath(sexpr);
    var type = this.classifySexpr(sexpr);

    if (type === 'simple') {
      this.simpleSexpr(sexpr);
    } else if (type === 'helper') {
      this.helperSexpr(sexpr);
    } else {
      this.ambiguousSexpr(sexpr);
    }
  },
  ambiguousSexpr: function ambiguousSexpr(sexpr, program, inverse) {
    var path = sexpr.path,
        name = path.parts[0],
        isBlock = program != null || inverse != null;

    this.opcode('getContext', path.depth);

    this.opcode('pushProgram', program);
    this.opcode('pushProgram', inverse);

    path.strict = true;
    this.accept(path);

    this.opcode('invokeAmbiguous', name, isBlock);
  },

  simpleSexpr: function simpleSexpr(sexpr) {
    var path = sexpr.path;
    path.strict = true;
    this.accept(path);
    this.opcode('resolvePossibleLambda');
  },

  helperSexpr: function helperSexpr(sexpr, program, inverse) {
    var params = this.setupFullMustacheParams(sexpr, program, inverse),
        path = sexpr.path,
        name = path.parts[0];

    if (this.options.knownHelpers[name]) {
      this.opcode('invokeKnownHelper', params.length, name);
    } else if (this.options.knownHelpersOnly) {
      throw new _exception2['default']('You specified knownHelpersOnly, but used the unknown helper ' + name, sexpr);
    } else {
      path.strict = true;
      path.falsy = true;

      this.accept(path);
      this.opcode('invokeHelper', params.length, path.original, _ast2['default'].helpers.simpleId(path));
    }
  },

  PathExpression: function PathExpression(path) {
    this.addDepth(path.depth);
    this.opcode('getContext', path.depth);

    var name = path.parts[0],
        scoped = _ast2['default'].helpers.scopedId(path),
        blockParamId = !path.depth && !scoped && this.blockParamIndex(name);

    if (blockParamId) {
      this.opcode('lookupBlockParam', blockParamId, path.parts);
    } else if (!name) {
      // Context reference, i.e. `{{foo .}}` or `{{foo ..}}`
      this.opcode('pushContext');
    } else if (path.data) {
      this.options.data = true;
      this.opcode('lookupData', path.depth, path.parts, path.strict);
    } else {
      this.opcode('lookupOnContext', path.parts, path.falsy, path.strict, scoped);
    }
  },

  StringLiteral: function StringLiteral(string) {
    this.opcode('pushString', string.value);
  },

  NumberLiteral: function NumberLiteral(number) {
    this.opcode('pushLiteral', number.value);
  },

  BooleanLiteral: function BooleanLiteral(bool) {
    this.opcode('pushLiteral', bool.value);
  },

  UndefinedLiteral: function UndefinedLiteral() {
    this.opcode('pushLiteral', 'undefined');
  },

  NullLiteral: function NullLiteral() {
    this.opcode('pushLiteral', 'null');
  },

  Hash: function Hash(hash) {
    var pairs = hash.pairs,
        i = 0,
        l = pairs.length;

    this.opcode('pushHash');

    for (; i < l; i++) {
      this.pushParam(pairs[i].value);
    }
    while (i--) {
      this.opcode('assignToHash', pairs[i].key);
    }
    this.opcode('popHash');
  },

  // HELPERS
  opcode: function opcode(name) {
    this.opcodes.push({
      opcode: name,
      args: slice.call(arguments, 1),
      loc: this.sourceNode[0].loc
    });
  },

  addDepth: function addDepth(depth) {
    if (!depth) {
      return;
    }

    this.useDepths = true;
  },

  classifySexpr: function classifySexpr(sexpr) {
    var isSimple = _ast2['default'].helpers.simpleId(sexpr.path);

    var isBlockParam = isSimple && !!this.blockParamIndex(sexpr.path.parts[0]);

    // a mustache is an eligible helper if:
    // * its id is simple (a single part, not `this` or `..`)
    var isHelper = !isBlockParam && _ast2['default'].helpers.helperExpression(sexpr);

    // if a mustache is an eligible helper but not a definite
    // helper, it is ambiguous, and will be resolved in a later
    // pass or at runtime.
    var isEligible = !isBlockParam && (isHelper || isSimple);

    // if ambiguous, we can possibly resolve the ambiguity now
    // An eligible helper is one that does not have a complex path, i.e. `this.foo`, `../foo` etc.
    if (isEligible && !isHelper) {
      var _name = sexpr.path.parts[0],
          options = this.options;
      if (options.knownHelpers[_name]) {
        isHelper = true;
      } else if (options.knownHelpersOnly) {
        isEligible = false;
      }
    }

    if (isHelper) {
      return 'helper';
    } else if (isEligible) {
      return 'ambiguous';
    } else {
      return 'simple';
    }
  },

  pushParams: function pushParams(params) {
    for (var i = 0, l = params.length; i < l; i++) {
      this.pushParam(params[i]);
    }
  },

  pushParam: function pushParam(val) {
    var value = val.value != null ? val.value : val.original || '';

    if (this.stringParams) {
      if (value.replace) {
        value = value.replace(/^(\.?\.\/)*/g, '').replace(/\//g, '.');
      }

      if (val.depth) {
        this.addDepth(val.depth);
      }
      this.opcode('getContext', val.depth || 0);
      this.opcode('pushStringParam', value, val.type);

      if (val.type === 'SubExpression') {
        // SubExpressions get evaluated and passed in
        // in string params mode.
        this.accept(val);
      }
    } else {
      if (this.trackIds) {
        var blockParamIndex = undefined;
        if (val.parts && !_ast2['default'].helpers.scopedId(val) && !val.depth) {
          blockParamIndex = this.blockParamIndex(val.parts[0]);
        }
        if (blockParamIndex) {
          var blockParamChild = val.parts.slice(1).join('.');
          this.opcode('pushId', 'BlockParam', blockParamIndex, blockParamChild);
        } else {
          value = val.original || value;
          if (value.replace) {
            value = value.replace(/^this(?:\.|$)/, '').replace(/^\.\//, '').replace(/^\.$/, '');
          }

          this.opcode('pushId', val.type, value);
        }
      }
      this.accept(val);
    }
  },

  setupFullMustacheParams: function setupFullMustacheParams(sexpr, program, inverse, omitEmpty) {
    var params = sexpr.params;
    this.pushParams(params);

    this.opcode('pushProgram', program);
    this.opcode('pushProgram', inverse);

    if (sexpr.hash) {
      this.accept(sexpr.hash);
    } else {
      this.opcode('emptyHash', omitEmpty);
    }

    return params;
  },

  blockParamIndex: function blockParamIndex(name) {
    for (var depth = 0, len = this.options.blockParams.length; depth < len; depth++) {
      var blockParams = this.options.blockParams[depth],
          param = blockParams && utils$2.indexOf(blockParams, name);
      if (blockParams && param >= 0) {
        return [depth, param];
      }
    }
  }
};

function precompile(input, options, env) {
  if (input == null || typeof input !== 'string' && input.type !== 'Program') {
    throw new _exception2['default']('You must pass a string or Handlebars AST to Handlebars.precompile. You passed ' + input);
  }

  options = options || {};
  if (!('data' in options)) {
    options.data = true;
  }
  if (options.compat) {
    options.useDepths = true;
  }

  var ast = env.parse(input, options),
      environment = new env.Compiler().compile(ast, options);
  return new env.JavaScriptCompiler().compile(environment, options);
}

function compile(input, options, env) {
  if (options === undefined) options = {};

  if (input == null || typeof input !== 'string' && input.type !== 'Program') {
    throw new _exception2['default']('You must pass a string or Handlebars AST to Handlebars.compile. You passed ' + input);
  }

  options = utils$2.extend({}, options);
  if (!('data' in options)) {
    options.data = true;
  }
  if (options.compat) {
    options.useDepths = true;
  }

  var compiled = undefined;

  function compileInput() {
    var ast = env.parse(input, options),
        environment = new env.Compiler().compile(ast, options),
        templateSpec = new env.JavaScriptCompiler().compile(environment, options, undefined, true);
    return env.template(templateSpec);
  }

  // Template is only compiled on first use and cached after that point.
  function ret(context, execOptions) {
    if (!compiled) {
      compiled = compileInput();
    }
    return compiled.call(this, context, execOptions);
  }
  ret._setup = function (setupOptions) {
    if (!compiled) {
      compiled = compileInput();
    }
    return compiled._setup(setupOptions);
  };
  ret._child = function (i, data, blockParams, depths) {
    if (!compiled) {
      compiled = compileInput();
    }
    return compiled._child(i, data, blockParams, depths);
  };
  return ret;
}

function argEquals(a, b) {
  if (a === b) {
    return true;
  }

  if (utils$2.isArray(a) && utils$2.isArray(b) && a.length === b.length) {
    for (var i = 0; i < a.length; i++) {
      if (!argEquals(a[i], b[i])) {
        return false;
      }
    }
    return true;
  }
}

function transformLiteralToPath(sexpr) {
  if (!sexpr.path.parts) {
    var literal = sexpr.path;
    // Casting to string here to make false and 0 literal values play nicely with the rest
    // of the system.
    sexpr.path = {
      type: 'PathExpression',
      data: false,
      depth: 0,
      parts: [literal.original + ''],
      original: literal.original + '',
      loc: literal.loc
    };
  }
}

});

/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

var intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');

/**
 * Encode an integer in the range of 0 to 63 to a single base 64 digit.
 */
var encode = function (number) {
  if (0 <= number && number < intToCharMap.length) {
    return intToCharMap[number];
  }
  throw new TypeError("Must be between 0 and 63: " + number);
};

/**
 * Decode a single base 64 character code digit to an integer. Returns -1 on
 * failure.
 */
var decode = function (charCode) {
  var bigA = 65;     // 'A'
  var bigZ = 90;     // 'Z'

  var littleA = 97;  // 'a'
  var littleZ = 122; // 'z'

  var zero = 48;     // '0'
  var nine = 57;     // '9'

  var plus = 43;     // '+'
  var slash = 47;    // '/'

  var littleOffset = 26;
  var numberOffset = 52;

  // 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ
  if (bigA <= charCode && charCode <= bigZ) {
    return (charCode - bigA);
  }

  // 26 - 51: abcdefghijklmnopqrstuvwxyz
  if (littleA <= charCode && charCode <= littleZ) {
    return (charCode - littleA + littleOffset);
  }

  // 52 - 61: 0123456789
  if (zero <= charCode && charCode <= nine) {
    return (charCode - zero + numberOffset);
  }

  // 62: +
  if (charCode == plus) {
    return 62;
  }

  // 63: /
  if (charCode == slash) {
    return 63;
  }

  // Invalid base64 digit.
  return -1;
};

var base64 = {
	encode: encode,
	decode: decode
};

/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 *
 * Based on the Base 64 VLQ implementation in Closure Compiler:
 * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
 *
 * Copyright 2011 The Closure Compiler Authors. All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 *  * Neither the name of Google Inc. nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */



// A single base 64 digit can contain 6 bits of data. For the base 64 variable
// length quantities we use in the source map spec, the first bit is the sign,
// the next four bits are the actual value, and the 6th bit is the
// continuation bit. The continuation bit tells us whether there are more
// digits in this value following this digit.
//
//   Continuation
//   |    Sign
//   |    |
//   V    V
//   101011

var VLQ_BASE_SHIFT = 5;

// binary: 100000
var VLQ_BASE = 1 << VLQ_BASE_SHIFT;

// binary: 011111
var VLQ_BASE_MASK = VLQ_BASE - 1;

// binary: 100000
var VLQ_CONTINUATION_BIT = VLQ_BASE;

/**
 * Converts from a two-complement value to a value where the sign bit is
 * placed in the least significant bit.  For example, as decimals:
 *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
 *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
 */
function toVLQSigned(aValue) {
  return aValue < 0
    ? ((-aValue) << 1) + 1
    : (aValue << 1) + 0;
}

/**
 * Converts to a two-complement value from a value where the sign bit is
 * placed in the least significant bit.  For example, as decimals:
 *   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
 *   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
 */
function fromVLQSigned(aValue) {
  var isNegative = (aValue & 1) === 1;
  var shifted = aValue >> 1;
  return isNegative
    ? -shifted
    : shifted;
}

/**
 * Returns the base 64 VLQ encoded value.
 */
var encode$1 = function base64VLQ_encode(aValue) {
  var encoded = "";
  var digit;

  var vlq = toVLQSigned(aValue);

  do {
    digit = vlq & VLQ_BASE_MASK;
    vlq >>>= VLQ_BASE_SHIFT;
    if (vlq > 0) {
      // There are still more digits in this value, so we must make sure the
      // continuation bit is marked.
      digit |= VLQ_CONTINUATION_BIT;
    }
    encoded += base64.encode(digit);
  } while (vlq > 0);

  return encoded;
};

/**
 * Decodes the next base 64 VLQ value from the given string and returns the
 * value and the rest of the string via the out parameter.
 */
var decode$1 = function base64VLQ_decode(aStr, aIndex, aOutParam) {
  var strLen = aStr.length;
  var result = 0;
  var shift = 0;
  var continuation, digit;

  do {
    if (aIndex >= strLen) {
      throw new Error("Expected more digits in base 64 VLQ value.");
    }

    digit = base64.decode(aStr.charCodeAt(aIndex++));
    if (digit === -1) {
      throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
    }

    continuation = !!(digit & VLQ_CONTINUATION_BIT);
    digit &= VLQ_BASE_MASK;
    result = result + (digit << shift);
    shift += VLQ_BASE_SHIFT;
  } while (continuation);

  aOutParam.value = fromVLQSigned(result);
  aOutParam.rest = aIndex;
};

var base64Vlq = {
	encode: encode$1,
	decode: decode$1
};

var util = createCommonjsModule(function (module, exports) {
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

/**
 * This is a helper function for getting values from parameter/options
 * objects.
 *
 * @param args The object we are extracting values from
 * @param name The name of the property we are getting.
 * @param defaultValue An optional value to return if the property is missing
 * from the object. If this is not specified and the property is missing, an
 * error will be thrown.
 */
function getArg(aArgs, aName, aDefaultValue) {
  if (aName in aArgs) {
    return aArgs[aName];
  } else if (arguments.length === 3) {
    return aDefaultValue;
  } else {
    throw new Error('"' + aName + '" is a required argument.');
  }
}
exports.getArg = getArg;

var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
var dataUrlRegexp = /^data:.+\,.+$/;

function urlParse(aUrl) {
  var match = aUrl.match(urlRegexp);
  if (!match) {
    return null;
  }
  return {
    scheme: match[1],
    auth: match[2],
    host: match[3],
    port: match[4],
    path: match[5]
  };
}
exports.urlParse = urlParse;

function urlGenerate(aParsedUrl) {
  var url = '';
  if (aParsedUrl.scheme) {
    url += aParsedUrl.scheme + ':';
  }
  url += '//';
  if (aParsedUrl.auth) {
    url += aParsedUrl.auth + '@';
  }
  if (aParsedUrl.host) {
    url += aParsedUrl.host;
  }
  if (aParsedUrl.port) {
    url += ":" + aParsedUrl.port;
  }
  if (aParsedUrl.path) {
    url += aParsedUrl.path;
  }
  return url;
}
exports.urlGenerate = urlGenerate;

/**
 * Normalizes a path, or the path portion of a URL:
 *
 * - Replaces consecutive slashes with one slash.
 * - Removes unnecessary '.' parts.
 * - Removes unnecessary '<dir>/..' parts.
 *
 * Based on code in the Node.js 'path' core module.
 *
 * @param aPath The path or url to normalize.
 */
function normalize(aPath) {
  var path = aPath;
  var url = urlParse(aPath);
  if (url) {
    if (!url.path) {
      return aPath;
    }
    path = url.path;
  }
  var isAbsolute = exports.isAbsolute(path);

  var parts = path.split(/\/+/);
  for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
    part = parts[i];
    if (part === '.') {
      parts.splice(i, 1);
    } else if (part === '..') {
      up++;
    } else if (up > 0) {
      if (part === '') {
        // The first part is blank if the path is absolute. Trying to go
        // above the root is a no-op. Therefore we can remove all '..' parts
        // directly after the root.
        parts.splice(i + 1, up);
        up = 0;
      } else {
        parts.splice(i, 2);
        up--;
      }
    }
  }
  path = parts.join('/');

  if (path === '') {
    path = isAbsolute ? '/' : '.';
  }

  if (url) {
    url.path = path;
    return urlGenerate(url);
  }
  return path;
}
exports.normalize = normalize;

/**
 * Joins two paths/URLs.
 *
 * @param aRoot The root path or URL.
 * @param aPath The path or URL to be joined with the root.
 *
 * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
 *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
 *   first.
 * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
 *   is updated with the result and aRoot is returned. Otherwise the result
 *   is returned.
 *   - If aPath is absolute, the result is aPath.
 *   - Otherwise the two paths are joined with a slash.
 * - Joining for example 'http://' and 'www.example.com' is also supported.
 */
function join(aRoot, aPath) {
  if (aRoot === "") {
    aRoot = ".";
  }
  if (aPath === "") {
    aPath = ".";
  }
  var aPathUrl = urlParse(aPath);
  var aRootUrl = urlParse(aRoot);
  if (aRootUrl) {
    aRoot = aRootUrl.path || '/';
  }

  // `join(foo, '//www.example.org')`
  if (aPathUrl && !aPathUrl.scheme) {
    if (aRootUrl) {
      aPathUrl.scheme = aRootUrl.scheme;
    }
    return urlGenerate(aPathUrl);
  }

  if (aPathUrl || aPath.match(dataUrlRegexp)) {
    return aPath;
  }

  // `join('http://', 'www.example.com')`
  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
    aRootUrl.host = aPath;
    return urlGenerate(aRootUrl);
  }

  var joined = aPath.charAt(0) === '/'
    ? aPath
    : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);

  if (aRootUrl) {
    aRootUrl.path = joined;
    return urlGenerate(aRootUrl);
  }
  return joined;
}
exports.join = join;

exports.isAbsolute = function (aPath) {
  return aPath.charAt(0) === '/' || urlRegexp.test(aPath);
};

/**
 * Make a path relative to a URL or another path.
 *
 * @param aRoot The root path or URL.
 * @param aPath The path or URL to be made relative to aRoot.
 */
function relative(aRoot, aPath) {
  if (aRoot === "") {
    aRoot = ".";
  }

  aRoot = aRoot.replace(/\/$/, '');

  // It is possible for the path to be above the root. In this case, simply
  // checking whether the root is a prefix of the path won't work. Instead, we
  // need to remove components from the root one by one, until either we find
  // a prefix that fits, or we run out of components to remove.
  var level = 0;
  while (aPath.indexOf(aRoot + '/') !== 0) {
    var index = aRoot.lastIndexOf("/");
    if (index < 0) {
      return aPath;
    }

    // If the only part of the root that is left is the scheme (i.e. http://,
    // file:///, etc.), one or more slashes (/), or simply nothing at all, we
    // have exhausted all components, so the path is not relative to the root.
    aRoot = aRoot.slice(0, index);
    if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
      return aPath;
    }

    ++level;
  }

  // Make sure we add a "../" for each component we removed from the root.
  return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
}
exports.relative = relative;

var supportsNullProto = (function () {
  var obj = Object.create(null);
  return !('__proto__' in obj);
}());

function identity (s) {
  return s;
}

/**
 * Because behavior goes wacky when you set `__proto__` on objects, we
 * have to prefix all the strings in our set with an arbitrary character.
 *
 * See https://github.com/mozilla/source-map/pull/31 and
 * https://github.com/mozilla/source-map/issues/30
 *
 * @param String aStr
 */
function toSetString(aStr) {
  if (isProtoString(aStr)) {
    return '$' + aStr;
  }

  return aStr;
}
exports.toSetString = supportsNullProto ? identity : toSetString;

function fromSetString(aStr) {
  if (isProtoString(aStr)) {
    return aStr.slice(1);
  }

  return aStr;
}
exports.fromSetString = supportsNullProto ? identity : fromSetString;

function isProtoString(s) {
  if (!s) {
    return false;
  }

  var length = s.length;

  if (length < 9 /* "__proto__".length */) {
    return false;
  }

  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||
      s.charCodeAt(length - 2) !== 95  /* '_' */ ||
      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
      s.charCodeAt(length - 4) !== 116 /* 't' */ ||
      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
      s.charCodeAt(length - 8) !== 95  /* '_' */ ||
      s.charCodeAt(length - 9) !== 95  /* '_' */) {
    return false;
  }

  for (var i = length - 10; i >= 0; i--) {
    if (s.charCodeAt(i) !== 36 /* '$' */) {
      return false;
    }
  }

  return true;
}

/**
 * Comparator between two mappings where the original positions are compared.
 *
 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
 * mappings with the same original source/line/column, but different generated
 * line and column the same. Useful when searching for a mapping with a
 * stubbed out mapping.
 */
function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
  var cmp = strcmp(mappingA.source, mappingB.source);
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.originalLine - mappingB.originalLine;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.originalColumn - mappingB.originalColumn;
  if (cmp !== 0 || onlyCompareOriginal) {
    return cmp;
  }

  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.generatedLine - mappingB.generatedLine;
  if (cmp !== 0) {
    return cmp;
  }

  return strcmp(mappingA.name, mappingB.name);
}
exports.compareByOriginalPositions = compareByOriginalPositions;

/**
 * Comparator between two mappings with deflated source and name indices where
 * the generated positions are compared.
 *
 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
 * mappings with the same generated line and column, but different
 * source/name/original line and column the same. Useful when searching for a
 * mapping with a stubbed out mapping.
 */
function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
  var cmp = mappingA.generatedLine - mappingB.generatedLine;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
  if (cmp !== 0 || onlyCompareGenerated) {
    return cmp;
  }

  cmp = strcmp(mappingA.source, mappingB.source);
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.originalLine - mappingB.originalLine;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.originalColumn - mappingB.originalColumn;
  if (cmp !== 0) {
    return cmp;
  }

  return strcmp(mappingA.name, mappingB.name);
}
exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;

function strcmp(aStr1, aStr2) {
  if (aStr1 === aStr2) {
    return 0;
  }

  if (aStr1 === null) {
    return 1; // aStr2 !== null
  }

  if (aStr2 === null) {
    return -1; // aStr1 !== null
  }

  if (aStr1 > aStr2) {
    return 1;
  }

  return -1;
}

/**
 * Comparator between two mappings with inflated source and name strings where
 * the generated positions are compared.
 */
function compareByGeneratedPositionsInflated(mappingA, mappingB) {
  var cmp = mappingA.generatedLine - mappingB.generatedLine;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = strcmp(mappingA.source, mappingB.source);
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.originalLine - mappingB.originalLine;
  if (cmp !== 0) {
    return cmp;
  }

  cmp = mappingA.originalColumn - mappingB.originalColumn;
  if (cmp !== 0) {
    return cmp;
  }

  return strcmp(mappingA.name, mappingB.name);
}
exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;

/**
 * Strip any JSON XSSI avoidance prefix from the string (as documented
 * in the source maps specification), and then parse the string as
 * JSON.
 */
function parseSourceMapInput(str) {
  return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''));
}
exports.parseSourceMapInput = parseSourceMapInput;

/**
 * Compute the URL of a source given the the source root, the source's
 * URL, and the source map's URL.
 */
function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
  sourceURL = sourceURL || '';

  if (sourceRoot) {
    // This follows what Chrome does.
    if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {
      sourceRoot += '/';
    }
    // The spec says:
    //   Line 4: An optional source root, useful for relocating source
    //   files on a server or removing repeated values in the
    //   “sources” entry.  This value is prepended to the individual
    //   entries in the “source” field.
    sourceURL = sourceRoot + sourceURL;
  }

  // Historically, SourceMapConsumer did not take the sourceMapURL as
  // a parameter.  This mode is still somewhat supported, which is why
  // this code block is conditional.  However, it's preferable to pass
  // the source map URL to SourceMapConsumer, so that this function
  // can implement the source URL resolution algorithm as outlined in
  // the spec.  This block is basically the equivalent of:
  //    new URL(sourceURL, sourceMapURL).toString()
  // ... except it avoids using URL, which wasn't available in the
  // older releases of node still supported by this library.
  //
  // The spec says:
  //   If the sources are not absolute URLs after prepending of the
  //   “sourceRoot”, the sources are resolved relative to the
  //   SourceMap (like resolving script src in a html document).
  if (sourceMapURL) {
    var parsed = urlParse(sourceMapURL);
    if (!parsed) {
      throw new Error("sourceMapURL could not be parsed");
    }
    if (parsed.path) {
      // Strip the last path component, but keep the "/".
      var index = parsed.path.lastIndexOf('/');
      if (index >= 0) {
        parsed.path = parsed.path.substring(0, index + 1);
      }
    }
    sourceURL = join(urlGenerate(parsed), sourceURL);
  }

  return normalize(sourceURL);
}
exports.computeSourceURL = computeSourceURL;
});

/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */


var has = Object.prototype.hasOwnProperty;
var hasNativeMap = typeof Map !== "undefined";

/**
 * A data structure which is a combination of an array and a set. Adding a new
 * member is O(1), testing for membership is O(1), and finding the index of an
 * element is O(1). Removing elements from the set is not supported. Only
 * strings are supported for membership.
 */
function ArraySet() {
  this._array = [];
  this._set = hasNativeMap ? new Map() : Object.create(null);
}

/**
 * Static method for creating ArraySet instances from an existing array.
 */
ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
  var set = new ArraySet();
  for (var i = 0, len = aArray.length; i < len; i++) {
    set.add(aArray[i], aAllowDuplicates);
  }
  return set;
};

/**
 * Return how many unique items are in this ArraySet. If duplicates have been
 * added, than those do not count towards the size.
 *
 * @returns Number
 */
ArraySet.prototype.size = function ArraySet_size() {
  return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
};

/**
 * Add the given string to this set.
 *
 * @param String aStr
 */
ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
  var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
  var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
  var idx = this._array.length;
  if (!isDuplicate || aAllowDuplicates) {
    this._array.push(aStr);
  }
  if (!isDuplicate) {
    if (hasNativeMap) {
      this._set.set(aStr, idx);
    } else {
      this._set[sStr] = idx;
    }
  }
};

/**
 * Is the given string a member of this set?
 *
 * @param String aStr
 */
ArraySet.prototype.has = function ArraySet_has(aStr) {
  if (hasNativeMap) {
    return this._set.has(aStr);
  } else {
    var sStr = util.toSetString(aStr);
    return has.call(this._set, sStr);
  }
};

/**
 * What is the index of the given string in the array?
 *
 * @param String aStr
 */
ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
  if (hasNativeMap) {
    var idx = this._set.get(aStr);
    if (idx >= 0) {
        return idx;
    }
  } else {
    var sStr = util.toSetString(aStr);
    if (has.call(this._set, sStr)) {
      return this._set[sStr];
    }
  }

  throw new Error('"' + aStr + '" is not in the set.');
};

/**
 * What is the element at the given index?
 *
 * @param Number aIdx
 */
ArraySet.prototype.at = function ArraySet_at(aIdx) {
  if (aIdx >= 0 && aIdx < this._array.length) {
    return this._array[aIdx];
  }
  throw new Error('No element indexed by ' + aIdx);
};

/**
 * Returns the array representation of this set (which has the proper indices
 * indicated by indexOf). Note that this is a copy of the internal array used
 * for storing the members so that no one can mess with internal state.
 */
ArraySet.prototype.toArray = function ArraySet_toArray() {
  return this._array.slice();
};

var ArraySet_1 = ArraySet;

var arraySet = {
	ArraySet: ArraySet_1
};

/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2014 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */



/**
 * Determine whether mappingB is after mappingA with respect to generated
 * position.
 */
function generatedPositionAfter(mappingA, mappingB) {
  // Optimized for most common case
  var lineA = mappingA.generatedLine;
  var lineB = mappingB.generatedLine;
  var columnA = mappingA.generatedColumn;
  var columnB = mappingB.generatedColumn;
  return lineB > lineA || lineB == lineA && columnB >= columnA ||
         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
}

/**
 * A data structure to provide a sorted view of accumulated mappings in a
 * performance conscious manner. It trades a neglibable overhead in general
 * case for a large speedup in case of mappings being added in order.
 */
function MappingList() {
  this._array = [];
  this._sorted = true;
  // Serves as infimum
  this._last = {generatedLine: -1, generatedColumn: 0};
}

/**
 * Iterate through internal items. This method takes the same arguments that
 * `Array.prototype.forEach` takes.
 *
 * NOTE: The order of the mappings is NOT guaranteed.
 */
MappingList.prototype.unsortedForEach =
  function MappingList_forEach(aCallback, aThisArg) {
    this._array.forEach(aCallback, aThisArg);
  };

/**
 * Add the given source mapping.
 *
 * @param Object aMapping
 */
MappingList.prototype.add = function MappingList_add(aMapping) {
  if (generatedPositionAfter(this._last, aMapping)) {
    this._last = aMapping;
    this._array.push(aMapping);
  } else {
    this._sorted = false;
    this._array.push(aMapping);
  }
};

/**
 * Returns the flat, sorted array of mappings. The mappings are sorted by
 * generated position.
 *
 * WARNING: This method returns internal data without copying, for
 * performance. The return value must NOT be mutated, and should be treated as
 * an immutable borrow. If you want to take ownership, you must make your own
 * copy.
 */
MappingList.prototype.toArray = function MappingList_toArray() {
  if (!this._sorted) {
    this._array.sort(util.compareByGeneratedPositionsInflated);
    this._sorted = true;
  }
  return this._array;
};

var MappingList_1 = MappingList;

var mappingList = {
	MappingList: MappingList_1
};

/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */



var ArraySet$1 = arraySet.ArraySet;
var MappingList$1 = mappingList.MappingList;

/**
 * An instance of the SourceMapGenerator represents a source map which is
 * being built incrementally. You may pass an object with the following
 * properties:
 *
 *   - file: The filename of the generated source.
 *   - sourceRoot: A root for all relative URLs in this source map.
 */
function SourceMapGenerator(aArgs) {
  if (!aArgs) {
    aArgs = {};
  }
  this._file = util.getArg(aArgs, 'file', null);
  this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null);
  this._skipValidation = util.getArg(aArgs, 'skipValidation', false);
  this._sources = new ArraySet$1();
  this._names = new ArraySet$1();
  this._mappings = new MappingList$1();
  this._sourcesContents = null;
}

SourceMapGenerator.prototype._version = 3;

/**
 * Creates a new SourceMapGenerator based on a SourceMapConsumer
 *
 * @param aSourceMapConsumer The SourceMap.
 */
SourceMapGenerator.fromSourceMap =
  function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
    var sourceRoot = aSourceMapConsumer.sourceRoot;
    var generator = new SourceMapGenerator({
      file: aSourceMapConsumer.file,
      sourceRoot: sourceRoot
    });
    aSourceMapConsumer.eachMapping(function (mapping) {
      var newMapping = {
        generated: {
          line: mapping.generatedLine,
          column: mapping.generatedColumn
        }
      };

      if (mapping.source != null) {
        newMapping.source = mapping.source;
        if (sourceRoot != null) {
          newMapping.source = util.relative(sourceRoot, newMapping.source);
        }

        newMapping.original = {
          line: mapping.originalLine,
          column: mapping.originalColumn
        };

        if (mapping.name != null) {
          newMapping.name = mapping.name;
        }
      }

      generator.addMapping(newMapping);
    });
    aSourceMapConsumer.sources.forEach(function (sourceFile) {
      var sourceRelative = sourceFile;
      if (sourceRoot !== null) {
        sourceRelative = util.relative(sourceRoot, sourceFile);
      }

      if (!generator._sources.has(sourceRelative)) {
        generator._sources.add(sourceRelative);
      }

      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
      if (content != null) {
        generator.setSourceContent(sourceFile, content);
      }
    });
    return generator;
  };

/**
 * Add a single mapping from original source line and column to the generated
 * source's line and column for this source map being created. The mapping
 * object should have the following properties:
 *
 *   - generated: An object with the generated line and column positions.
 *   - original: An object with the original line and column positions.
 *   - source: The original source file (relative to the sourceRoot).
 *   - name: An optional original token name for this mapping.
 */
SourceMapGenerator.prototype.addMapping =
  function SourceMapGenerator_addMapping(aArgs) {
    var generated = util.getArg(aArgs, 'generated');
    var original = util.getArg(aArgs, 'original', null);
    var source = util.getArg(aArgs, 'source', null);
    var name = util.getArg(aArgs, 'name', null);

    if (!this._skipValidation) {
      this._validateMapping(generated, original, source, name);
    }

    if (source != null) {
      source = String(source);
      if (!this._sources.has(source)) {
        this._sources.add(source);
      }
    }

    if (name != null) {
      name = String(name);
      if (!this._names.has(name)) {
        this._names.add(name);
      }
    }

    this._mappings.add({
      generatedLine: generated.line,
      generatedColumn: generated.column,
      originalLine: original != null && original.line,
      originalColumn: original != null && original.column,
      source: source,
      name: name
    });
  };

/**
 * Set the source content for a source file.
 */
SourceMapGenerator.prototype.setSourceContent =
  function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
    var source = aSourceFile;
    if (this._sourceRoot != null) {
      source = util.relative(this._sourceRoot, source);
    }

    if (aSourceContent != null) {
      // Add the source content to the _sourcesContents map.
      // Create a new _sourcesContents map if the property is null.
      if (!this._sourcesContents) {
        this._sourcesContents = Object.create(null);
      }
      this._sourcesContents[util.toSetString(source)] = aSourceContent;
    } else if (this._sourcesContents) {
      // Remove the source file from the _sourcesContents map.
      // If the _sourcesContents map is empty, set the property to null.
      delete this._sourcesContents[util.toSetString(source)];
      if (Object.keys(this._sourcesContents).length === 0) {
        this._sourcesContents = null;
      }
    }
  };

/**
 * Applies the mappings of a sub-source-map for a specific source file to the
 * source map being generated. Each mapping to the supplied source file is
 * rewritten using the supplied source map. Note: The resolution for the
 * resulting mappings is the minimium of this map and the supplied map.
 *
 * @param aSourceMapConsumer The source map to be applied.
 * @param aSourceFile Optional. The filename of the source file.
 *        If omitted, SourceMapConsumer's file property will be used.
 * @param aSourceMapPath Optional. The dirname of the path to the source map
 *        to be applied. If relative, it is relative to the SourceMapConsumer.
 *        This parameter is needed when the two source maps aren't in the same
 *        directory, and the source map to be applied contains relative source
 *        paths. If so, those relative source paths need to be rewritten
 *        relative to the SourceMapGenerator.
 */
SourceMapGenerator.prototype.applySourceMap =
  function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
    var sourceFile = aSourceFile;
    // If aSourceFile is omitted, we will use the file property of the SourceMap
    if (aSourceFile == null) {
      if (aSourceMapConsumer.file == null) {
        throw new Error(
          'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
          'or the source map\'s "file" property. Both were omitted.'
        );
      }
      sourceFile = aSourceMapConsumer.file;
    }
    var sourceRoot = this._sourceRoot;
    // Make "sourceFile" relative if an absolute Url is passed.
    if (sourceRoot != null) {
      sourceFile = util.relative(sourceRoot, sourceFile);
    }
    // Applying the SourceMap can add and remove items from the sources and
    // the names array.
    var newSources = new ArraySet$1();
    var newNames = new ArraySet$1();

    // Find mappings for the "sourceFile"
    this._mappings.unsortedForEach(function (mapping) {
      if (mapping.source === sourceFile && mapping.originalLine != null) {
        // Check if it can be mapped by the source map, then update the mapping.
        var original = aSourceMapConsumer.originalPositionFor({
          line: mapping.originalLine,
          column: mapping.originalColumn
        });
        if (original.source != null) {
          // Copy mapping
          mapping.source = original.source;
          if (aSourceMapPath != null) {
            mapping.source = util.join(aSourceMapPath, mapping.source);
          }
          if (sourceRoot != null) {
            mapping.source = util.relative(sourceRoot, mapping.source);
          }
          mapping.originalLine = original.line;
          mapping.originalColumn = original.column;
          if (original.name != null) {
            mapping.name = original.name;
          }
        }
      }

      var source = mapping.source;
      if (source != null && !newSources.has(source)) {
        newSources.add(source);
      }

      var name = mapping.name;
      if (name != null && !newNames.has(name)) {
        newNames.add(name);
      }

    }, this);
    this._sources = newSources;
    this._names = newNames;

    // Copy sourcesContents of applied map.
    aSourceMapConsumer.sources.forEach(function (sourceFile) {
      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
      if (content != null) {
        if (aSourceMapPath != null) {
          sourceFile = util.join(aSourceMapPath, sourceFile);
        }
        if (sourceRoot != null) {
          sourceFile = util.relative(sourceRoot, sourceFile);
        }
        this.setSourceContent(sourceFile, content);
      }
    }, this);
  };

/**
 * A mapping can have one of the three levels of data:
 *
 *   1. Just the generated position.
 *   2. The Generated position, original position, and original source.
 *   3. Generated and original position, original source, as well as a name
 *      token.
 *
 * To maintain consistency, we validate that any new mapping being added falls
 * in to one of these categories.
 */
SourceMapGenerator.prototype._validateMapping =
  function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
                                              aName) {
    // When aOriginal is truthy but has empty values for .line and .column,
    // it is most likely a programmer error. In this case we throw a very
    // specific error message to try to guide them the right way.
    // For example: https://github.com/Polymer/polymer-bundler/pull/519
    if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
        throw new Error(
            'original.line and original.column are not numbers -- you probably meant to omit ' +
            'the original mapping entirely and only map the generated position. If so, pass ' +
            'null for the original mapping instead of an object with empty or null values.'
        );
    }

    if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
        && aGenerated.line > 0 && aGenerated.column >= 0
        && !aOriginal && !aSource && !aName) {
      // Case 1.
      return;
    }
    else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
             && aOriginal && 'line' in aOriginal && 'column' in aOriginal
             && aGenerated.line > 0 && aGenerated.column >= 0
             && aOriginal.line > 0 && aOriginal.column >= 0
             && aSource) {
      // Cases 2 and 3.
      return;
    }
    else {
      throw new Error('Invalid mapping: ' + JSON.stringify({
        generated: aGenerated,
        source: aSource,
        original: aOriginal,
        name: aName
      }));
    }
  };

/**
 * Serialize the accumulated mappings in to the stream of base 64 VLQs
 * specified by the source map format.
 */
SourceMapGenerator.prototype._serializeMappings =
  function SourceMapGenerator_serializeMappings() {
    var previousGeneratedColumn = 0;
    var previousGeneratedLine = 1;
    var previousOriginalColumn = 0;
    var previousOriginalLine = 0;
    var previousName = 0;
    var previousSource = 0;
    var result = '';
    var next;
    var mapping;
    var nameIdx;
    var sourceIdx;

    var mappings = this._mappings.toArray();
    for (var i = 0, len = mappings.length; i < len; i++) {
      mapping = mappings[i];
      next = '';

      if (mapping.generatedLine !== previousGeneratedLine) {
        previousGeneratedColumn = 0;
        while (mapping.generatedLine !== previousGeneratedLine) {
          next += ';';
          previousGeneratedLine++;
        }
      }
      else {
        if (i > 0) {
          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
            continue;
          }
          next += ',';
        }
      }

      next += base64Vlq.encode(mapping.generatedColumn
                                 - previousGeneratedColumn);
      previousGeneratedColumn = mapping.generatedColumn;

      if (mapping.source != null) {
        sourceIdx = this._sources.indexOf(mapping.source);
        next += base64Vlq.encode(sourceIdx - previousSource);
        previousSource = sourceIdx;

        // lines are stored 0-based in SourceMap spec version 3
        next += base64Vlq.encode(mapping.originalLine - 1
                                   - previousOriginalLine);
        previousOriginalLine = mapping.originalLine - 1;

        next += base64Vlq.encode(mapping.originalColumn
                                   - previousOriginalColumn);
        previousOriginalColumn = mapping.originalColumn;

        if (mapping.name != null) {
          nameIdx = this._names.indexOf(mapping.name);
          next += base64Vlq.encode(nameIdx - previousName);
          previousName = nameIdx;
        }
      }

      result += next;
    }

    return result;
  };

SourceMapGenerator.prototype._generateSourcesContent =
  function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
    return aSources.map(function (source) {
      if (!this._sourcesContents) {
        return null;
      }
      if (aSourceRoot != null) {
        source = util.relative(aSourceRoot, source);
      }
      var key = util.toSetString(source);
      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
        ? this._sourcesContents[key]
        : null;
    }, this);
  };

/**
 * Externalize the source map.
 */
SourceMapGenerator.prototype.toJSON =
  function SourceMapGenerator_toJSON() {
    var map = {
      version: this._version,
      sources: this._sources.toArray(),
      names: this._names.toArray(),
      mappings: this._serializeMappings()
    };
    if (this._file != null) {
      map.file = this._file;
    }
    if (this._sourceRoot != null) {
      map.sourceRoot = this._sourceRoot;
    }
    if (this._sourcesContents) {
      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
    }

    return map;
  };

/**
 * Render the source map being generated to a string.
 */
SourceMapGenerator.prototype.toString =
  function SourceMapGenerator_toString() {
    return JSON.stringify(this.toJSON());
  };

var SourceMapGenerator_1 = SourceMapGenerator;

var sourceMapGenerator = {
	SourceMapGenerator: SourceMapGenerator_1
};

var binarySearch = createCommonjsModule(function (module, exports) {
/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

exports.GREATEST_LOWER_BOUND = 1;
exports.LEAST_UPPER_BOUND = 2;

/**
 * Recursive implementation of binary search.
 *
 * @param aLow Indices here and lower do not contain the needle.
 * @param aHigh Indices here and higher do not contain the needle.
 * @param aNeedle The element being searched for.
 * @param aHaystack The non-empty array being searched.
 * @param aCompare Function which takes two elements and returns -1, 0, or 1.
 * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
 *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
 *     closest element that is smaller than or greater than the one we are
 *     searching for, respectively, if the exact element cannot be found.
 */
function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
  // This function terminates when one of the following is true:
  //
  //   1. We find the exact element we are looking for.
  //
  //   2. We did not find the exact element, but we can return the index of
  //      the next-closest element.
  //
  //   3. We did not find the exact element, and there is no next-closest
  //      element than the one we are searching for, so we return -1.
  var mid = Math.floor((aHigh - aLow) / 2) + aLow;
  var cmp = aCompare(aNeedle, aHaystack[mid], true);
  if (cmp === 0) {
    // Found the element we are looking for.
    return mid;
  }
  else if (cmp > 0) {
    // Our needle is greater than aHaystack[mid].
    if (aHigh - mid > 1) {
      // The element is in the upper half.
      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
    }

    // The exact needle element was not found in this haystack. Determine if
    // we are in termination case (3) or (2) and return the appropriate thing.
    if (aBias == exports.LEAST_UPPER_BOUND) {
      return aHigh < aHaystack.length ? aHigh : -1;
    } else {
      return mid;
    }
  }
  else {
    // Our needle is less than aHaystack[mid].
    if (mid - aLow > 1) {
      // The element is in the lower half.
      return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
    }

    // we are in termination case (3) or (2) and return the appropriate thing.
    if (aBias == exports.LEAST_UPPER_BOUND) {
      return mid;
    } else {
      return aLow < 0 ? -1 : aLow;
    }
  }
}

/**
 * This is an implementation of binary search which will always try and return
 * the index of the closest element if there is no exact hit. This is because
 * mappings between original and generated line/col pairs are single points,
 * and there is an implicit region between each of them, so a miss just means
 * that you aren't on the very start of a region.
 *
 * @param aNeedle The element you are looking for.
 * @param aHaystack The array that is being searched.
 * @param aCompare A function which takes the needle and an element in the
 *     array and returns -1, 0, or 1 depending on whether the needle is less
 *     than, equal to, or greater than the element, respectively.
 * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
 *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
 *     closest element that is smaller than or greater than the one we are
 *     searching for, respectively, if the exact element cannot be found.
 *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
 */
exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
  if (aHaystack.length === 0) {
    return -1;
  }

  var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,
                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);
  if (index < 0) {
    return -1;
  }

  // We have found either the exact element, or the next-closest element than
  // the one we are searching for. However, there may be more than one such
  // element. Make sure we always return the smallest of these.
  while (index - 1 >= 0) {
    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
      break;
    }
    --index;
  }

  return index;
};
});

/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

// It turns out that some (most?) JavaScript engines don't self-host
// `Array.prototype.sort`. This makes sense because C++ will likely remain
// faster than JS when doing raw CPU-intensive sorting. However, when using a
// custom comparator function, calling back and forth between the VM's C++ and
// JIT'd JS is rather slow *and* loses JIT type information, resulting in
// worse generated code for the comparator function than would be optimal. In
// fact, when sorting with a comparator, these costs outweigh the benefits of
// sorting in C++. By using our own JS-implemented Quick Sort (below), we get
// a ~3500ms mean speed-up in `bench/bench.html`.

/**
 * Swap the elements indexed by `x` and `y` in the array `ary`.
 *
 * @param {Array} ary
 *        The array.
 * @param {Number} x
 *        The index of the first item.
 * @param {Number} y
 *        The index of the second item.
 */
function swap(ary, x, y) {
  var temp = ary[x];
  ary[x] = ary[y];
  ary[y] = temp;
}

/**
 * Returns a random integer within the range `low .. high` inclusive.
 *
 * @param {Number} low
 *        The lower bound on the range.
 * @param {Number} high
 *        The upper bound on the range.
 */
function randomIntInRange(low, high) {
  return Math.round(low + (Math.random() * (high - low)));
}

/**
 * The Quick Sort algorithm.
 *
 * @param {Array} ary
 *        An array to sort.
 * @param {function} comparator
 *        Function to use to compare two items.
 * @param {Number} p
 *        Start index of the array
 * @param {Number} r
 *        End index of the array
 */
function doQuickSort(ary, comparator, p, r) {
  // If our lower bound is less than our upper bound, we (1) partition the
  // array into two pieces and (2) recurse on each half. If it is not, this is
  // the empty array and our base case.

  if (p < r) {
    // (1) Partitioning.
    //
    // The partitioning chooses a pivot between `p` and `r` and moves all
    // elements that are less than or equal to the pivot to the before it, and
    // all the elements that are greater than it after it. The effect is that
    // once partition is done, the pivot is in the exact place it will be when
    // the array is put in sorted order, and it will not need to be moved
    // again. This runs in O(n) time.

    // Always choose a random pivot so that an input array which is reverse
    // sorted does not cause O(n^2) running time.
    var pivotIndex = randomIntInRange(p, r);
    var i = p - 1;

    swap(ary, pivotIndex, r);
    var pivot = ary[r];

    // Immediately after `j` is incremented in this loop, the following hold
    // true:
    //
    //   * Every element in `ary[p .. i]` is less than or equal to the pivot.
    //
    //   * Every element in `ary[i+1 .. j-1]` is greater than the pivot.
    for (var j = p; j < r; j++) {
      if (comparator(ary[j], pivot) <= 0) {
        i += 1;
        swap(ary, i, j);
      }
    }

    swap(ary, i + 1, j);
    var q = i + 1;

    // (2) Recurse on each half.

    doQuickSort(ary, comparator, p, q - 1);
    doQuickSort(ary, comparator, q + 1, r);
  }
}

/**
 * Sort the given array in-place with the given comparator function.
 *
 * @param {Array} ary
 *        An array to sort.
 * @param {function} comparator
 *        Function to use to compare two items.
 */
var quickSort_1 = function (ary, comparator) {
  doQuickSort(ary, comparator, 0, ary.length - 1);
};

var quickSort = {
	quickSort: quickSort_1
};

/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */



var ArraySet$2 = arraySet.ArraySet;

var quickSort$1 = quickSort.quickSort;

function SourceMapConsumer(aSourceMap, aSourceMapURL) {
  var sourceMap = aSourceMap;
  if (typeof aSourceMap === 'string') {
    sourceMap = util.parseSourceMapInput(aSourceMap);
  }

  return sourceMap.sections != null
    ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL)
    : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
}

SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
  return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
};

/**
 * The version of the source mapping spec that we are consuming.
 */
SourceMapConsumer.prototype._version = 3;

// `__generatedMappings` and `__originalMappings` are arrays that hold the
// parsed mapping coordinates from the source map's "mappings" attribute. They
// are lazily instantiated, accessed via the `_generatedMappings` and
// `_originalMappings` getters respectively, and we only parse the mappings
// and create these arrays once queried for a source location. We jump through
// these hoops because there can be many thousands of mappings, and parsing
// them is expensive, so we only want to do it if we must.
//
// Each object in the arrays is of the form:
//
//     {
//       generatedLine: The line number in the generated code,
//       generatedColumn: The column number in the generated code,
//       source: The path to the original source file that generated this
//               chunk of code,
//       originalLine: The line number in the original source that
//                     corresponds to this chunk of generated code,
//       originalColumn: The column number in the original source that
//                       corresponds to this chunk of generated code,
//       name: The name of the original symbol which generated this chunk of
//             code.
//     }
//
// All properties except for `generatedLine` and `generatedColumn` can be
// `null`.
//
// `_generatedMappings` is ordered by the generated positions.
//
// `_originalMappings` is ordered by the original positions.

SourceMapConsumer.prototype.__generatedMappings = null;
Object.defineProperty(SourceMapConsumer.prototype, '_generatedMappings', {
  configurable: true,
  enumerable: true,
  get: function () {
    if (!this.__generatedMappings) {
      this._parseMappings(this._mappings, this.sourceRoot);
    }

    return this.__generatedMappings;
  }
});

SourceMapConsumer.prototype.__originalMappings = null;
Object.defineProperty(SourceMapConsumer.prototype, '_originalMappings', {
  configurable: true,
  enumerable: true,
  get: function () {
    if (!this.__originalMappings) {
      this._parseMappings(this._mappings, this.sourceRoot);
    }

    return this.__originalMappings;
  }
});

SourceMapConsumer.prototype._charIsMappingSeparator =
  function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
    var c = aStr.charAt(index);
    return c === ";" || c === ",";
  };

/**
 * Parse the mappings in a string in to a data structure which we can easily
 * query (the ordered arrays in the `this.__generatedMappings` and
 * `this.__originalMappings` properties).
 */
SourceMapConsumer.prototype._parseMappings =
  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
    throw new Error("Subclasses must implement _parseMappings");
  };

SourceMapConsumer.GENERATED_ORDER = 1;
SourceMapConsumer.ORIGINAL_ORDER = 2;

SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
SourceMapConsumer.LEAST_UPPER_BOUND = 2;

/**
 * Iterate over each mapping between an original source/line/column and a
 * generated line/column in this source map.
 *
 * @param Function aCallback
 *        The function that is called with each mapping.
 * @param Object aContext
 *        Optional. If specified, this object will be the value of `this` every
 *        time that `aCallback` is called.
 * @param aOrder
 *        Either `SourceMapConsumer.GENERATED_ORDER` or
 *        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
 *        iterate over the mappings sorted by the generated file's line/column
 *        order or the original's source/line/column order, respectively. Defaults to
 *        `SourceMapConsumer.GENERATED_ORDER`.
 */
SourceMapConsumer.prototype.eachMapping =
  function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
    var context = aContext || null;
    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;

    var mappings;
    switch (order) {
    case SourceMapConsumer.GENERATED_ORDER:
      mappings = this._generatedMappings;
      break;
    case SourceMapConsumer.ORIGINAL_ORDER:
      mappings = this._originalMappings;
      break;
    default:
      throw new Error("Unknown order of iteration.");
    }

    var sourceRoot = this.sourceRoot;
    mappings.map(function (mapping) {
      var source = mapping.source === null ? null : this._sources.at(mapping.source);
      source = util.computeSourceURL(sourceRoot, source, this._sourceMapURL);
      return {
        source: source,
        generatedLine: mapping.generatedLine,
        generatedColumn: mapping.generatedColumn,
        originalLine: mapping.originalLine,
        originalColumn: mapping.originalColumn,
        name: mapping.name === null ? null : this._names.at(mapping.name)
      };
    }, this).forEach(aCallback, context);
  };

/**
 * Returns all generated line and column information for the original source,
 * line, and column provided. If no column is provided, returns all mappings
 * corresponding to a either the line we are searching for or the next
 * closest line that has any mappings. Otherwise, returns all mappings
 * corresponding to the given line and either the column we are searching for
 * or the next closest column that has any offsets.
 *
 * The only argument is an object with the following properties:
 *
 *   - source: The filename of the original source.
 *   - line: The line number in the original source.  The line number is 1-based.
 *   - column: Optional. the column number in the original source.
 *    The column number is 0-based.
 *
 * and an array of objects is returned, each with the following properties:
 *
 *   - line: The line number in the generated source, or null.  The
 *    line number is 1-based.
 *   - column: The column number in the generated source, or null.
 *    The column number is 0-based.
 */
SourceMapConsumer.prototype.allGeneratedPositionsFor =
  function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
    var line = util.getArg(aArgs, 'line');

    // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
    // returns the index of the closest mapping less than the needle. By
    // setting needle.originalColumn to 0, we thus find the last mapping for
    // the given line, provided such a mapping exists.
    var needle = {
      source: util.getArg(aArgs, 'source'),
      originalLine: line,
      originalColumn: util.getArg(aArgs, 'column', 0)
    };

    needle.source = this._findSourceIndex(needle.source);
    if (needle.source < 0) {
      return [];
    }

    var mappings = [];

    var index = this._findMapping(needle,
                                  this._originalMappings,
                                  "originalLine",
                                  "originalColumn",
                                  util.compareByOriginalPositions,
                                  binarySearch.LEAST_UPPER_BOUND);
    if (index >= 0) {
      var mapping = this._originalMappings[index];

      if (aArgs.column === undefined) {
        var originalLine = mapping.originalLine;

        // Iterate until either we run out of mappings, or we run into
        // a mapping for a different line than the one we found. Since
        // mappings are sorted, this is guaranteed to find all mappings for
        // the line we found.
        while (mapping && mapping.originalLine === originalLine) {
          mappings.push({
            line: util.getArg(mapping, 'generatedLine', null),
            column: util.getArg(mapping, 'generatedColumn', null),
            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
          });

          mapping = this._originalMappings[++index];
        }
      } else {
        var originalColumn = mapping.originalColumn;

        // Iterate until either we run out of mappings, or we run into
        // a mapping for a different line than the one we were searching for.
        // Since mappings are sorted, this is guaranteed to find all mappings for
        // the line we are searching for.
        while (mapping &&
               mapping.originalLine === line &&
               mapping.originalColumn == originalColumn) {
          mappings.push({
            line: util.getArg(mapping, 'generatedLine', null),
            column: util.getArg(mapping, 'generatedColumn', null),
            lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
          });

          mapping = this._originalMappings[++index];
        }
      }
    }

    return mappings;
  };

var SourceMapConsumer_1 = SourceMapConsumer;

/**
 * A BasicSourceMapConsumer instance represents a parsed source map which we can
 * query for information about the original file positions by giving it a file
 * position in the generated source.
 *
 * The first parameter is the raw source map (either as a JSON string, or
 * already parsed to an object). According to the spec, source maps have the
 * following attributes:
 *
 *   - version: Which version of the source map spec this map is following.
 *   - sources: An array of URLs to the original source files.
 *   - names: An array of identifiers which can be referrenced by individual mappings.
 *   - sourceRoot: Optional. The URL root from which all sources are relative.
 *   - sourcesContent: Optional. An array of contents of the original source files.
 *   - mappings: A string of base64 VLQs which contain the actual mappings.
 *   - file: Optional. The generated file this source map is associated with.
 *
 * Here is an example source map, taken from the source map spec[0]:
 *
 *     {
 *       version : 3,
 *       file: "out.js",
 *       sourceRoot : "",
 *       sources: ["foo.js", "bar.js"],
 *       names: ["src", "maps", "are", "fun"],
 *       mappings: "AA,AB;;ABCDE;"
 *     }
 *
 * The second parameter, if given, is a string whose value is the URL
 * at which the source map was found.  This URL is used to compute the
 * sources array.
 *
 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
 */
function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
  var sourceMap = aSourceMap;
  if (typeof aSourceMap === 'string') {
    sourceMap = util.parseSourceMapInput(aSourceMap);
  }

  var version = util.getArg(sourceMap, 'version');
  var sources = util.getArg(sourceMap, 'sources');
  // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
  // requires the array) to play nice here.
  var names = util.getArg(sourceMap, 'names', []);
  var sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
  var sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
  var mappings = util.getArg(sourceMap, 'mappings');
  var file = util.getArg(sourceMap, 'file', null);

  // Once again, Sass deviates from the spec and supplies the version as a
  // string rather than a number, so we use loose equality checking here.
  if (version != this._version) {
    throw new Error('Unsupported version: ' + version);
  }

  if (sourceRoot) {
    sourceRoot = util.normalize(sourceRoot);
  }

  sources = sources
    .map(String)
    // Some source maps produce relative source paths like "./foo.js" instead of
    // "foo.js".  Normalize these first so that future comparisons will succeed.
    // See bugzil.la/1090768.
    .map(util.normalize)
    // Always ensure that absolute sources are internally stored relative to
    // the source root, if the source root is absolute. Not doing this would
    // be particularly problematic when the source root is a prefix of the
    // source (valid, but why??). See github issue #199 and bugzil.la/1188982.
    .map(function (source) {
      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)
        ? util.relative(sourceRoot, source)
        : source;
    });

  // Pass `true` below to allow duplicate names and sources. While source maps
  // are intended to be compressed and deduplicated, the TypeScript compiler
  // sometimes generates source maps with duplicates in them. See Github issue
  // #72 and bugzil.la/889492.
  this._names = ArraySet$2.fromArray(names.map(String), true);
  this._sources = ArraySet$2.fromArray(sources, true);

  this._absoluteSources = this._sources.toArray().map(function (s) {
    return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
  });

  this.sourceRoot = sourceRoot;
  this.sourcesContent = sourcesContent;
  this._mappings = mappings;
  this._sourceMapURL = aSourceMapURL;
  this.file = file;
}

BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;

/**
 * Utility function to find the index of a source.  Returns -1 if not
 * found.
 */
BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
  var relativeSource = aSource;
  if (this.sourceRoot != null) {
    relativeSource = util.relative(this.sourceRoot, relativeSource);
  }

  if (this._sources.has(relativeSource)) {
    return this._sources.indexOf(relativeSource);
  }

  // Maybe aSource is an absolute URL as returned by |sources|.  In
  // this case we can't simply undo the transform.
  var i;
  for (i = 0; i < this._absoluteSources.length; ++i) {
    if (this._absoluteSources[i] == aSource) {
      return i;
    }
  }

  return -1;
};

/**
 * Create a BasicSourceMapConsumer from a SourceMapGenerator.
 *
 * @param SourceMapGenerator aSourceMap
 *        The source map that will be consumed.
 * @param String aSourceMapURL
 *        The URL at which the source map can be found (optional)
 * @returns BasicSourceMapConsumer
 */
BasicSourceMapConsumer.fromSourceMap =
  function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
    var smc = Object.create(BasicSourceMapConsumer.prototype);

    var names = smc._names = ArraySet$2.fromArray(aSourceMap._names.toArray(), true);
    var sources = smc._sources = ArraySet$2.fromArray(aSourceMap._sources.toArray(), true);
    smc.sourceRoot = aSourceMap._sourceRoot;
    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
                                                            smc.sourceRoot);
    smc.file = aSourceMap._file;
    smc._sourceMapURL = aSourceMapURL;
    smc._absoluteSources = smc._sources.toArray().map(function (s) {
      return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
    });

    // Because we are modifying the entries (by converting string sources and
    // names to indices into the sources and names ArraySets), we have to make
    // a copy of the entry or else bad things happen. Shared mutable state
    // strikes again! See github issue #191.

    var generatedMappings = aSourceMap._mappings.toArray().slice();
    var destGeneratedMappings = smc.__generatedMappings = [];
    var destOriginalMappings = smc.__originalMappings = [];

    for (var i = 0, length = generatedMappings.length; i < length; i++) {
      var srcMapping = generatedMappings[i];
      var destMapping = new Mapping;
      destMapping.generatedLine = srcMapping.generatedLine;
      destMapping.generatedColumn = srcMapping.generatedColumn;

      if (srcMapping.source) {
        destMapping.source = sources.indexOf(srcMapping.source);
        destMapping.originalLine = srcMapping.originalLine;
        destMapping.originalColumn = srcMapping.originalColumn;

        if (srcMapping.name) {
          destMapping.name = names.indexOf(srcMapping.name);
        }

        destOriginalMappings.push(destMapping);
      }

      destGeneratedMappings.push(destMapping);
    }

    quickSort$1(smc.__originalMappings, util.compareByOriginalPositions);

    return smc;
  };

/**
 * The version of the source mapping spec that we are consuming.
 */
BasicSourceMapConsumer.prototype._version = 3;

/**
 * The list of original sources.
 */
Object.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {
  get: function () {
    return this._absoluteSources.slice();
  }
});

/**
 * Provide the JIT with a nice shape / hidden class.
 */
function Mapping() {
  this.generatedLine = 0;
  this.generatedColumn = 0;
  this.source = null;
  this.originalLine = null;
  this.originalColumn = null;
  this.name = null;
}

/**
 * Parse the mappings in a string in to a data structure which we can easily
 * query (the ordered arrays in the `this.__generatedMappings` and
 * `this.__originalMappings` properties).
 */
BasicSourceMapConsumer.prototype._parseMappings =
  function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
    var generatedLine = 1;
    var previousGeneratedColumn = 0;
    var previousOriginalLine = 0;
    var previousOriginalColumn = 0;
    var previousSource = 0;
    var previousName = 0;
    var length = aStr.length;
    var index = 0;
    var cachedSegments = {};
    var temp = {};
    var originalMappings = [];
    var generatedMappings = [];
    var mapping, str, segment, end, value;

    while (index < length) {
      if (aStr.charAt(index) === ';') {
        generatedLine++;
        index++;
        previousGeneratedColumn = 0;
      }
      else if (aStr.charAt(index) === ',') {
        index++;
      }
      else {
        mapping = new Mapping();
        mapping.generatedLine = generatedLine;

        // Because each offset is encoded relative to the previous one,
        // many segments often have the same encoding. We can exploit this
        // fact by caching the parsed variable length fields of each segment,
        // allowing us to avoid a second parse if we encounter the same
        // segment again.
        for (end = index; end < length; end++) {
          if (this._charIsMappingSeparator(aStr, end)) {
            break;
          }
        }
        str = aStr.slice(index, end);

        segment = cachedSegments[str];
        if (segment) {
          index += str.length;
        } else {
          segment = [];
          while (index < end) {
            base64Vlq.decode(aStr, index, temp);
            value = temp.value;
            index = temp.rest;
            segment.push(value);
          }

          if (segment.length === 2) {
            throw new Error('Found a source, but no line and column');
          }

          if (segment.length === 3) {
            throw new Error('Found a source and line, but no column');
          }

          cachedSegments[str] = segment;
        }

        // Generated column.
        mapping.generatedColumn = previousGeneratedColumn + segment[0];
        previousGeneratedColumn = mapping.generatedColumn;

        if (segment.length > 1) {
          // Original source.
          mapping.source = previousSource + segment[1];
          previousSource += segment[1];

          // Original line.
          mapping.originalLine = previousOriginalLine + segment[2];
          previousOriginalLine = mapping.originalLine;
          // Lines are stored 0-based
          mapping.originalLine += 1;

          // Original column.
          mapping.originalColumn = previousOriginalColumn + segment[3];
          previousOriginalColumn = mapping.originalColumn;

          if (segment.length > 4) {
            // Original name.
            mapping.name = previousName + segment[4];
            previousName += segment[4];
          }
        }

        generatedMappings.push(mapping);
        if (typeof mapping.originalLine === 'number') {
          originalMappings.push(mapping);
        }
      }
    }

    quickSort$1(generatedMappings, util.compareByGeneratedPositionsDeflated);
    this.__generatedMappings = generatedMappings;

    quickSort$1(originalMappings, util.compareByOriginalPositions);
    this.__originalMappings = originalMappings;
  };

/**
 * Find the mapping that best matches the hypothetical "needle" mapping that
 * we are searching for in the given "haystack" of mappings.
 */
BasicSourceMapConsumer.prototype._findMapping =
  function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
                                         aColumnName, aComparator, aBias) {
    // To return the position we are searching for, we must first find the
    // mapping for the given position and then return the opposite position it
    // points to. Because the mappings are sorted, we can use binary search to
    // find the best mapping.

    if (aNeedle[aLineName] <= 0) {
      throw new TypeError('Line must be greater than or equal to 1, got '
                          + aNeedle[aLineName]);
    }
    if (aNeedle[aColumnName] < 0) {
      throw new TypeError('Column must be greater than or equal to 0, got '
                          + aNeedle[aColumnName]);
    }

    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
  };

/**
 * Compute the last column for each generated mapping. The last column is
 * inclusive.
 */
BasicSourceMapConsumer.prototype.computeColumnSpans =
  function SourceMapConsumer_computeColumnSpans() {
    for (var index = 0; index < this._generatedMappings.length; ++index) {
      var mapping = this._generatedMappings[index];

      // Mappings do not contain a field for the last generated columnt. We
      // can come up with an optimistic estimate, however, by assuming that
      // mappings are contiguous (i.e. given two consecutive mappings, the
      // first mapping ends where the second one starts).
      if (index + 1 < this._generatedMappings.length) {
        var nextMapping = this._generatedMappings[index + 1];

        if (mapping.generatedLine === nextMapping.generatedLine) {
          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
          continue;
        }
      }

      // The last mapping for each line spans the entire line.
      mapping.lastGeneratedColumn = Infinity;
    }
  };

/**
 * Returns the original source, line, and column information for the generated
 * source's line and column positions provided. The only argument is an object
 * with the following properties:
 *
 *   - line: The line number in the generated source.  The line number
 *     is 1-based.
 *   - column: The column number in the generated source.  The column
 *     number is 0-based.
 *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
 *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
 *     closest element that is smaller than or greater than the one we are
 *     searching for, respectively, if the exact element cannot be found.
 *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
 *
 * and an object is returned with the following properties:
 *
 *   - source: The original source file, or null.
 *   - line: The line number in the original source, or null.  The
 *     line number is 1-based.
 *   - column: The column number in the original source, or null.  The
 *     column number is 0-based.
 *   - name: The original identifier, or null.
 */
BasicSourceMapConsumer.prototype.originalPositionFor =
  function SourceMapConsumer_originalPositionFor(aArgs) {
    var needle = {
      generatedLine: util.getArg(aArgs, 'line'),
      generatedColumn: util.getArg(aArgs, 'column')
    };

    var index = this._findMapping(
      needle,
      this._generatedMappings,
      "generatedLine",
      "generatedColumn",
      util.compareByGeneratedPositionsDeflated,
      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
    );

    if (index >= 0) {
      var mapping = this._generatedMappings[index];

      if (mapping.generatedLine === needle.generatedLine) {
        var source = util.getArg(mapping, 'source', null);
        if (source !== null) {
          source = this._sources.at(source);
          source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
        }
        var name = util.getArg(mapping, 'name', null);
        if (name !== null) {
          name = this._names.at(name);
        }
        return {
          source: source,
          line: util.getArg(mapping, 'originalLine', null),
          column: util.getArg(mapping, 'originalColumn', null),
          name: name
        };
      }
    }

    return {
      source: null,
      line: null,
      column: null,
      name: null
    };
  };

/**
 * Return true if we have the source content for every source in the source
 * map, false otherwise.
 */
BasicSourceMapConsumer.prototype.hasContentsOfAllSources =
  function BasicSourceMapConsumer_hasContentsOfAllSources() {
    if (!this.sourcesContent) {
      return false;
    }
    return this.sourcesContent.length >= this._sources.size() &&
      !this.sourcesContent.some(function (sc) { return sc == null; });
  };

/**
 * Returns the original source content. The only argument is the url of the
 * original source file. Returns null if no original source content is
 * available.
 */
BasicSourceMapConsumer.prototype.sourceContentFor =
  function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
    if (!this.sourcesContent) {
      return null;
    }

    var index = this._findSourceIndex(aSource);
    if (index >= 0) {
      return this.sourcesContent[index];
    }

    var relativeSource = aSource;
    if (this.sourceRoot != null) {
      relativeSource = util.relative(this.sourceRoot, relativeSource);
    }

    var url;
    if (this.sourceRoot != null
        && (url = util.urlParse(this.sourceRoot))) {
      // XXX: file:// URIs and absolute paths lead to unexpected behavior for
      // many users. We can help them out when they expect file:// URIs to
      // behave like it would if they were running a local HTTP server. See
      // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
      var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
      if (url.scheme == "file"
          && this._sources.has(fileUriAbsPath)) {
        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
      }

      if ((!url.path || url.path == "/")
          && this._sources.has("/" + relativeSource)) {
        return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
      }
    }

    // This function is used recursively from
    // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
    // don't want to throw if we can't find the source - we just want to
    // return null, so we provide a flag to exit gracefully.
    if (nullOnMissing) {
      return null;
    }
    else {
      throw new Error('"' + relativeSource + '" is not in the SourceMap.');
    }
  };

/**
 * Returns the generated line and column information for the original source,
 * line, and column positions provided. The only argument is an object with
 * the following properties:
 *
 *   - source: The filename of the original source.
 *   - line: The line number in the original source.  The line number
 *     is 1-based.
 *   - column: The column number in the original source.  The column
 *     number is 0-based.
 *   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
 *     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
 *     closest element that is smaller than or greater than the one we are
 *     searching for, respectively, if the exact element cannot be found.
 *     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
 *
 * and an object is returned with the following properties:
 *
 *   - line: The line number in the generated source, or null.  The
 *     line number is 1-based.
 *   - column: The column number in the generated source, or null.
 *     The column number is 0-based.
 */
BasicSourceMapConsumer.prototype.generatedPositionFor =
  function SourceMapConsumer_generatedPositionFor(aArgs) {
    var source = util.getArg(aArgs, 'source');
    source = this._findSourceIndex(source);
    if (source < 0) {
      return {
        line: null,
        column: null,
        lastColumn: null
      };
    }

    var needle = {
      source: source,
      originalLine: util.getArg(aArgs, 'line'),
      originalColumn: util.getArg(aArgs, 'column')
    };

    var index = this._findMapping(
      needle,
      this._originalMappings,
      "originalLine",
      "originalColumn",
      util.compareByOriginalPositions,
      util.getArg(aArgs, 'bias', SourceMapConsumer.GREATEST_LOWER_BOUND)
    );

    if (index >= 0) {
      var mapping = this._originalMappings[index];

      if (mapping.source === needle.source) {
        return {
          line: util.getArg(mapping, 'generatedLine', null),
          column: util.getArg(mapping, 'generatedColumn', null),
          lastColumn: util.getArg(mapping, 'lastGeneratedColumn', null)
        };
      }
    }

    return {
      line: null,
      column: null,
      lastColumn: null
    };
  };

var BasicSourceMapConsumer_1 = BasicSourceMapConsumer;

/**
 * An IndexedSourceMapConsumer instance represents a parsed source map which
 * we can query for information. It differs from BasicSourceMapConsumer in
 * that it takes "indexed" source maps (i.e. ones with a "sections" field) as
 * input.
 *
 * The first parameter is a raw source map (either as a JSON string, or already
 * parsed to an object). According to the spec for indexed source maps, they
 * have the following attributes:
 *
 *   - version: Which version of the source map spec this map is following.
 *   - file: Optional. The generated file this source map is associated with.
 *   - sections: A list of section definitions.
 *
 * Each value under the "sections" field has two fields:
 *   - offset: The offset into the original specified at which this section
 *       begins to apply, defined as an object with a "line" and "column"
 *       field.
 *   - map: A source map definition. This source map could also be indexed,
 *       but doesn't have to be.
 *
 * Instead of the "map" field, it's also possible to have a "url" field
 * specifying a URL to retrieve a source map from, but that's currently
 * unsupported.
 *
 * Here's an example source map, taken from the source map spec[0], but
 * modified to omit a section which uses the "url" field.
 *
 *  {
 *    version : 3,
 *    file: "app.js",
 *    sections: [{
 *      offset: {line:100, column:10},
 *      map: {
 *        version : 3,
 *        file: "section.js",
 *        sources: ["foo.js", "bar.js"],
 *        names: ["src", "maps", "are", "fun"],
 *        mappings: "AAAA,E;;ABCDE;"
 *      }
 *    }],
 *  }
 *
 * The second parameter, if given, is a string whose value is the URL
 * at which the source map was found.  This URL is used to compute the
 * sources array.
 *
 * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
 */
function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
  var sourceMap = aSourceMap;
  if (typeof aSourceMap === 'string') {
    sourceMap = util.parseSourceMapInput(aSourceMap);
  }

  var version = util.getArg(sourceMap, 'version');
  var sections = util.getArg(sourceMap, 'sections');

  if (version != this._version) {
    throw new Error('Unsupported version: ' + version);
  }

  this._sources = new ArraySet$2();
  this._names = new ArraySet$2();

  var lastOffset = {
    line: -1,
    column: 0
  };
  this._sections = sections.map(function (s) {
    if (s.url) {
      // The url field will require support for asynchronicity.
      // See https://github.com/mozilla/source-map/issues/16
      throw new Error('Support for url field in sections not implemented.');
    }
    var offset = util.getArg(s, 'offset');
    var offsetLine = util.getArg(offset, 'line');
    var offsetColumn = util.getArg(offset, 'column');

    if (offsetLine < lastOffset.line ||
        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
      throw new Error('Section offsets must be ordered and non-overlapping.');
    }
    lastOffset = offset;

    return {
      generatedOffset: {
        // The offset fields are 0-based, but we use 1-based indices when
        // encoding/decoding from VLQ.
        generatedLine: offsetLine + 1,
        generatedColumn: offsetColumn + 1
      },
      consumer: new SourceMapConsumer(util.getArg(s, 'map'), aSourceMapURL)
    }
  });
}

IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;

/**
 * The version of the source mapping spec that we are consuming.
 */
IndexedSourceMapConsumer.prototype._version = 3;

/**
 * The list of original sources.
 */
Object.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {
  get: function () {
    var sources = [];
    for (var i = 0; i < this._sections.length; i++) {
      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
        sources.push(this._sections[i].consumer.sources[j]);
      }
    }
    return sources;
  }
});

/**
 * Returns the original source, line, and column information for the generated
 * source's line and column positions provided. The only argument is an object
 * with the following properties:
 *
 *   - line: The line number in the generated source.  The line number
 *     is 1-based.
 *   - column: The column number in the generated source.  The column
 *     number is 0-based.
 *
 * and an object is returned with the following properties:
 *
 *   - source: The original source file, or null.
 *   - line: The line number in the original source, or null.  The
 *     line number is 1-based.
 *   - column: The column number in the original source, or null.  The
 *     column number is 0-based.
 *   - name: The original identifier, or null.
 */
IndexedSourceMapConsumer.prototype.originalPositionFor =
  function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
    var needle = {
      generatedLine: util.getArg(aArgs, 'line'),
      generatedColumn: util.getArg(aArgs, 'column')
    };

    // Find the section containing the generated position we're trying to map
    // to an original position.
    var sectionIndex = binarySearch.search(needle, this._sections,
      function(needle, section) {
        var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
        if (cmp) {
          return cmp;
        }

        return (needle.generatedColumn -
                section.generatedOffset.generatedColumn);
      });
    var section = this._sections[sectionIndex];

    if (!section) {
      return {
        source: null,
        line: null,
        column: null,
        name: null
      };
    }

    return section.consumer.originalPositionFor({
      line: needle.generatedLine -
        (section.generatedOffset.generatedLine - 1),
      column: needle.generatedColumn -
        (section.generatedOffset.generatedLine === needle.generatedLine
         ? section.generatedOffset.generatedColumn - 1
         : 0),
      bias: aArgs.bias
    });
  };

/**
 * Return true if we have the source content for every source in the source
 * map, false otherwise.
 */
IndexedSourceMapConsumer.prototype.hasContentsOfAllSources =
  function IndexedSourceMapConsumer_hasContentsOfAllSources() {
    return this._sections.every(function (s) {
      return s.consumer.hasContentsOfAllSources();
    });
  };

/**
 * Returns the original source content. The only argument is the url of the
 * original source file. Returns null if no original source content is
 * available.
 */
IndexedSourceMapConsumer.prototype.sourceContentFor =
  function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
    for (var i = 0; i < this._sections.length; i++) {
      var section = this._sections[i];

      var content = section.consumer.sourceContentFor(aSource, true);
      if (content) {
        return content;
      }
    }
    if (nullOnMissing) {
      return null;
    }
    else {
      throw new Error('"' + aSource + '" is not in the SourceMap.');
    }
  };

/**
 * Returns the generated line and column information for the original source,
 * line, and column positions provided. The only argument is an object with
 * the following properties:
 *
 *   - source: The filename of the original source.
 *   - line: The line number in the original source.  The line number
 *     is 1-based.
 *   - column: The column number in the original source.  The column
 *     number is 0-based.
 *
 * and an object is returned with the following properties:
 *
 *   - line: The line number in the generated source, or null.  The
 *     line number is 1-based. 
 *   - column: The column number in the generated source, or null.
 *     The column number is 0-based.
 */
IndexedSourceMapConsumer.prototype.generatedPositionFor =
  function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
    for (var i = 0; i < this._sections.length; i++) {
      var section = this._sections[i];

      // Only consider this section if the requested source is in the list of
      // sources of the consumer.
      if (section.consumer._findSourceIndex(util.getArg(aArgs, 'source')) === -1) {
        continue;
      }
      var generatedPosition = section.consumer.generatedPositionFor(aArgs);
      if (generatedPosition) {
        var ret = {
          line: generatedPosition.line +
            (section.generatedOffset.generatedLine - 1),
          column: generatedPosition.column +
            (section.generatedOffset.generatedLine === generatedPosition.line
             ? section.generatedOffset.generatedColumn - 1
             : 0)
        };
        return ret;
      }
    }

    return {
      line: null,
      column: null
    };
  };

/**
 * Parse the mappings in a string in to a data structure which we can easily
 * query (the ordered arrays in the `this.__generatedMappings` and
 * `this.__originalMappings` properties).
 */
IndexedSourceMapConsumer.prototype._parseMappings =
  function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
    this.__generatedMappings = [];
    this.__originalMappings = [];
    for (var i = 0; i < this._sections.length; i++) {
      var section = this._sections[i];
      var sectionMappings = section.consumer._generatedMappings;
      for (var j = 0; j < sectionMappings.length; j++) {
        var mapping = sectionMappings[j];

        var source = section.consumer._sources.at(mapping.source);
        source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
        this._sources.add(source);
        source = this._sources.indexOf(source);

        var name = null;
        if (mapping.name) {
          name = section.consumer._names.at(mapping.name);
          this._names.add(name);
          name = this._names.indexOf(name);
        }

        // The mappings coming from the consumer for the section have
        // generated positions relative to the start of the section, so we
        // need to offset them to be relative to the start of the concatenated
        // generated file.
        var adjustedMapping = {
          source: source,
          generatedLine: mapping.generatedLine +
            (section.generatedOffset.generatedLine - 1),
          generatedColumn: mapping.generatedColumn +
            (section.generatedOffset.generatedLine === mapping.generatedLine
            ? section.generatedOffset.generatedColumn - 1
            : 0),
          originalLine: mapping.originalLine,
          originalColumn: mapping.originalColumn,
          name: name
        };

        this.__generatedMappings.push(adjustedMapping);
        if (typeof adjustedMapping.originalLine === 'number') {
          this.__originalMappings.push(adjustedMapping);
        }
      }
    }

    quickSort$1(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
    quickSort$1(this.__originalMappings, util.compareByOriginalPositions);
  };

var IndexedSourceMapConsumer_1 = IndexedSourceMapConsumer;

var sourceMapConsumer = {
	SourceMapConsumer: SourceMapConsumer_1,
	BasicSourceMapConsumer: BasicSourceMapConsumer_1,
	IndexedSourceMapConsumer: IndexedSourceMapConsumer_1
};

/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

var SourceMapGenerator$1 = sourceMapGenerator.SourceMapGenerator;


// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
// operating systems these days (capturing the result).
var REGEX_NEWLINE = /(\r?\n)/;

// Newline character code for charCodeAt() comparisons
var NEWLINE_CODE = 10;

// Private symbol for identifying `SourceNode`s when multiple versions of
// the source-map library are loaded. This MUST NOT CHANGE across
// versions!
var isSourceNode = "$$$isSourceNode$$$";

/**
 * SourceNodes provide a way to abstract over interpolating/concatenating
 * snippets of generated JavaScript source code while maintaining the line and
 * column information associated with the original source code.
 *
 * @param aLine The original line number.
 * @param aColumn The original column number.
 * @param aSource The original source's filename.
 * @param aChunks Optional. An array of strings which are snippets of
 *        generated JS, or other SourceNodes.
 * @param aName The original identifier.
 */
function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
  this.children = [];
  this.sourceContents = {};
  this.line = aLine == null ? null : aLine;
  this.column = aColumn == null ? null : aColumn;
  this.source = aSource == null ? null : aSource;
  this.name = aName == null ? null : aName;
  this[isSourceNode] = true;
  if (aChunks != null) this.add(aChunks);
}

/**
 * Creates a SourceNode from generated code and a SourceMapConsumer.
 *
 * @param aGeneratedCode The generated code
 * @param aSourceMapConsumer The SourceMap for the generated code
 * @param aRelativePath Optional. The path that relative sources in the
 *        SourceMapConsumer should be relative to.
 */
SourceNode.fromStringWithSourceMap =
  function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
    // The SourceNode we want to fill with the generated code
    // and the SourceMap
    var node = new SourceNode();

    // All even indices of this array are one line of the generated code,
    // while all odd indices are the newlines between two adjacent lines
    // (since `REGEX_NEWLINE` captures its match).
    // Processed fragments are accessed by calling `shiftNextLine`.
    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
    var remainingLinesIndex = 0;
    var shiftNextLine = function() {
      var lineContents = getNextLine();
      // The last line of a file might not have a newline.
      var newLine = getNextLine() || "";
      return lineContents + newLine;

      function getNextLine() {
        return remainingLinesIndex < remainingLines.length ?
            remainingLines[remainingLinesIndex++] : undefined;
      }
    };

    // We need to remember the position of "remainingLines"
    var lastGeneratedLine = 1, lastGeneratedColumn = 0;

    // The generate SourceNodes we need a code range.
    // To extract it current and last mapping is used.
    // Here we store the last mapping.
    var lastMapping = null;

    aSourceMapConsumer.eachMapping(function (mapping) {
      if (lastMapping !== null) {
        // We add the code from "lastMapping" to "mapping":
        // First check if there is a new line in between.
        if (lastGeneratedLine < mapping.generatedLine) {
          // Associate first line with "lastMapping"
          addMappingWithCode(lastMapping, shiftNextLine());
          lastGeneratedLine++;
          lastGeneratedColumn = 0;
          // The remaining code is added without mapping
        } else {
          // There is no new line in between.
          // Associate the code between "lastGeneratedColumn" and
          // "mapping.generatedColumn" with "lastMapping"
          var nextLine = remainingLines[remainingLinesIndex] || '';
          var code = nextLine.substr(0, mapping.generatedColumn -
                                        lastGeneratedColumn);
          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -
                                              lastGeneratedColumn);
          lastGeneratedColumn = mapping.generatedColumn;
          addMappingWithCode(lastMapping, code);
          // No more remaining code, continue
          lastMapping = mapping;
          return;
        }
      }
      // We add the generated code until the first mapping
      // to the SourceNode without any mapping.
      // Each line is added as separate string.
      while (lastGeneratedLine < mapping.generatedLine) {
        node.add(shiftNextLine());
        lastGeneratedLine++;
      }
      if (lastGeneratedColumn < mapping.generatedColumn) {
        var nextLine = remainingLines[remainingLinesIndex] || '';
        node.add(nextLine.substr(0, mapping.generatedColumn));
        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
        lastGeneratedColumn = mapping.generatedColumn;
      }
      lastMapping = mapping;
    }, this);
    // We have processed all mappings.
    if (remainingLinesIndex < remainingLines.length) {
      if (lastMapping) {
        // Associate the remaining code in the current line with "lastMapping"
        addMappingWithCode(lastMapping, shiftNextLine());
      }
      // and add the remaining lines without any mapping
      node.add(remainingLines.splice(remainingLinesIndex).join(""));
    }

    // Copy sourcesContent into SourceNode
    aSourceMapConsumer.sources.forEach(function (sourceFile) {
      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
      if (content != null) {
        if (aRelativePath != null) {
          sourceFile = util.join(aRelativePath, sourceFile);
        }
        node.setSourceContent(sourceFile, content);
      }
    });

    return node;

    function addMappingWithCode(mapping, code) {
      if (mapping === null || mapping.source === undefined) {
        node.add(code);
      } else {
        var source = aRelativePath
          ? util.join(aRelativePath, mapping.source)
          : mapping.source;
        node.add(new SourceNode(mapping.originalLine,
                                mapping.originalColumn,
                                source,
                                code,
                                mapping.name));
      }
    }
  };

/**
 * Add a chunk of generated JS to this source node.
 *
 * @param aChunk A string snippet of generated JS code, another instance of
 *        SourceNode, or an array where each member is one of those things.
 */
SourceNode.prototype.add = function SourceNode_add(aChunk) {
  if (Array.isArray(aChunk)) {
    aChunk.forEach(function (chunk) {
      this.add(chunk);
    }, this);
  }
  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
    if (aChunk) {
      this.children.push(aChunk);
    }
  }
  else {
    throw new TypeError(
      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
    );
  }
  return this;
};

/**
 * Add a chunk of generated JS to the beginning of this source node.
 *
 * @param aChunk A string snippet of generated JS code, another instance of
 *        SourceNode, or an array where each member is one of those things.
 */
SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
  if (Array.isArray(aChunk)) {
    for (var i = aChunk.length-1; i >= 0; i--) {
      this.prepend(aChunk[i]);
    }
  }
  else if (aChunk[isSourceNode] || typeof aChunk === "string") {
    this.children.unshift(aChunk);
  }
  else {
    throw new TypeError(
      "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
    );
  }
  return this;
};

/**
 * Walk over the tree of JS snippets in this node and its children. The
 * walking function is called once for each snippet of JS and is passed that
 * snippet and the its original associated source's line/column location.
 *
 * @param aFn The traversal function.
 */
SourceNode.prototype.walk = function SourceNode_walk(aFn) {
  var chunk;
  for (var i = 0, len = this.children.length; i < len; i++) {
    chunk = this.children[i];
    if (chunk[isSourceNode]) {
      chunk.walk(aFn);
    }
    else {
      if (chunk !== '') {
        aFn(chunk, { source: this.source,
                     line: this.line,
                     column: this.column,
                     name: this.name });
      }
    }
  }
};

/**
 * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
 * each of `this.children`.
 *
 * @param aSep The separator.
 */
SourceNode.prototype.join = function SourceNode_join(aSep) {
  var newChildren;
  var i;
  var len = this.children.length;
  if (len > 0) {
    newChildren = [];
    for (i = 0; i < len-1; i++) {
      newChildren.push(this.children[i]);
      newChildren.push(aSep);
    }
    newChildren.push(this.children[i]);
    this.children = newChildren;
  }
  return this;
};

/**
 * Call String.prototype.replace on the very right-most source snippet. Useful
 * for trimming whitespace from the end of a source node, etc.
 *
 * @param aPattern The pattern to replace.
 * @param aReplacement The thing to replace the pattern with.
 */
SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
  var lastChild = this.children[this.children.length - 1];
  if (lastChild[isSourceNode]) {
    lastChild.replaceRight(aPattern, aReplacement);
  }
  else if (typeof lastChild === 'string') {
    this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
  }
  else {
    this.children.push(''.replace(aPattern, aReplacement));
  }
  return this;
};

/**
 * Set the source content for a source file. This will be added to the SourceMapGenerator
 * in the sourcesContent field.
 *
 * @param aSourceFile The filename of the source file
 * @param aSourceContent The content of the source file
 */
SourceNode.prototype.setSourceContent =
  function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
  };

/**
 * Walk over the tree of SourceNodes. The walking function is called for each
 * source file content and is passed the filename and source content.
 *
 * @param aFn The traversal function.
 */
SourceNode.prototype.walkSourceContents =
  function SourceNode_walkSourceContents(aFn) {
    for (var i = 0, len = this.children.length; i < len; i++) {
      if (this.children[i][isSourceNode]) {
        this.children[i].walkSourceContents(aFn);
      }
    }

    var sources = Object.keys(this.sourceContents);
    for (var i = 0, len = sources.length; i < len; i++) {
      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
    }
  };

/**
 * Return the string representation of this source node. Walks over the tree
 * and concatenates all the various snippets together to one string.
 */
SourceNode.prototype.toString = function SourceNode_toString() {
  var str = "";
  this.walk(function (chunk) {
    str += chunk;
  });
  return str;
};

/**
 * Returns the string representation of this source node along with a source
 * map.
 */
SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
  var generated = {
    code: "",
    line: 1,
    column: 0
  };
  var map = new SourceMapGenerator$1(aArgs);
  var sourceMappingActive = false;
  var lastOriginalSource = null;
  var lastOriginalLine = null;
  var lastOriginalColumn = null;
  var lastOriginalName = null;
  this.walk(function (chunk, original) {
    generated.code += chunk;
    if (original.source !== null
        && original.line !== null
        && original.column !== null) {
      if(lastOriginalSource !== original.source
         || lastOriginalLine !== original.line
         || lastOriginalColumn !== original.column
         || lastOriginalName !== original.name) {
        map.addMapping({
          source: original.source,
          original: {
            line: original.line,
            column: original.column
          },
          generated: {
            line: generated.line,
            column: generated.column
          },
          name: original.name
        });
      }
      lastOriginalSource = original.source;
      lastOriginalLine = original.line;
      lastOriginalColumn = original.column;
      lastOriginalName = original.name;
      sourceMappingActive = true;
    } else if (sourceMappingActive) {
      map.addMapping({
        generated: {
          line: generated.line,
          column: generated.column
        }
      });
      lastOriginalSource = null;
      sourceMappingActive = false;
    }
    for (var idx = 0, length = chunk.length; idx < length; idx++) {
      if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
        generated.line++;
        generated.column = 0;
        // Mappings end at eol
        if (idx + 1 === length) {
          lastOriginalSource = null;
          sourceMappingActive = false;
        } else if (sourceMappingActive) {
          map.addMapping({
            source: original.source,
            original: {
              line: original.line,
              column: original.column
            },
            generated: {
              line: generated.line,
              column: generated.column
            },
            name: original.name
          });
        }
      } else {
        generated.column++;
      }
    }
  });
  this.walkSourceContents(function (sourceFile, sourceContent) {
    map.setSourceContent(sourceFile, sourceContent);
  });

  return { code: generated.code, map: map };
};

var SourceNode_1 = SourceNode;

var sourceNode = {
	SourceNode: SourceNode_1
};

/*
 * Copyright 2009-2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE.txt or:
 * http://opensource.org/licenses/BSD-3-Clause
 */
var SourceMapGenerator$2 = sourceMapGenerator.SourceMapGenerator;
var SourceMapConsumer$1 = sourceMapConsumer.SourceMapConsumer;
var SourceNode$1 = sourceNode.SourceNode;

var sourceMap = {
	SourceMapGenerator: SourceMapGenerator$2,
	SourceMapConsumer: SourceMapConsumer$1,
	SourceNode: SourceNode$1
};

var codeGen = createCommonjsModule(function (module, exports) {

exports.__esModule = true;



var SourceNode = undefined;

try {
  /* istanbul ignore next */
  if (typeof undefined !== 'function' || !undefined.amd) {
    // We don't support this in AMD environments. For these environments, we asusme that
    // they are running on the browser and thus have no need for the source-map library.
    var SourceMap = sourceMap;
    SourceNode = SourceMap.SourceNode;
  }
} catch (err) {}
/* NOP */

/* istanbul ignore if: tested but not covered in istanbul due to dist build  */
if (!SourceNode) {
  SourceNode = function (line, column, srcFile, chunks) {
    this.src = '';
    if (chunks) {
      this.add(chunks);
    }
  };
  /* istanbul ignore next */
  SourceNode.prototype = {
    add: function add(chunks) {
      if (utils$2.isArray(chunks)) {
        chunks = chunks.join('');
      }
      this.src += chunks;
    },
    prepend: function prepend(chunks) {
      if (utils$2.isArray(chunks)) {
        chunks = chunks.join('');
      }
      this.src = chunks + this.src;
    },
    toStringWithSourceMap: function toStringWithSourceMap() {
      return { code: this.toString() };
    },
    toString: function toString() {
      return this.src;
    }
  };
}

function castChunk(chunk, codeGen, loc) {
  if (utils$2.isArray(chunk)) {
    var ret = [];

    for (var i = 0, len = chunk.length; i < len; i++) {
      ret.push(codeGen.wrap(chunk[i], loc));
    }
    return ret;
  } else if (typeof chunk === 'boolean' || typeof chunk === 'number') {
    // Handle primitives that the SourceNode will throw up on
    return chunk + '';
  }
  return chunk;
}

function CodeGen(srcFile) {
  this.srcFile = srcFile;
  this.source = [];
}

CodeGen.prototype = {
  isEmpty: function isEmpty() {
    return !this.source.length;
  },
  prepend: function prepend(source, loc) {
    this.source.unshift(this.wrap(source, loc));
  },
  push: function push(source, loc) {
    this.source.push(this.wrap(source, loc));
  },

  merge: function merge() {
    var source = this.empty();
    this.each(function (line) {
      source.add(['  ', line, '\n']);
    });
    return source;
  },

  each: function each(iter) {
    for (var i = 0, len = this.source.length; i < len; i++) {
      iter(this.source[i]);
    }
  },

  empty: function empty() {
    var loc = this.currentLocation || { start: {} };
    return new SourceNode(loc.start.line, loc.start.column, this.srcFile);
  },
  wrap: function wrap(chunk) {
    var loc = arguments.length <= 1 || arguments[1] === undefined ? this.currentLocation || { start: {} } : arguments[1];

    if (chunk instanceof SourceNode) {
      return chunk;
    }

    chunk = castChunk(chunk, this, loc);

    return new SourceNode(loc.start.line, loc.start.column, this.srcFile, chunk);
  },

  functionCall: function functionCall(fn, type, params) {
    params = this.generateList(params);
    return this.wrap([fn, type ? '.' + type + '(' : '(', params, ')']);
  },

  quotedString: function quotedString(str) {
    return '"' + (str + '').replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\u2028/g, '\\u2028') // Per Ecma-262 7.3 + 7.8.4
    .replace(/\u2029/g, '\\u2029') + '"';
  },

  objectLiteral: function objectLiteral(obj) {
    // istanbul ignore next

    var _this = this;

    var pairs = [];

    Object.keys(obj).forEach(function (key) {
      var value = castChunk(obj[key], _this);
      if (value !== 'undefined') {
        pairs.push([_this.quotedString(key), ':', value]);
      }
    });

    var ret = this.generateList(pairs);
    ret.prepend('{');
    ret.add('}');
    return ret;
  },

  generateList: function generateList(entries) {
    var ret = this.empty();

    for (var i = 0, len = entries.length; i < len; i++) {
      if (i) {
        ret.add(',');
      }

      ret.add(castChunk(entries[i], this));
    }

    return ret;
  },

  generateArray: function generateArray(entries) {
    var ret = this.generateList(entries);
    ret.prepend('[');
    ret.add(']');

    return ret;
  }
};

exports['default'] = CodeGen;
module.exports = exports['default'];

});

var javascriptCompiler = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }





var _exception2 = _interopRequireDefault(exception);





var _codeGen2 = _interopRequireDefault(codeGen);

function Literal(value) {
  this.value = value;
}

function JavaScriptCompiler() {}

JavaScriptCompiler.prototype = {
  // PUBLIC API: You can override these methods in a subclass to provide
  // alternative compiled forms for name lookup and buffering semantics
  nameLookup: function nameLookup(parent, name /*,  type */) {
    return this.internalNameLookup(parent, name);
  },
  depthedLookup: function depthedLookup(name) {
    return [this.aliasable('container.lookup'), '(depths, "', name, '")'];
  },

  compilerInfo: function compilerInfo() {
    var revision = base.COMPILER_REVISION,
        versions = base.REVISION_CHANGES[revision];
    return [revision, versions];
  },

  appendToBuffer: function appendToBuffer(source, location, explicit) {
    // Force a source as this simplifies the merge logic.
    if (!utils$2.isArray(source)) {
      source = [source];
    }
    source = this.source.wrap(source, location);

    if (this.environment.isSimple) {
      return ['return ', source, ';'];
    } else if (explicit) {
      // This is a case where the buffer operation occurs as a child of another
      // construct, generally braces. We have to explicitly output these buffer
      // operations to ensure that the emitted code goes in the correct location.
      return ['buffer += ', source, ';'];
    } else {
      source.appendToBuffer = true;
      return source;
    }
  },

  initializeBuffer: function initializeBuffer() {
    return this.quotedString('');
  },
  // END PUBLIC API
  internalNameLookup: function internalNameLookup(parent, name) {
    this.lookupPropertyFunctionIsUsed = true;
    return ['lookupProperty(', parent, ',', JSON.stringify(name), ')'];
  },

  lookupPropertyFunctionIsUsed: false,

  compile: function compile(environment, options, context, asObject) {
    this.environment = environment;
    this.options = options;
    this.stringParams = this.options.stringParams;
    this.trackIds = this.options.trackIds;
    this.precompile = !asObject;

    this.name = this.environment.name;
    this.isChild = !!context;
    this.context = context || {
      decorators: [],
      programs: [],
      environments: []
    };

    this.preamble();

    this.stackSlot = 0;
    this.stackVars = [];
    this.aliases = {};
    this.registers = { list: [] };
    this.hashes = [];
    this.compileStack = [];
    this.inlineStack = [];
    this.blockParams = [];

    this.compileChildren(environment, options);

    this.useDepths = this.useDepths || environment.useDepths || environment.useDecorators || this.options.compat;
    this.useBlockParams = this.useBlockParams || environment.useBlockParams;

    var opcodes = environment.opcodes,
        opcode = undefined,
        firstLoc = undefined,
        i = undefined,
        l = undefined;

    for (i = 0, l = opcodes.length; i < l; i++) {
      opcode = opcodes[i];

      this.source.currentLocation = opcode.loc;
      firstLoc = firstLoc || opcode.loc;
      this[opcode.opcode].apply(this, opcode.args);
    }

    // Flush any trailing content that might be pending.
    this.source.currentLocation = firstLoc;
    this.pushSource('');

    /* istanbul ignore next */
    if (this.stackSlot || this.inlineStack.length || this.compileStack.length) {
      throw new _exception2['default']('Compile completed with content left on stack');
    }

    if (!this.decorators.isEmpty()) {
      this.useDecorators = true;

      this.decorators.prepend(['var decorators = container.decorators, ', this.lookupPropertyFunctionVarDeclaration(), ';\n']);
      this.decorators.push('return fn;');

      if (asObject) {
        this.decorators = Function.apply(this, ['fn', 'props', 'container', 'depth0', 'data', 'blockParams', 'depths', this.decorators.merge()]);
      } else {
        this.decorators.prepend('function(fn, props, container, depth0, data, blockParams, depths) {\n');
        this.decorators.push('}\n');
        this.decorators = this.decorators.merge();
      }
    } else {
      this.decorators = undefined;
    }

    var fn = this.createFunctionContext(asObject);
    if (!this.isChild) {
      var ret = {
        compiler: this.compilerInfo(),
        main: fn
      };

      if (this.decorators) {
        ret.main_d = this.decorators; // eslint-disable-line camelcase
        ret.useDecorators = true;
      }

      var _context = this.context;
      var programs = _context.programs;
      var decorators = _context.decorators;

      for (i = 0, l = programs.length; i < l; i++) {
        if (programs[i]) {
          ret[i] = programs[i];
          if (decorators[i]) {
            ret[i + '_d'] = decorators[i];
            ret.useDecorators = true;
          }
        }
      }

      if (this.environment.usePartial) {
        ret.usePartial = true;
      }
      if (this.options.data) {
        ret.useData = true;
      }
      if (this.useDepths) {
        ret.useDepths = true;
      }
      if (this.useBlockParams) {
        ret.useBlockParams = true;
      }
      if (this.options.compat) {
        ret.compat = true;
      }

      if (!asObject) {
        ret.compiler = JSON.stringify(ret.compiler);

        this.source.currentLocation = { start: { line: 1, column: 0 } };
        ret = this.objectLiteral(ret);

        if (options.srcName) {
          ret = ret.toStringWithSourceMap({ file: options.destName });
          ret.map = ret.map && ret.map.toString();
        } else {
          ret = ret.toString();
        }
      } else {
        ret.compilerOptions = this.options;
      }

      return ret;
    } else {
      return fn;
    }
  },

  preamble: function preamble() {
    // track the last context pushed into place to allow skipping the
    // getContext opcode when it would be a noop
    this.lastContext = 0;
    this.source = new _codeGen2['default'](this.options.srcName);
    this.decorators = new _codeGen2['default'](this.options.srcName);
  },

  createFunctionContext: function createFunctionContext(asObject) {
    // istanbul ignore next

    var _this = this;

    var varDeclarations = '';

    var locals = this.stackVars.concat(this.registers.list);
    if (locals.length > 0) {
      varDeclarations += ', ' + locals.join(', ');
    }

    // Generate minimizer alias mappings
    //
    // When using true SourceNodes, this will update all references to the given alias
    // as the source nodes are reused in situ. For the non-source node compilation mode,
    // aliases will not be used, but this case is already being run on the client and
    // we aren't concern about minimizing the template size.
    var aliasCount = 0;
    Object.keys(this.aliases).forEach(function (alias) {
      var node = _this.aliases[alias];
      if (node.children && node.referenceCount > 1) {
        varDeclarations += ', alias' + ++aliasCount + '=' + alias;
        node.children[0] = 'alias' + aliasCount;
      }
    });

    if (this.lookupPropertyFunctionIsUsed) {
      varDeclarations += ', ' + this.lookupPropertyFunctionVarDeclaration();
    }

    var params = ['container', 'depth0', 'helpers', 'partials', 'data'];

    if (this.useBlockParams || this.useDepths) {
      params.push('blockParams');
    }
    if (this.useDepths) {
      params.push('depths');
    }

    // Perform a second pass over the output to merge content when possible
    var source = this.mergeSource(varDeclarations);

    if (asObject) {
      params.push(source);

      return Function.apply(this, params);
    } else {
      return this.source.wrap(['function(', params.join(','), ') {\n  ', source, '}']);
    }
  },
  mergeSource: function mergeSource(varDeclarations) {
    var isSimple = this.environment.isSimple,
        appendOnly = !this.forceBuffer,
        appendFirst = undefined,
        sourceSeen = undefined,
        bufferStart = undefined,
        bufferEnd = undefined;
    this.source.each(function (line) {
      if (line.appendToBuffer) {
        if (bufferStart) {
          line.prepend('  + ');
        } else {
          bufferStart = line;
        }
        bufferEnd = line;
      } else {
        if (bufferStart) {
          if (!sourceSeen) {
            appendFirst = true;
          } else {
            bufferStart.prepend('buffer += ');
          }
          bufferEnd.add(';');
          bufferStart = bufferEnd = undefined;
        }

        sourceSeen = true;
        if (!isSimple) {
          appendOnly = false;
        }
      }
    });

    if (appendOnly) {
      if (bufferStart) {
        bufferStart.prepend('return ');
        bufferEnd.add(';');
      } else if (!sourceSeen) {
        this.source.push('return "";');
      }
    } else {
      varDeclarations += ', buffer = ' + (appendFirst ? '' : this.initializeBuffer());

      if (bufferStart) {
        bufferStart.prepend('return buffer + ');
        bufferEnd.add(';');
      } else {
        this.source.push('return buffer;');
      }
    }

    if (varDeclarations) {
      this.source.prepend('var ' + varDeclarations.substring(2) + (appendFirst ? '' : ';\n'));
    }

    return this.source.merge();
  },

  lookupPropertyFunctionVarDeclaration: function lookupPropertyFunctionVarDeclaration() {
    return '\n      lookupProperty = container.lookupProperty || function(parent, propertyName) {\n        if (Object.prototype.hasOwnProperty.call(parent, propertyName)) {\n          return parent[propertyName];\n        }\n        return undefined\n    }\n    '.trim();
  },

  // [blockValue]
  //
  // On stack, before: hash, inverse, program, value
  // On stack, after: return value of blockHelperMissing
  //
  // The purpose of this opcode is to take a block of the form
  // `{{#this.foo}}...{{/this.foo}}`, resolve the value of `foo`, and
  // replace it on the stack with the result of properly
  // invoking blockHelperMissing.
  blockValue: function blockValue(name) {
    var blockHelperMissing = this.aliasable('container.hooks.blockHelperMissing'),
        params = [this.contextName(0)];
    this.setupHelperArgs(name, 0, params);

    var blockName = this.popStack();
    params.splice(1, 0, blockName);

    this.push(this.source.functionCall(blockHelperMissing, 'call', params));
  },

  // [ambiguousBlockValue]
  //
  // On stack, before: hash, inverse, program, value
  // Compiler value, before: lastHelper=value of last found helper, if any
  // On stack, after, if no lastHelper: same as [blockValue]
  // On stack, after, if lastHelper: value
  ambiguousBlockValue: function ambiguousBlockValue() {
    // We're being a bit cheeky and reusing the options value from the prior exec
    var blockHelperMissing = this.aliasable('container.hooks.blockHelperMissing'),
        params = [this.contextName(0)];
    this.setupHelperArgs('', 0, params, true);

    this.flushInline();

    var current = this.topStack();
    params.splice(1, 0, current);

    this.pushSource(['if (!', this.lastHelper, ') { ', current, ' = ', this.source.functionCall(blockHelperMissing, 'call', params), '}']);
  },

  // [appendContent]
  //
  // On stack, before: ...
  // On stack, after: ...
  //
  // Appends the string value of `content` to the current buffer
  appendContent: function appendContent(content) {
    if (this.pendingContent) {
      content = this.pendingContent + content;
    } else {
      this.pendingLocation = this.source.currentLocation;
    }

    this.pendingContent = content;
  },

  // [append]
  //
  // On stack, before: value, ...
  // On stack, after: ...
  //
  // Coerces `value` to a String and appends it to the current buffer.
  //
  // If `value` is truthy, or 0, it is coerced into a string and appended
  // Otherwise, the empty string is appended
  append: function append() {
    if (this.isInline()) {
      this.replaceStack(function (current) {
        return [' != null ? ', current, ' : ""'];
      });

      this.pushSource(this.appendToBuffer(this.popStack()));
    } else {
      var local = this.popStack();
      this.pushSource(['if (', local, ' != null) { ', this.appendToBuffer(local, undefined, true), ' }']);
      if (this.environment.isSimple) {
        this.pushSource(['else { ', this.appendToBuffer("''", undefined, true), ' }']);
      }
    }
  },

  // [appendEscaped]
  //
  // On stack, before: value, ...
  // On stack, after: ...
  //
  // Escape `value` and append it to the buffer
  appendEscaped: function appendEscaped() {
    this.pushSource(this.appendToBuffer([this.aliasable('container.escapeExpression'), '(', this.popStack(), ')']));
  },

  // [getContext]
  //
  // On stack, before: ...
  // On stack, after: ...
  // Compiler value, after: lastContext=depth
  //
  // Set the value of the `lastContext` compiler value to the depth
  getContext: function getContext(depth) {
    this.lastContext = depth;
  },

  // [pushContext]
  //
  // On stack, before: ...
  // On stack, after: currentContext, ...
  //
  // Pushes the value of the current context onto the stack.
  pushContext: function pushContext() {
    this.pushStackLiteral(this.contextName(this.lastContext));
  },

  // [lookupOnContext]
  //
  // On stack, before: ...
  // On stack, after: currentContext[name], ...
  //
  // Looks up the value of `name` on the current context and pushes
  // it onto the stack.
  lookupOnContext: function lookupOnContext(parts, falsy, strict, scoped) {
    var i = 0;

    if (!scoped && this.options.compat && !this.lastContext) {
      // The depthed query is expected to handle the undefined logic for the root level that
      // is implemented below, so we evaluate that directly in compat mode
      this.push(this.depthedLookup(parts[i++]));
    } else {
      this.pushContext();
    }

    this.resolvePath('context', parts, i, falsy, strict);
  },

  // [lookupBlockParam]
  //
  // On stack, before: ...
  // On stack, after: blockParam[name], ...
  //
  // Looks up the value of `parts` on the given block param and pushes
  // it onto the stack.
  lookupBlockParam: function lookupBlockParam(blockParamId, parts) {
    this.useBlockParams = true;

    this.push(['blockParams[', blockParamId[0], '][', blockParamId[1], ']']);
    this.resolvePath('context', parts, 1);
  },

  // [lookupData]
  //
  // On stack, before: ...
  // On stack, after: data, ...
  //
  // Push the data lookup operator
  lookupData: function lookupData(depth, parts, strict) {
    if (!depth) {
      this.pushStackLiteral('data');
    } else {
      this.pushStackLiteral('container.data(data, ' + depth + ')');
    }

    this.resolvePath('data', parts, 0, true, strict);
  },

  resolvePath: function resolvePath(type, parts, i, falsy, strict) {
    // istanbul ignore next

    var _this2 = this;

    if (this.options.strict || this.options.assumeObjects) {
      this.push(strictLookup(this.options.strict && strict, this, parts, type));
      return;
    }

    var len = parts.length;
    for (; i < len; i++) {
      /* eslint-disable no-loop-func */
      this.replaceStack(function (current) {
        var lookup = _this2.nameLookup(current, parts[i], type);
        // We want to ensure that zero and false are handled properly if the context (falsy flag)
        // needs to have the special handling for these values.
        if (!falsy) {
          return [' != null ? ', lookup, ' : ', current];
        } else {
          // Otherwise we can use generic falsy handling
          return [' && ', lookup];
        }
      });
      /* eslint-enable no-loop-func */
    }
  },

  // [resolvePossibleLambda]
  //
  // On stack, before: value, ...
  // On stack, after: resolved value, ...
  //
  // If the `value` is a lambda, replace it on the stack by
  // the return value of the lambda
  resolvePossibleLambda: function resolvePossibleLambda() {
    this.push([this.aliasable('container.lambda'), '(', this.popStack(), ', ', this.contextName(0), ')']);
  },

  // [pushStringParam]
  //
  // On stack, before: ...
  // On stack, after: string, currentContext, ...
  //
  // This opcode is designed for use in string mode, which
  // provides the string value of a parameter along with its
  // depth rather than resolving it immediately.
  pushStringParam: function pushStringParam(string, type) {
    this.pushContext();
    this.pushString(type);

    // If it's a subexpression, the string result
    // will be pushed after this opcode.
    if (type !== 'SubExpression') {
      if (typeof string === 'string') {
        this.pushString(string);
      } else {
        this.pushStackLiteral(string);
      }
    }
  },

  emptyHash: function emptyHash(omitEmpty) {
    if (this.trackIds) {
      this.push('{}'); // hashIds
    }
    if (this.stringParams) {
      this.push('{}'); // hashContexts
      this.push('{}'); // hashTypes
    }
    this.pushStackLiteral(omitEmpty ? 'undefined' : '{}');
  },
  pushHash: function pushHash() {
    if (this.hash) {
      this.hashes.push(this.hash);
    }
    this.hash = { values: {}, types: [], contexts: [], ids: [] };
  },
  popHash: function popHash() {
    var hash = this.hash;
    this.hash = this.hashes.pop();

    if (this.trackIds) {
      this.push(this.objectLiteral(hash.ids));
    }
    if (this.stringParams) {
      this.push(this.objectLiteral(hash.contexts));
      this.push(this.objectLiteral(hash.types));
    }

    this.push(this.objectLiteral(hash.values));
  },

  // [pushString]
  //
  // On stack, before: ...
  // On stack, after: quotedString(string), ...
  //
  // Push a quoted version of `string` onto the stack
  pushString: function pushString(string) {
    this.pushStackLiteral(this.quotedString(string));
  },

  // [pushLiteral]
  //
  // On stack, before: ...
  // On stack, after: value, ...
  //
  // Pushes a value onto the stack. This operation prevents
  // the compiler from creating a temporary variable to hold
  // it.
  pushLiteral: function pushLiteral(value) {
    this.pushStackLiteral(value);
  },

  // [pushProgram]
  //
  // On stack, before: ...
  // On stack, after: program(guid), ...
  //
  // Push a program expression onto the stack. This takes
  // a compile-time guid and converts it into a runtime-accessible
  // expression.
  pushProgram: function pushProgram(guid) {
    if (guid != null) {
      this.pushStackLiteral(this.programExpression(guid));
    } else {
      this.pushStackLiteral(null);
    }
  },

  // [registerDecorator]
  //
  // On stack, before: hash, program, params..., ...
  // On stack, after: ...
  //
  // Pops off the decorator's parameters, invokes the decorator,
  // and inserts the decorator into the decorators list.
  registerDecorator: function registerDecorator(paramSize, name) {
    var foundDecorator = this.nameLookup('decorators', name, 'decorator'),
        options = this.setupHelperArgs(name, paramSize);

    this.decorators.push(['fn = ', this.decorators.functionCall(foundDecorator, '', ['fn', 'props', 'container', options]), ' || fn;']);
  },

  // [invokeHelper]
  //
  // On stack, before: hash, inverse, program, params..., ...
  // On stack, after: result of helper invocation
  //
  // Pops off the helper's parameters, invokes the helper,
  // and pushes the helper's return value onto the stack.
  //
  // If the helper is not found, `helperMissing` is called.
  invokeHelper: function invokeHelper(paramSize, name, isSimple) {
    var nonHelper = this.popStack(),
        helper = this.setupHelper(paramSize, name);

    var possibleFunctionCalls = [];

    if (isSimple) {
      // direct call to helper
      possibleFunctionCalls.push(helper.name);
    }
    // call a function from the input object
    possibleFunctionCalls.push(nonHelper);
    if (!this.options.strict) {
      possibleFunctionCalls.push(this.aliasable('container.hooks.helperMissing'));
    }

    var functionLookupCode = ['(', this.itemsSeparatedBy(possibleFunctionCalls, '||'), ')'];
    var functionCall = this.source.functionCall(functionLookupCode, 'call', helper.callParams);
    this.push(functionCall);
  },

  itemsSeparatedBy: function itemsSeparatedBy(items, separator) {
    var result = [];
    result.push(items[0]);
    for (var i = 1; i < items.length; i++) {
      result.push(separator, items[i]);
    }
    return result;
  },
  // [invokeKnownHelper]
  //
  // On stack, before: hash, inverse, program, params..., ...
  // On stack, after: result of helper invocation
  //
  // This operation is used when the helper is known to exist,
  // so a `helperMissing` fallback is not required.
  invokeKnownHelper: function invokeKnownHelper(paramSize, name) {
    var helper = this.setupHelper(paramSize, name);
    this.push(this.source.functionCall(helper.name, 'call', helper.callParams));
  },

  // [invokeAmbiguous]
  //
  // On stack, before: hash, inverse, program, params..., ...
  // On stack, after: result of disambiguation
  //
  // This operation is used when an expression like `{{foo}}`
  // is provided, but we don't know at compile-time whether it
  // is a helper or a path.
  //
  // This operation emits more code than the other options,
  // and can be avoided by passing the `knownHelpers` and
  // `knownHelpersOnly` flags at compile-time.
  invokeAmbiguous: function invokeAmbiguous(name, helperCall) {
    this.useRegister('helper');

    var nonHelper = this.popStack();

    this.emptyHash();
    var helper = this.setupHelper(0, name, helperCall);

    var helperName = this.lastHelper = this.nameLookup('helpers', name, 'helper');

    var lookup = ['(', '(helper = ', helperName, ' || ', nonHelper, ')'];
    if (!this.options.strict) {
      lookup[0] = '(helper = ';
      lookup.push(' != null ? helper : ', this.aliasable('container.hooks.helperMissing'));
    }

    this.push(['(', lookup, helper.paramsInit ? ['),(', helper.paramsInit] : [], '),', '(typeof helper === ', this.aliasable('"function"'), ' ? ', this.source.functionCall('helper', 'call', helper.callParams), ' : helper))']);
  },

  // [invokePartial]
  //
  // On stack, before: context, ...
  // On stack after: result of partial invocation
  //
  // This operation pops off a context, invokes a partial with that context,
  // and pushes the result of the invocation back.
  invokePartial: function invokePartial(isDynamic, name, indent) {
    var params = [],
        options = this.setupParams(name, 1, params);

    if (isDynamic) {
      name = this.popStack();
      delete options.name;
    }

    if (indent) {
      options.indent = JSON.stringify(indent);
    }
    options.helpers = 'helpers';
    options.partials = 'partials';
    options.decorators = 'container.decorators';

    if (!isDynamic) {
      params.unshift(this.nameLookup('partials', name, 'partial'));
    } else {
      params.unshift(name);
    }

    if (this.options.compat) {
      options.depths = 'depths';
    }
    options = this.objectLiteral(options);
    params.push(options);

    this.push(this.source.functionCall('container.invokePartial', '', params));
  },

  // [assignToHash]
  //
  // On stack, before: value, ..., hash, ...
  // On stack, after: ..., hash, ...
  //
  // Pops a value off the stack and assigns it to the current hash
  assignToHash: function assignToHash(key) {
    var value = this.popStack(),
        context = undefined,
        type = undefined,
        id = undefined;

    if (this.trackIds) {
      id = this.popStack();
    }
    if (this.stringParams) {
      type = this.popStack();
      context = this.popStack();
    }

    var hash = this.hash;
    if (context) {
      hash.contexts[key] = context;
    }
    if (type) {
      hash.types[key] = type;
    }
    if (id) {
      hash.ids[key] = id;
    }
    hash.values[key] = value;
  },

  pushId: function pushId(type, name, child) {
    if (type === 'BlockParam') {
      this.pushStackLiteral('blockParams[' + name[0] + '].path[' + name[1] + ']' + (child ? ' + ' + JSON.stringify('.' + child) : ''));
    } else if (type === 'PathExpression') {
      this.pushString(name);
    } else if (type === 'SubExpression') {
      this.pushStackLiteral('true');
    } else {
      this.pushStackLiteral('null');
    }
  },

  // HELPERS

  compiler: JavaScriptCompiler,

  compileChildren: function compileChildren(environment, options) {
    var children = environment.children,
        child = undefined,
        compiler = undefined;

    for (var i = 0, l = children.length; i < l; i++) {
      child = children[i];
      compiler = new this.compiler(); // eslint-disable-line new-cap

      var existing = this.matchExistingProgram(child);

      if (existing == null) {
        this.context.programs.push(''); // Placeholder to prevent name conflicts for nested children
        var index = this.context.programs.length;
        child.index = index;
        child.name = 'program' + index;
        this.context.programs[index] = compiler.compile(child, options, this.context, !this.precompile);
        this.context.decorators[index] = compiler.decorators;
        this.context.environments[index] = child;

        this.useDepths = this.useDepths || compiler.useDepths;
        this.useBlockParams = this.useBlockParams || compiler.useBlockParams;
        child.useDepths = this.useDepths;
        child.useBlockParams = this.useBlockParams;
      } else {
        child.index = existing.index;
        child.name = 'program' + existing.index;

        this.useDepths = this.useDepths || existing.useDepths;
        this.useBlockParams = this.useBlockParams || existing.useBlockParams;
      }
    }
  },
  matchExistingProgram: function matchExistingProgram(child) {
    for (var i = 0, len = this.context.environments.length; i < len; i++) {
      var environment = this.context.environments[i];
      if (environment && environment.equals(child)) {
        return environment;
      }
    }
  },

  programExpression: function programExpression(guid) {
    var child = this.environment.children[guid],
        programParams = [child.index, 'data', child.blockParams];

    if (this.useBlockParams || this.useDepths) {
      programParams.push('blockParams');
    }
    if (this.useDepths) {
      programParams.push('depths');
    }

    return 'container.program(' + programParams.join(', ') + ')';
  },

  useRegister: function useRegister(name) {
    if (!this.registers[name]) {
      this.registers[name] = true;
      this.registers.list.push(name);
    }
  },

  push: function push(expr) {
    if (!(expr instanceof Literal)) {
      expr = this.source.wrap(expr);
    }

    this.inlineStack.push(expr);
    return expr;
  },

  pushStackLiteral: function pushStackLiteral(item) {
    this.push(new Literal(item));
  },

  pushSource: function pushSource(source) {
    if (this.pendingContent) {
      this.source.push(this.appendToBuffer(this.source.quotedString(this.pendingContent), this.pendingLocation));
      this.pendingContent = undefined;
    }

    if (source) {
      this.source.push(source);
    }
  },

  replaceStack: function replaceStack(callback) {
    var prefix = ['('],
        stack = undefined,
        createdStack = undefined,
        usedLiteral = undefined;

    /* istanbul ignore next */
    if (!this.isInline()) {
      throw new _exception2['default']('replaceStack on non-inline');
    }

    // We want to merge the inline statement into the replacement statement via ','
    var top = this.popStack(true);

    if (top instanceof Literal) {
      // Literals do not need to be inlined
      stack = [top.value];
      prefix = ['(', stack];
      usedLiteral = true;
    } else {
      // Get or create the current stack name for use by the inline
      createdStack = true;
      var _name = this.incrStack();

      prefix = ['((', this.push(_name), ' = ', top, ')'];
      stack = this.topStack();
    }

    var item = callback.call(this, stack);

    if (!usedLiteral) {
      this.popStack();
    }
    if (createdStack) {
      this.stackSlot--;
    }
    this.push(prefix.concat(item, ')'));
  },

  incrStack: function incrStack() {
    this.stackSlot++;
    if (this.stackSlot > this.stackVars.length) {
      this.stackVars.push('stack' + this.stackSlot);
    }
    return this.topStackName();
  },
  topStackName: function topStackName() {
    return 'stack' + this.stackSlot;
  },
  flushInline: function flushInline() {
    var inlineStack = this.inlineStack;
    this.inlineStack = [];
    for (var i = 0, len = inlineStack.length; i < len; i++) {
      var entry = inlineStack[i];
      /* istanbul ignore if */
      if (entry instanceof Literal) {
        this.compileStack.push(entry);
      } else {
        var stack = this.incrStack();
        this.pushSource([stack, ' = ', entry, ';']);
        this.compileStack.push(stack);
      }
    }
  },
  isInline: function isInline() {
    return this.inlineStack.length;
  },

  popStack: function popStack(wrapped) {
    var inline = this.isInline(),
        item = (inline ? this.inlineStack : this.compileStack).pop();

    if (!wrapped && item instanceof Literal) {
      return item.value;
    } else {
      if (!inline) {
        /* istanbul ignore next */
        if (!this.stackSlot) {
          throw new _exception2['default']('Invalid stack pop');
        }
        this.stackSlot--;
      }
      return item;
    }
  },

  topStack: function topStack() {
    var stack = this.isInline() ? this.inlineStack : this.compileStack,
        item = stack[stack.length - 1];

    /* istanbul ignore if */
    if (item instanceof Literal) {
      return item.value;
    } else {
      return item;
    }
  },

  contextName: function contextName(context) {
    if (this.useDepths && context) {
      return 'depths[' + context + ']';
    } else {
      return 'depth' + context;
    }
  },

  quotedString: function quotedString(str) {
    return this.source.quotedString(str);
  },

  objectLiteral: function objectLiteral(obj) {
    return this.source.objectLiteral(obj);
  },

  aliasable: function aliasable(name) {
    var ret = this.aliases[name];
    if (ret) {
      ret.referenceCount++;
      return ret;
    }

    ret = this.aliases[name] = this.source.wrap(name);
    ret.aliasable = true;
    ret.referenceCount = 1;

    return ret;
  },

  setupHelper: function setupHelper(paramSize, name, blockHelper) {
    var params = [],
        paramsInit = this.setupHelperArgs(name, paramSize, params, blockHelper);
    var foundHelper = this.nameLookup('helpers', name, 'helper'),
        callContext = this.aliasable(this.contextName(0) + ' != null ? ' + this.contextName(0) + ' : (container.nullContext || {})');

    return {
      params: params,
      paramsInit: paramsInit,
      name: foundHelper,
      callParams: [callContext].concat(params)
    };
  },

  setupParams: function setupParams(helper, paramSize, params) {
    var options = {},
        contexts = [],
        types = [],
        ids = [],
        objectArgs = !params,
        param = undefined;

    if (objectArgs) {
      params = [];
    }

    options.name = this.quotedString(helper);
    options.hash = this.popStack();

    if (this.trackIds) {
      options.hashIds = this.popStack();
    }
    if (this.stringParams) {
      options.hashTypes = this.popStack();
      options.hashContexts = this.popStack();
    }

    var inverse = this.popStack(),
        program = this.popStack();

    // Avoid setting fn and inverse if neither are set. This allows
    // helpers to do a check for `if (options.fn)`
    if (program || inverse) {
      options.fn = program || 'container.noop';
      options.inverse = inverse || 'container.noop';
    }

    // The parameters go on to the stack in order (making sure that they are evaluated in order)
    // so we need to pop them off the stack in reverse order
    var i = paramSize;
    while (i--) {
      param = this.popStack();
      params[i] = param;

      if (this.trackIds) {
        ids[i] = this.popStack();
      }
      if (this.stringParams) {
        types[i] = this.popStack();
        contexts[i] = this.popStack();
      }
    }

    if (objectArgs) {
      options.args = this.source.generateArray(params);
    }

    if (this.trackIds) {
      options.ids = this.source.generateArray(ids);
    }
    if (this.stringParams) {
      options.types = this.source.generateArray(types);
      options.contexts = this.source.generateArray(contexts);
    }

    if (this.options.data) {
      options.data = 'data';
    }
    if (this.useBlockParams) {
      options.blockParams = 'blockParams';
    }
    return options;
  },

  setupHelperArgs: function setupHelperArgs(helper, paramSize, params, useRegister) {
    var options = this.setupParams(helper, paramSize, params);
    options.loc = JSON.stringify(this.source.currentLocation);
    options = this.objectLiteral(options);
    if (useRegister) {
      this.useRegister('options');
      params.push('options');
      return ['options=', options];
    } else if (params) {
      params.push(options);
      return '';
    } else {
      return options;
    }
  }
};

(function () {
  var reservedWords = ('break else new var' + ' case finally return void' + ' catch for switch while' + ' continue function this with' + ' default if throw' + ' delete in try' + ' do instanceof typeof' + ' abstract enum int short' + ' boolean export interface static' + ' byte extends long super' + ' char final native synchronized' + ' class float package throws' + ' const goto private transient' + ' debugger implements protected volatile' + ' double import public let yield await' + ' null true false').split(' ');

  var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {};

  for (var i = 0, l = reservedWords.length; i < l; i++) {
    compilerWords[reservedWords[i]] = true;
  }
})();

/**
 * @deprecated May be removed in the next major version
 */
JavaScriptCompiler.isValidJavaScriptVariableName = function (name) {
  return !JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(name);
};

function strictLookup(requireTerminal, compiler, parts, type) {
  var stack = compiler.popStack(),
      i = 0,
      len = parts.length;
  if (requireTerminal) {
    len--;
  }

  for (; i < len; i++) {
    stack = compiler.nameLookup(stack, parts[i], type);
  }

  if (requireTerminal) {
    return [compiler.aliasable('container.strict'), '(', stack, ', ', compiler.quotedString(parts[i]), ', ', JSON.stringify(compiler.source.currentLocation), ' )'];
  } else {
    return stack;
  }
}

exports['default'] = JavaScriptCompiler;
module.exports = exports['default'];

});

var handlebars = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }



var _handlebarsRuntime2 = _interopRequireDefault(handlebars_runtime);

// Compiler imports



var _handlebarsCompilerAst2 = _interopRequireDefault(ast);







var _handlebarsCompilerJavascriptCompiler2 = _interopRequireDefault(javascriptCompiler);



var _handlebarsCompilerVisitor2 = _interopRequireDefault(visitor);



var _handlebarsNoConflict2 = _interopRequireDefault(noConflict);

var _create = _handlebarsRuntime2['default'].create;
function create() {
  var hb = _create();

  hb.compile = function (input, options) {
    return compiler.compile(input, options, hb);
  };
  hb.precompile = function (input, options) {
    return compiler.precompile(input, options, hb);
  };

  hb.AST = _handlebarsCompilerAst2['default'];
  hb.Compiler = compiler.Compiler;
  hb.JavaScriptCompiler = _handlebarsCompilerJavascriptCompiler2['default'];
  hb.Parser = base$1.parser;
  hb.parse = base$1.parse;
  hb.parseWithoutProcessing = base$1.parseWithoutProcessing;

  return hb;
}

var inst = create();
inst.create = create;

_handlebarsNoConflict2['default'](inst);

inst.Visitor = _handlebarsCompilerVisitor2['default'];

inst['default'] = inst;

exports['default'] = inst;
module.exports = exports['default'];

});

var printer = createCommonjsModule(function (module, exports) {

exports.__esModule = true;
exports.print = print;
exports.PrintVisitor = PrintVisitor;
// istanbul ignore next

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }



var _visitor2 = _interopRequireDefault(visitor);

function print(ast) {
  return new PrintVisitor().accept(ast);
}

function PrintVisitor() {
  this.padding = 0;
}

PrintVisitor.prototype = new _visitor2['default']();

PrintVisitor.prototype.pad = function (string) {
  var out = '';

  for (var i = 0, l = this.padding; i < l; i++) {
    out += '  ';
  }

  out += string + '\n';
  return out;
};

PrintVisitor.prototype.Program = function (program) {
  var out = '',
      body = program.body,
      i = undefined,
      l = undefined;

  if (program.blockParams) {
    var blockParams = 'BLOCK PARAMS: [';
    for (i = 0, l = program.blockParams.length; i < l; i++) {
      blockParams += ' ' + program.blockParams[i];
    }
    blockParams += ' ]';
    out += this.pad(blockParams);
  }

  for (i = 0, l = body.length; i < l; i++) {
    out += this.accept(body[i]);
  }

  this.padding--;

  return out;
};

PrintVisitor.prototype.MustacheStatement = function (mustache) {
  return this.pad('{{ ' + this.SubExpression(mustache) + ' }}');
};
PrintVisitor.prototype.Decorator = function (mustache) {
  return this.pad('{{ DIRECTIVE ' + this.SubExpression(mustache) + ' }}');
};

PrintVisitor.prototype.BlockStatement = PrintVisitor.prototype.DecoratorBlock = function (block) {
  var out = '';

  out += this.pad((block.type === 'DecoratorBlock' ? 'DIRECTIVE ' : '') + 'BLOCK:');
  this.padding++;
  out += this.pad(this.SubExpression(block));
  if (block.program) {
    out += this.pad('PROGRAM:');
    this.padding++;
    out += this.accept(block.program);
    this.padding--;
  }
  if (block.inverse) {
    if (block.program) {
      this.padding++;
    }
    out += this.pad('{{^}}');
    this.padding++;
    out += this.accept(block.inverse);
    this.padding--;
    if (block.program) {
      this.padding--;
    }
  }
  this.padding--;

  return out;
};

PrintVisitor.prototype.PartialStatement = function (partial) {
  var content = 'PARTIAL:' + partial.name.original;
  if (partial.params[0]) {
    content += ' ' + this.accept(partial.params[0]);
  }
  if (partial.hash) {
    content += ' ' + this.accept(partial.hash);
  }
  return this.pad('{{> ' + content + ' }}');
};
PrintVisitor.prototype.PartialBlockStatement = function (partial) {
  var content = 'PARTIAL BLOCK:' + partial.name.original;
  if (partial.params[0]) {
    content += ' ' + this.accept(partial.params[0]);
  }
  if (partial.hash) {
    content += ' ' + this.accept(partial.hash);
  }

  content += ' ' + this.pad('PROGRAM:');
  this.padding++;
  content += this.accept(partial.program);
  this.padding--;

  return this.pad('{{> ' + content + ' }}');
};

PrintVisitor.prototype.ContentStatement = function (content) {
  return this.pad("CONTENT[ '" + content.value + "' ]");
};

PrintVisitor.prototype.CommentStatement = function (comment) {
  return this.pad("{{! '" + comment.value + "' }}");
};

PrintVisitor.prototype.SubExpression = function (sexpr) {
  var params = sexpr.params,
      paramStrings = [],
      hash = undefined;

  for (var i = 0, l = params.length; i < l; i++) {
    paramStrings.push(this.accept(params[i]));
  }

  params = '[' + paramStrings.join(', ') + ']';

  hash = sexpr.hash ? ' ' + this.accept(sexpr.hash) : '';

  return this.accept(sexpr.path) + ' ' + params + hash;
};

PrintVisitor.prototype.PathExpression = function (id) {
  var path = id.parts.join('/');
  return (id.data ? '@' : '') + 'PATH:' + path;
};

PrintVisitor.prototype.StringLiteral = function (string) {
  return '"' + string.value + '"';
};

PrintVisitor.prototype.NumberLiteral = function (number) {
  return 'NUMBER{' + number.value + '}';
};

PrintVisitor.prototype.BooleanLiteral = function (bool) {
  return 'BOOLEAN{' + bool.value + '}';
};

PrintVisitor.prototype.UndefinedLiteral = function () {
  return 'UNDEFINED';
};

PrintVisitor.prototype.NullLiteral = function () {
  return 'NULL';
};

PrintVisitor.prototype.Hash = function (hash) {
  var pairs = hash.pairs,
      joinedPairs = [];

  for (var i = 0, l = pairs.length; i < l; i++) {
    joinedPairs.push(this.accept(pairs[i]));
  }

  return 'HASH{' + joinedPairs.join(', ') + '}';
};
PrintVisitor.prototype.HashPair = function (pair) {
  return pair.key + '=' + this.accept(pair.value);
};
/* eslint-enable new-cap */

});

// USAGE:
// var handlebars = require('handlebars');
/* eslint-disable no-var */

// var local = handlebars.create();

var handlebars$1 = handlebars['default'];


handlebars$1.PrintVisitor = printer.PrintVisitor;
handlebars$1.print = printer.print;

var lib = handlebars$1;

// Publish a Node.js require() handler for .handlebars and .hbs files
function extension(module, filename) {
  var fs = fs__default['default'];
  var templateString = fs.readFileSync(filename, 'utf8');
  module.exports = handlebars$1.compile(templateString);
}
/* istanbul ignore else */
if (typeof commonjsRequire !== 'undefined' && commonjsRequire.extensions) {
  commonjsRequire.extensions['.handlebars'] = extension;
  commonjsRequire.extensions['.hbs'] = extension;
}

/**
 * Defines an event manager for the citations plugin.
 */
var CitationEvents = /** @class */ (function (_super) {
    __extends(CitationEvents, _super);
    function CitationEvents() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    CitationEvents.prototype.on = function (name, callback, ctx) {
        return _super.prototype.on.call(this, name, callback, ctx);
    };
    CitationEvents.prototype.trigger = function (name) {
        var data = [];
        for (var _i = 1; _i < arguments.length; _i++) {
            data[_i - 1] = arguments[_i];
        }
        _super.prototype.trigger.call(this, name, data);
    };
    return CitationEvents;
}(obsidian.Events));

var SearchModal = /** @class */ (function (_super) {
    __extends(SearchModal, _super);
    function SearchModal(app, plugin) {
        var _this = _super.call(this, app) || this;
        _this.limit = 50;
        _this.plugin = plugin;
        _this.resultContainerEl.addClass('zoteroModalResults');
        _this.inputEl.setAttribute('spellcheck', 'false');
        _this.loadingEl = _this.resultContainerEl.parentElement.createEl('div', {
            cls: 'zoteroModalLoading',
        });
        _this.loadingEl.createEl('div', { cls: 'zoteroModalLoadingAnimation' });
        _this.loadingEl.createEl('p', {
            text: 'Loading citation database. Please wait...',
        });
        return _this;
    }
    SearchModal.prototype.onOpen = function () {
        var _this = this;
        _super.prototype.onOpen.call(this);
        this.eventRefs = [
            this.plugin.events.on('library-load-start', function () {
                _this.setLoading(true);
            }),
            this.plugin.events.on('library-load-complete', function () {
                _this.setLoading(false);
            }),
        ];
        this.setLoading(this.plugin.isLibraryLoading);
        // Don't immediately register keyevent listeners. If the modal was triggered
        // by an "Enter" keystroke (e.g. via the Obsidian command dialog), this event
        // will be received here erroneously.
        setTimeout(function () {
            _this.inputEl.addEventListener('keydown', function (ev) { return _this.onInputKeydown(ev); });
            _this.inputEl.addEventListener('keyup', function (ev) { return _this.onInputKeyup(ev); });
        }, 200);
    };
    SearchModal.prototype.onClose = function () {
        var _this = this;
        var _a;
        (_a = this.eventRefs) === null || _a === void 0 ? void 0 : _a.forEach(function (e) { return _this.plugin.events.offref(e); });
    };
    SearchModal.prototype.getItems = function () {
        if (this.plugin.isLibraryLoading) {
            return [];
        }
        return Object.values(this.plugin.library.entries);
    };
    SearchModal.prototype.getItemText = function (item) {
        return item.title + " " + item.authorString + " " + item.year;
    };
    SearchModal.prototype.setLoading = function (loading) {
        if (loading) {
            this.loadingEl.removeClass('d-none');
            this.inputEl.disabled = true;
            this.resultContainerEl.empty();
        }
        else {
            this.loadingEl.addClass('d-none');
            this.inputEl.disabled = false;
            this.inputEl.focus();
            // @ts-ignore: not exposed in API.
            this.updateSuggestions();
        }
    };
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    SearchModal.prototype.onChooseItem = function (item, evt) {
        this.plugin.openLiteratureNote(item.id, false).catch(console.error);
    };
    SearchModal.prototype.renderSuggestion = function (match, el) {
        el.empty();
        var entry = match.item;
        var entryTitle = entry.title || '';
        var container = el.createEl('div', { cls: 'zoteroResult' });
        var titleEl = container.createEl('span', {
            cls: 'zoteroTitle',
        });
        container.createEl('span', { cls: 'zoteroCitekey', text: entry.id });
        var authorsCls = entry.authorString
            ? 'zoteroAuthors'
            : 'zoteroAuthors zoteroAuthorsEmpty';
        var authorsEl = container.createEl('span', {
            cls: authorsCls,
        });
        // Prepare to highlight string matches for each part of the search item.
        // Compute offsets of each rendered element's content within the string
        // returned by `getItemText`.
        var allMatches = match.match.matches;
        var authorStringOffset = 1 + entryTitle.length;
        // Filter a match list to contain only the relevant matches for a given
        // substring, and with match indices shifted relative to the start of that
        // substring
        var shiftMatches = function (matches, start, end) {
            return matches
                .map(function (match) {
                var matchStart = match[0], matchEnd = match[1];
                return [
                    matchStart - start,
                    Math.min(matchEnd - start, end),
                ];
            })
                .filter(function (match) {
                var matchStart = match[0], matchEnd = match[1];
                return matchStart >= 0;
            });
        };
        // Now highlight matched strings within each element
        obsidian.renderMatches(titleEl, entryTitle, shiftMatches(allMatches, 0, entryTitle.length));
        if (entry.authorString) {
            obsidian.renderMatches(authorsEl, entry.authorString, shiftMatches(allMatches, authorStringOffset, authorStringOffset + entry.authorString.length));
        }
    };
    SearchModal.prototype.onInputKeydown = function (ev) {
        if (ev.key == 'Tab') {
            ev.preventDefault();
        }
    };
    SearchModal.prototype.onInputKeyup = function (ev) {
        if (ev.key == 'Enter' || ev.key == 'Tab') {
            this.chooser.useSelectedItem(ev);
        }
    };
    return SearchModal;
}(obsidian.FuzzySuggestModal));
var OpenNoteModal = /** @class */ (function (_super) {
    __extends(OpenNoteModal, _super);
    function OpenNoteModal(app, plugin) {
        var _this = _super.call(this, app, plugin) || this;
        _this.setInstructions([
            { command: '↑↓', purpose: 'to navigate' },
            { command: '↵', purpose: 'to open literature note' },
            { command: 'ctrl ↵', purpose: 'to open literature note in a new pane' },
            { command: 'tab', purpose: 'open in Zotero' },
            { command: 'shift tab', purpose: 'open PDF' },
            { command: 'esc', purpose: 'to dismiss' },
        ]);
        return _this;
    }
    OpenNoteModal.prototype.onChooseItem = function (item, evt) {
        if (evt instanceof MouseEvent || evt.key == 'Enter') {
            var newPane = evt instanceof KeyboardEvent && evt.ctrlKey;
            this.plugin.openLiteratureNote(item.id, newPane);
        }
        else if (evt.key == 'Tab') {
            if (evt.shiftKey) {
                var files = item.files || [];
                var pdfPaths = files.filter(function (path) {
                    return path.toLowerCase().endsWith('pdf');
                });
                if (pdfPaths.length == 0) {
                    new obsidian.Notice('This reference has no associated PDF files.');
                }
                else {
                    open("file://" + pdfPaths[0]);
                }
            }
            else {
                open(item.zoteroSelectURI);
            }
        }
    };
    return OpenNoteModal;
}(SearchModal));
var InsertNoteLinkModal = /** @class */ (function (_super) {
    __extends(InsertNoteLinkModal, _super);
    function InsertNoteLinkModal(app, plugin) {
        var _this = _super.call(this, app, plugin) || this;
        _this.setInstructions([
            { command: '↑↓', purpose: 'to navigate' },
            { command: '↵', purpose: 'to insert literature note reference' },
            { command: 'esc', purpose: 'to dismiss' },
        ]);
        return _this;
    }
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    InsertNoteLinkModal.prototype.onChooseItem = function (item, evt) {
        this.plugin.insertLiteratureNoteLink(item.id).catch(console.error);
    };
    return InsertNoteLinkModal;
}(SearchModal));
var InsertNoteContentModal = /** @class */ (function (_super) {
    __extends(InsertNoteContentModal, _super);
    function InsertNoteContentModal(app, plugin) {
        var _this = _super.call(this, app, plugin) || this;
        _this.setInstructions([
            { command: '↑↓', purpose: 'to navigate' },
            {
                command: '↵',
                purpose: 'to insert literature note content in active pane',
            },
            { command: 'esc', purpose: 'to dismiss' },
        ]);
        return _this;
    }
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    InsertNoteContentModal.prototype.onChooseItem = function (item, evt) {
        this.plugin.insertLiteratureNoteContent(item.id).catch(console.error);
    };
    return InsertNoteContentModal;
}(SearchModal));
var InsertCitationModal = /** @class */ (function (_super) {
    __extends(InsertCitationModal, _super);
    function InsertCitationModal(app, plugin) {
        var _this = _super.call(this, app, plugin) || this;
        _this.setInstructions([
            { command: '↑↓', purpose: 'to navigate' },
            { command: '↵', purpose: 'to insert Markdown citation' },
            { command: 'shift ↵', purpose: 'to insert secondary Markdown citation' },
            { command: 'esc', purpose: 'to dismiss' },
        ]);
        return _this;
    }
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    InsertCitationModal.prototype.onChooseItem = function (item, evt) {
        var isAlternative = evt instanceof KeyboardEvent && evt.shiftKey;
        this.plugin
            .insertMarkdownCitation(item.id, isAlternative)
            .catch(console.error);
    };
    return InsertCitationModal;
}(SearchModal));

/*
 * Generated by PEG.js 0.10.0.
 *
 * http://pegjs.org/
 */

function peg$subclass(child, parent) {
  function ctor() { this.constructor = child; }
  ctor.prototype = parent.prototype;
  child.prototype = new ctor();
}

function peg$SyntaxError(message, expected, found, location) {
  this.message  = message;
  this.expected = expected;
  this.found    = found;
  this.location = location;
  this.name     = "SyntaxError";

  if (typeof Error.captureStackTrace === "function") {
    Error.captureStackTrace(this, peg$SyntaxError);
  }
}

peg$subclass(peg$SyntaxError, Error);

peg$SyntaxError.buildMessage = function(expected, found) {
  var DESCRIBE_EXPECTATION_FNS = {
        literal: function(expectation) {
          return "\"" + literalEscape(expectation.text) + "\"";
        },

        "class": function(expectation) {
          var escapedParts = "",
              i;

          for (i = 0; i < expectation.parts.length; i++) {
            escapedParts += expectation.parts[i] instanceof Array
              ? classEscape(expectation.parts[i][0]) + "-" + classEscape(expectation.parts[i][1])
              : classEscape(expectation.parts[i]);
          }

          return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]";
        },

        any: function(expectation) {
          return "any character";
        },

        end: function(expectation) {
          return "end of input";
        },

        other: function(expectation) {
          return expectation.description;
        }
      };

  function hex(ch) {
    return ch.charCodeAt(0).toString(16).toUpperCase();
  }

  function literalEscape(s) {
    return s
      .replace(/\\/g, '\\\\')
      .replace(/"/g,  '\\"')
      .replace(/\0/g, '\\0')
      .replace(/\t/g, '\\t')
      .replace(/\n/g, '\\n')
      .replace(/\r/g, '\\r')
      .replace(/[\x00-\x0F]/g,          function(ch) { return '\\x0' + hex(ch); })
      .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x'  + hex(ch); });
  }

  function classEscape(s) {
    return s
      .replace(/\\/g, '\\\\')
      .replace(/\]/g, '\\]')
      .replace(/\^/g, '\\^')
      .replace(/-/g,  '\\-')
      .replace(/\0/g, '\\0')
      .replace(/\t/g, '\\t')
      .replace(/\n/g, '\\n')
      .replace(/\r/g, '\\r')
      .replace(/[\x00-\x0F]/g,          function(ch) { return '\\x0' + hex(ch); })
      .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x'  + hex(ch); });
  }

  function describeExpectation(expectation) {
    return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
  }

  function describeExpected(expected) {
    var descriptions = new Array(expected.length),
        i, j;

    for (i = 0; i < expected.length; i++) {
      descriptions[i] = describeExpectation(expected[i]);
    }

    descriptions.sort();

    if (descriptions.length > 0) {
      for (i = 1, j = 1; i < descriptions.length; i++) {
        if (descriptions[i - 1] !== descriptions[i]) {
          descriptions[j] = descriptions[i];
          j++;
        }
      }
      descriptions.length = j;
    }

    switch (descriptions.length) {
      case 1:
        return descriptions[0];

      case 2:
        return descriptions[0] + " or " + descriptions[1];

      default:
        return descriptions.slice(0, -1).join(", ")
          + ", or "
          + descriptions[descriptions.length - 1];
    }
  }

  function describeFound(found) {
    return found ? "\"" + literalEscape(found) + "\"" : "end of input";
  }

  return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
};

function peg$parse(input, options) {
  options = options !== void 0 ? options : {};

  var peg$FAILED = {},

      peg$startRuleFunctions = { Bibliography: peg$parseBibliography },
      peg$startRuleFunction  = peg$parseBibliography,

      peg$c0 = function(r) {
          return {
            kind: 'Bibliography',
            loc: location(),
            source: text(),
            children: r,
          }
        },
      peg$c1 = "@",
      peg$c2 = peg$literalExpectation("@", false),
      peg$c3 = "comment",
      peg$c4 = peg$literalExpectation("comment", true),
      peg$c5 = function(v) {
          return {
            kind: 'BracedComment',
            loc: location(),
            source: text(),
            value: v.slice(1, -1),
          }
        },
      peg$c6 = /^[^\n\r]/,
      peg$c7 = peg$classExpectation(["\n", "\r"], true, false),
      peg$c8 = /^[\n\r]/,
      peg$c9 = peg$classExpectation(["\n", "\r"], false, false),
      peg$c10 = function(v) {
          return {
            kind: 'LineComment',
            loc: location(),
            source: text(),
            value: normalizeWhitespace(v),
          }
          },
      peg$c11 = /^[^@]/,
      peg$c12 = peg$classExpectation(["@"], true, false),
      peg$c13 = function(v) {
          return {
            kind: 'NonEntryText',
            loc: location(),
            source: text(),
            value: normalizeWhitespace(v),
          }
        },
      peg$c14 = function(n) { return n; },
      peg$c15 = "{",
      peg$c16 = peg$literalExpectation("{", false),
      peg$c17 = /^[^{}]/,
      peg$c18 = peg$classExpectation(["{", "}"], true, false),
      peg$c19 = "}",
      peg$c20 = peg$literalExpectation("}", false),
      peg$c21 = function(comment) { return '{' + comment.join('') + '}' },
      peg$c22 = /^[A-Za-z]/,
      peg$c23 = peg$classExpectation([["A", "Z"], ["a", "z"]], false, false),
      peg$c24 = /^[({]/,
      peg$c25 = peg$classExpectation(["(", "{"], false, false),
      peg$c26 = /^[})]/,
      peg$c27 = peg$classExpectation(["}", ")"], false, false),
      peg$c28 = function(type, id, fields) {
          return {
            kind: 'Entry',
            id: id || '',
            type: type.toLowerCase(),
            loc: location(),
            source: text(),
            fields: fields,
          }
        },
      peg$c29 = "preamble",
      peg$c30 = peg$literalExpectation("preamble", true),
      peg$c31 = function(opener, v, closer) {
          switch (opener + closer) {
            case '{}':
            case '()':
              break
            default:
              throw new Error(`Unbalanced opener-closer for preamble: ${opener}...${closer}`)
          }
          return {
            kind: 'PreambleExpression',
            loc: location(),
            source: text(),
            value: v.reduce((a, b) => a.concat(b), []),
          }
        },
      peg$c32 = "string",
      peg$c33 = peg$literalExpectation("string", true),
      peg$c34 = function(k, v) {
          return {
            kind: 'StringDeclaration',
            loc: location(),
            source: text(),
            name: k,
            value: v.reduce((a, b) => a.concat(b), []),
          }
        },
      peg$c35 = /^[^ \t\r\n,]/,
      peg$c36 = peg$classExpectation([" ", "\t", "\r", "\n", ","], true, false),
      peg$c37 = ",",
      peg$c38 = peg$literalExpectation(",", false),
      peg$c39 = function(id) { return id; },
      peg$c40 = function(name) { return isVerbatimField(name) && unnestFields.includes(name) },
      peg$c41 = function(name, value) {
          // because this was abused so much, many processors treat double-outer-braces as single
          return {
            kind: 'Field',
            loc: location(),
            source: text(),
            name: name,
            loc: location(),
            value: [ protect(value) ]
          }
        },
      peg$c42 = function(name) { return isVerbatimField(name) },
      peg$c43 = function(name, value) {
          return {
            kind: 'Field',
            loc: location(),
            source: text(),
            name: name,
            loc: location(),
            value: [ protect(value) ]
          }
        },
      peg$c44 = function(name, value) {
          // because this was abused so much, many processors treat double-outer-braces as single
          if (unnestFields.includes(name) && Array.isArray(value) && value.length === 1 && value[0].kind === 'Block') {
            if (options.unnestMode === 'preserve') {
              value[0].case = 'preserve';
            } else {
              value = value[0].value;
            }
          }

          return handle_markup_switches({
            kind: 'Field',
            loc: location(),
            source: text(),
            name: name,
            value: value,
          })
        },
      peg$c45 = /^[_:a-zA-Z0-9\-]/,
      peg$c46 = peg$classExpectation(["_", ":", ["a", "z"], ["A", "Z"], ["0", "9"], "-"], false, false),
      peg$c47 = function(name) { return name.toLowerCase() },
      peg$c48 = "\"",
      peg$c49 = peg$literalExpectation("\"", false),
      peg$c50 = function(v) {
          v = v || {
            kind: 'Text',
            loc: location(),
            source: text(),
            value: '',
          };
          v.mode = 'verbatim';
          return basicTextConversions(v)
        },
      peg$c51 = function(v) {
          return basicTextConversions({
            kind: 'Text',
            loc: location(),
            source: text(),
            value: v.join('').trim(),
            mode: 'verbatim',
          })
        },
      peg$c52 = function(v) { return v },
      peg$c53 = function(v) { return '{' + v.join('') + '}' },
      peg$c54 = function() { return math.set(false) },
      peg$c55 = function(v) {
          return v.reduce((a, b) => a.concat(b), []);
        },
      peg$c56 = function(v) { return v; },
      peg$c57 = "{\\verb",
      peg$c58 = peg$literalExpectation("{\\verb", false),
      peg$c59 = /^[a-zA-Z]/,
      peg$c60 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false),
      peg$c61 = /^[^\^_${}\\]/,
      peg$c62 = peg$classExpectation(["^", "_", "$", "{", "}", "\\"], true, false),
      peg$c63 = function(v) {
          return basicTextConversions({
            kind: 'Text',
            loc: location(),
            source: text(),
            value: normalizeWhitespace(v),
            mode: math.on ? 'math' : 'text',
          })
        },
      peg$c64 = /^[^\^_${}"\\]/,
      peg$c65 = peg$classExpectation(["^", "_", "$", "{", "}", "\"", "\\"], true, false),
      peg$c66 = /^[0-9]/,
      peg$c67 = peg$classExpectation([["0", "9"]], false, false),
      peg$c68 = function(v) {
          return {
            kind: 'Number',
            loc: location(),
            source: text(),
            value: parseInt(v, 10),
          }
        },
      peg$c69 = function(v) {
          return {
            kind: 'StringReference',
            loc: location(),
            source: text(),
            name: v,
          }
        },
      peg$c70 = "\\begin{",
      peg$c71 = peg$literalExpectation("\\begin{", false),
      peg$c72 = /^[a-zA-Z0-9]/,
      peg$c73 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"]], false, false),
      peg$c74 = "\\end{",
      peg$c75 = peg$literalExpectation("\\end{", false),
      peg$c76 = function(env, v, cenv) { return env === cenv },
      peg$c77 = function(env, v, cenv) {
          if (markup[env]) {
            return {
              kind: 'Block',
              loc: location(),
              source: text(),
              value: v,
              markup: { [markup[env]]: true },
            }
          } else {
            return {
              kind: 'Environment',
              loc: location(),
              source: text(),
              value: v,
              env: env,
            }
          }
        },
      peg$c78 = "{\\",
      peg$c79 = peg$literalExpectation("{\\", false),
      peg$c80 = "\\",
      peg$c81 = peg$literalExpectation("\\", false),
      peg$c82 = /^[ij]/,
      peg$c83 = peg$classExpectation(["i", "j"], false, false),
      peg$c84 = function(mark, char) {
          return {
            kind: 'DiacriticCommand',
            loc: location(),
            source: text(),
            mark: mark,
            dotless: !!char[1],
            character: char[1] || char[0],
          }
        },
      peg$c85 = function(v) {
            return basicTextConversions({
              kind: 'Text',
              loc: location(),
              source: text(),
              value: v.join('').trim(),
              mode: 'verbatim',
            })
        },
      peg$c86 = function(v) {
          const block = {
            kind: 'Block',
            loc: location(),
            source: text(),
            value: v,
            markup: {},
            case: 'protect',
          };

          let leadingcmd = block.value.length && (block.value[0].kind.endsWith('Command') || block.value[0].kind === 'Environment') ? block.value[0] : null;
          let leadingcmdblockarg = leadingcmd
            && leadingcmd.kind === 'RegularCommand'
            && leadingcmd.arguments.required.length
            && leadingcmd.arguments.required[0].kind === 'Block'
            && leadingcmd.arguments.required[0];

          // https://github.com/retorquere/zotero-better-bibtex/issues/541#issuecomment-240156274
          if (leadingcmd) {
            delete block.case;

            // command with a block cancels out case protection with containing block
            // if a smallcaps block has set case to 'preserve' we want to keep this
            if (leadingcmdblockarg && leadingcmdblockarg.case === 'protect') delete leadingcmdblockarg.case;

            // \sl, \it etc
            if (markup[leadingcmd.command]) {
              block.markup[markup[leadingcmd.command]] = true;
              block.value.shift();
            }
          }

          return handle_markup_switches(block)
        },
      peg$c87 = function() { return !math.on },
      peg$c88 = "$",
      peg$c89 = peg$literalExpectation("$", false),
      peg$c90 = "$$",
      peg$c91 = peg$literalExpectation("$$", false),
      peg$c92 = function(mode) { return math.set(true) },
      peg$c93 = function(mode, v) { return math.set(false) },
      peg$c94 = function(mode, v) {
          return {
            kind: mode == '$$' ? 'DisplayMath' : 'InlineMath',
            loc: location(),
            source: text(),
            value: v,
            case: 'protect',
            markup: {},
          }
        },
      peg$c95 = "%",
      peg$c96 = peg$literalExpectation("%", false),
      peg$c97 = /^[^\r\n]/,
      peg$c98 = peg$classExpectation(["\r", "\n"], true, false),
      peg$c99 = function(v) {
          return {
            kind: 'LineComment',
            loc: location(),
            source: text(),
            value: v,
          }
        },
      peg$c100 = /^[_\^]/,
      peg$c101 = peg$classExpectation(["_", "^"], false, false),
      peg$c102 = function(mode, v) {
          if (v.kind === 'Block') v = v.value;

          return {
            kind: mode === '_' ? 'SubscriptCommand' : 'SuperscriptCommand',
            loc: location(),
            source: text(),
            value: v,
          }
        },
      peg$c103 = function(mark, v) {
          return {
            kind: 'RegularCommand',
            loc: location(),
            source: text(),
            command: mark,
            arguments: {
              optional: [],
              required: [ protect(v) ],
            },
          }
        },
      peg$c104 = /^[^A-Za-z0-9\t\r\n]/,
      peg$c105 = peg$classExpectation([["A", "Z"], ["a", "z"], ["0", "9"], "\t", "\r", "\n"], true, false),
      peg$c106 = function(v) {
          return {
            kind: 'SymbolCommand',
            loc: location(),
            source: text(),
            command: v,
          }
        },
      peg$c107 = "newcommand",
      peg$c108 = peg$literalExpectation("newcommand", false),
      peg$c109 = function(cmd, name) { return name.value.length == 1 && name.value[0].kind === 'RegularCommand' },
      peg$c110 = function(cmd, name, optional, def) {
          return {
            kind: 'RegularCommand',
            loc: location(),
            source: text(),
            command: cmd,
            arguments: {
              optional: [],
              required: [name, def],
            },
          }
        },
      peg$c111 = "begin",
      peg$c112 = peg$literalExpectation("begin", false),
      peg$c113 = "end",
      peg$c114 = peg$literalExpectation("end", false),
      peg$c115 = function(cmd) { return verbatimCommands.includes(cmd) && (has_arguments[cmd] === 2) },
      peg$c116 = function(cmd, optional, req1, req2) {
          return {
            kind: 'RegularCommand',
            loc: location(),
            source: text(),
            command: cmd,
            arguments: {
              optional: optional,
              required: [protect(req1), protect(req2)],
            },
          }
        },
      peg$c117 = function(cmd) { return verbatimCommands.includes(cmd) && (has_arguments[cmd] === 1) },
      peg$c118 = function(cmd, optional, req) {
          return {
            kind: 'RegularCommand',
            loc: location(),
            source: text(),
            command: cmd,
            arguments: {
              optional: optional,
              required: [protect(req)],
            },
          }
        },
      peg$c119 = function(cmd) { return (has_arguments[cmd] === 2) },
      peg$c120 = function(cmd, optional, req1, req2) {
          return {
            kind: 'RegularCommand',
            loc: location(),
            source: text(),
            command: cmd,
            arguments: {
              optional: optional,
              required: [req1, req2],
            },
          }
        },
      peg$c121 = function(cmd) { return (has_arguments[cmd] === 1) },
      peg$c122 = function(cmd, optional, req) {
          let m;
          if (req.kind === 'Block') {
            switch (cmd) {
              case 'textsuperscript':
              case 'sp':
                req.markup.sup = true;
                break
              case 'textsubscript':
              case 'sb':
                req.markup.sub = true;
                break
              case 'textsc':
                req.markup.smallCaps = true;
                break
              case 'enquote':
              case 'mkbibquote':
                req.markup.enquote = true;
                break
              case 'textbf':
              case 'mkbibbold':
                req.markup.bold = true;
                break
              case 'emph':
              case 'textit':
              case 'mkbibitalic':
              case 'mkbibemph':
                req.markup.italics = true;
                break
              default:
                if (m = cmd.match(/^((sub)*)section$/)) {
                  req.markup[`h${(m[1].length / 3) + 1}`] = true;
                }
            }
          }

          // ignore case stuff on bibcyr
          if (cmd === 'bibcyr') delete req.case;

          return {
            kind: 'RegularCommand',
            loc: location(),
            source: text(),
            command: cmd,
            arguments: {
              optional: optional,
              required: [req],
            }
          }
        },
      peg$c123 = function(cmd, optional) {
          return {
            kind: 'RegularCommand',
            loc: location(),
            source: text(),
            command: cmd,
            arguments: {
              optional: optional,
              required: [],
            }
          }
        },
      peg$c124 = "[",
      peg$c125 = peg$literalExpectation("[", false),
      peg$c126 = /^[^\]]/,
      peg$c127 = peg$classExpectation(["]"], true, false),
      peg$c128 = "]",
      peg$c129 = peg$literalExpectation("]", false),
      peg$c130 = function(v) {
          return basicTextConversions({
            kind: 'Text', // this isn't really correct but I don't need these right now
            loc: location(),
            source: text(),
            value: v,
            mode: math.on ? 'math' : 'text',
          })
        },
      peg$c131 = /^[^ \t\^_${}\\]/,
      peg$c132 = peg$classExpectation([" ", "\t", "^", "_", "$", "{", "}", "\\"], true, false),
      peg$c133 = function(v) {
          return basicTextConversions({
            kind: 'Text',
            loc: location(),
            source: text(),
            value: normalizeWhitespace([v]),
            mode: math.on ? 'math' : 'text',
          })
        },
      peg$c134 = /^[a-zA-Z\-_]/,
      peg$c135 = peg$classExpectation([["a", "z"], ["A", "Z"], "-", "_"], false, false),
      peg$c136 = /^[a-zA-Z0-9\-&_:]/,
      peg$c137 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "-", "&", "_", ":"], false, false),
      peg$c138 = /^['`"=~\^.]/,
      peg$c139 = peg$classExpectation(["'", "`", "\"", "=", "~", "^", "."], false, false),
      peg$c140 = /^['`"=~\^.cbuvdrHk]/,
      peg$c141 = peg$classExpectation(["'", "`", "\"", "=", "~", "^", ".", "c", "b", "u", "v", "d", "r", "H", "k"], false, false),
      peg$c142 = "=",
      peg$c143 = peg$literalExpectation("=", false),
      peg$c144 = "#",
      peg$c145 = peg$literalExpectation("#", false),
      peg$c146 = /^[\r\n]/,
      peg$c147 = peg$classExpectation(["\r", "\n"], false, false),
      peg$c149 = /^[ \t]/,
      peg$c150 = peg$classExpectation([" ", "\t"], false, false),
      peg$c151 = peg$otherExpectation("Optional Horizontal Whitespace"),
      peg$c155 = /^[ \t\n\r]/,
      peg$c156 = peg$classExpectation([" ", "\t", "\n", "\r"], false, false),
      peg$c157 = peg$otherExpectation("Optional Whitespace"),

      peg$currPos          = 0,
      peg$savedPos         = 0,
      peg$posDetailsCache  = [{ line: 1, column: 1 }],
      peg$maxFailPos       = 0,
      peg$maxFailExpected  = [],
      peg$silentFails      = 0,

      peg$result;

  if ("startRule" in options) {
    if (!(options.startRule in peg$startRuleFunctions)) {
      throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
    }

    peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
  }

  function text() {
    return input.substring(peg$savedPos, peg$currPos);
  }

  function location() {
    return peg$computeLocation(peg$savedPos, peg$currPos);
  }

  function peg$literalExpectation(text, ignoreCase) {
    return { type: "literal", text: text, ignoreCase: ignoreCase };
  }

  function peg$classExpectation(parts, inverted, ignoreCase) {
    return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase };
  }

  function peg$endExpectation() {
    return { type: "end" };
  }

  function peg$otherExpectation(description) {
    return { type: "other", description: description };
  }

  function peg$computePosDetails(pos) {
    var details = peg$posDetailsCache[pos], p;

    if (details) {
      return details;
    } else {
      p = pos - 1;
      while (!peg$posDetailsCache[p]) {
        p--;
      }

      details = peg$posDetailsCache[p];
      details = {
        line:   details.line,
        column: details.column
      };

      while (p < pos) {
        if (input.charCodeAt(p) === 10) {
          details.line++;
          details.column = 1;
        } else {
          details.column++;
        }

        p++;
      }

      peg$posDetailsCache[pos] = details;
      return details;
    }
  }

  function peg$computeLocation(startPos, endPos) {
    var startPosDetails = peg$computePosDetails(startPos),
        endPosDetails   = peg$computePosDetails(endPos);

    return {
      start: {
        offset: startPos,
        line:   startPosDetails.line,
        column: startPosDetails.column
      },
      end: {
        offset: endPos,
        line:   endPosDetails.line,
        column: endPosDetails.column
      }
    };
  }

  function peg$fail(expected) {
    if (peg$currPos < peg$maxFailPos) { return; }

    if (peg$currPos > peg$maxFailPos) {
      peg$maxFailPos = peg$currPos;
      peg$maxFailExpected = [];
    }

    peg$maxFailExpected.push(expected);
  }

  function peg$buildStructuredError(expected, found, location) {
    return new peg$SyntaxError(
      peg$SyntaxError.buildMessage(expected, found),
      expected,
      found,
      location
    );
  }

  function peg$parseBibliography() {
    var s0, s1, s2, s3;

    s0 = peg$currPos;
    s1 = peg$parse__();
    if (s1 !== peg$FAILED) {
      s2 = [];
      s3 = peg$parseNode();
      while (s3 !== peg$FAILED) {
        s2.push(s3);
        s3 = peg$parseNode();
      }
      if (s2 !== peg$FAILED) {
        s3 = peg$parse__();
        if (s3 !== peg$FAILED) {
          peg$savedPos = s0;
          s1 = peg$c0(s2);
          s0 = s1;
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseComment() {
    var s0, s1, s2, s3, s4, s5, s6, s7;

    s0 = peg$currPos;
    if (input.charCodeAt(peg$currPos) === 64) {
      s1 = peg$c1;
      peg$currPos++;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c2); }
    }
    if (s1 !== peg$FAILED) {
      s2 = peg$parse__();
      if (s2 !== peg$FAILED) {
        if (input.substr(peg$currPos, 7).toLowerCase() === peg$c3) {
          s3 = input.substr(peg$currPos, 7);
          peg$currPos += 7;
        } else {
          s3 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c4); }
        }
        if (s3 !== peg$FAILED) {
          s4 = peg$parse__h();
          if (s4 !== peg$FAILED) {
            s5 = peg$parseBracedComment();
            if (s5 !== peg$FAILED) {
              peg$savedPos = s0;
              s1 = peg$c5(s5);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }
    if (s0 === peg$FAILED) {
      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 64) {
        s1 = peg$c1;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c2); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$parse__();
        if (s2 !== peg$FAILED) {
          if (input.substr(peg$currPos, 7).toLowerCase() === peg$c3) {
            s3 = input.substr(peg$currPos, 7);
            peg$currPos += 7;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c4); }
          }
          if (s3 !== peg$FAILED) {
            s4 = peg$parse__h();
            if (s4 !== peg$FAILED) {
              s5 = [];
              if (peg$c6.test(input.charAt(peg$currPos))) {
                s6 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s6 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c7); }
              }
              while (s6 !== peg$FAILED) {
                s5.push(s6);
                if (peg$c6.test(input.charAt(peg$currPos))) {
                  s6 = input.charAt(peg$currPos);
                  peg$currPos++;
                } else {
                  s6 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c7); }
                }
              }
              if (s5 !== peg$FAILED) {
                s6 = [];
                if (peg$c8.test(input.charAt(peg$currPos))) {
                  s7 = input.charAt(peg$currPos);
                  peg$currPos++;
                } else {
                  s7 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c9); }
                }
                while (s7 !== peg$FAILED) {
                  s6.push(s7);
                  if (peg$c8.test(input.charAt(peg$currPos))) {
                    s7 = input.charAt(peg$currPos);
                    peg$currPos++;
                  } else {
                    s7 = peg$FAILED;
                    if (peg$silentFails === 0) { peg$fail(peg$c9); }
                  }
                }
                if (s6 !== peg$FAILED) {
                  peg$savedPos = s0;
                  s1 = peg$c10(s5);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        s1 = peg$currPos;
        if (peg$c11.test(input.charAt(peg$currPos))) {
          s2 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s2 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c12); }
        }
        if (s2 !== peg$FAILED) {
          s3 = [];
          if (peg$c6.test(input.charAt(peg$currPos))) {
            s4 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s4 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c7); }
          }
          while (s4 !== peg$FAILED) {
            s3.push(s4);
            if (peg$c6.test(input.charAt(peg$currPos))) {
              s4 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s4 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c7); }
            }
          }
          if (s3 !== peg$FAILED) {
            s2 = [s2, s3];
            s1 = s2;
          } else {
            peg$currPos = s1;
            s1 = peg$FAILED;
          }
        } else {
          peg$currPos = s1;
          s1 = peg$FAILED;
        }
        if (s1 !== peg$FAILED) {
          s2 = [];
          if (peg$c8.test(input.charAt(peg$currPos))) {
            s3 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c9); }
          }
          while (s3 !== peg$FAILED) {
            s2.push(s3);
            if (peg$c8.test(input.charAt(peg$currPos))) {
              s3 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s3 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c9); }
            }
          }
          if (s2 !== peg$FAILED) {
            peg$savedPos = s0;
            s1 = peg$c13(s1);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      }
    }

    return s0;
  }

  function peg$parseNode() {
    var s0, s1;

    s0 = peg$currPos;
    s1 = peg$parseComment();
    if (s1 === peg$FAILED) {
      s1 = peg$parsePreambleExpression();
      if (s1 === peg$FAILED) {
        s1 = peg$parseStringDeclaration();
        if (s1 === peg$FAILED) {
          s1 = peg$parseEntry();
        }
      }
    }
    if (s1 !== peg$FAILED) {
      peg$savedPos = s0;
      s1 = peg$c14(s1);
    }
    s0 = s1;

    return s0;
  }

  function peg$parseBracedComment() {
    var s0, s1, s2, s3;

    s0 = peg$currPos;
    if (input.charCodeAt(peg$currPos) === 123) {
      s1 = peg$c15;
      peg$currPos++;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c16); }
    }
    if (s1 !== peg$FAILED) {
      s2 = [];
      if (peg$c17.test(input.charAt(peg$currPos))) {
        s3 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s3 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c18); }
      }
      if (s3 === peg$FAILED) {
        s3 = peg$parseBracedComment();
      }
      while (s3 !== peg$FAILED) {
        s2.push(s3);
        if (peg$c17.test(input.charAt(peg$currPos))) {
          s3 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s3 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c18); }
        }
        if (s3 === peg$FAILED) {
          s3 = peg$parseBracedComment();
        }
      }
      if (s2 !== peg$FAILED) {
        if (input.charCodeAt(peg$currPos) === 125) {
          s3 = peg$c19;
          peg$currPos++;
        } else {
          s3 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c20); }
        }
        if (s3 !== peg$FAILED) {
          peg$savedPos = s0;
          s1 = peg$c21(s2);
          s0 = s1;
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseEntry() {
    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;

    s0 = peg$currPos;
    if (input.charCodeAt(peg$currPos) === 64) {
      s1 = peg$c1;
      peg$currPos++;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c2); }
    }
    if (s1 !== peg$FAILED) {
      s2 = peg$parse__();
      if (s2 !== peg$FAILED) {
        s3 = peg$currPos;
        s4 = [];
        if (peg$c22.test(input.charAt(peg$currPos))) {
          s5 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s5 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c23); }
        }
        if (s5 !== peg$FAILED) {
          while (s5 !== peg$FAILED) {
            s4.push(s5);
            if (peg$c22.test(input.charAt(peg$currPos))) {
              s5 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s5 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c23); }
            }
          }
        } else {
          s4 = peg$FAILED;
        }
        if (s4 !== peg$FAILED) {
          s3 = input.substring(s3, peg$currPos);
        } else {
          s3 = s4;
        }
        if (s3 !== peg$FAILED) {
          s4 = peg$parse__();
          if (s4 !== peg$FAILED) {
            if (peg$c24.test(input.charAt(peg$currPos))) {
              s5 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s5 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c25); }
            }
            if (s5 !== peg$FAILED) {
              s6 = peg$parse__();
              if (s6 !== peg$FAILED) {
                s7 = peg$parseEntryId();
                if (s7 === peg$FAILED) {
                  s7 = null;
                }
                if (s7 !== peg$FAILED) {
                  s8 = peg$parse__();
                  if (s8 !== peg$FAILED) {
                    s9 = [];
                    s10 = peg$parseField();
                    while (s10 !== peg$FAILED) {
                      s9.push(s10);
                      s10 = peg$parseField();
                    }
                    if (s9 !== peg$FAILED) {
                      s10 = peg$parse__();
                      if (s10 !== peg$FAILED) {
                        if (peg$c26.test(input.charAt(peg$currPos))) {
                          s11 = input.charAt(peg$currPos);
                          peg$currPos++;
                        } else {
                          s11 = peg$FAILED;
                          if (peg$silentFails === 0) { peg$fail(peg$c27); }
                        }
                        if (s11 !== peg$FAILED) {
                          s12 = peg$parse__();
                          if (s12 !== peg$FAILED) {
                            peg$savedPos = s0;
                            s1 = peg$c28(s3, s7, s9);
                            s0 = s1;
                          } else {
                            peg$currPos = s0;
                            s0 = peg$FAILED;
                          }
                        } else {
                          peg$currPos = s0;
                          s0 = peg$FAILED;
                        }
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parsePreambleExpression() {
    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;

    s0 = peg$currPos;
    if (input.charCodeAt(peg$currPos) === 64) {
      s1 = peg$c1;
      peg$currPos++;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c2); }
    }
    if (s1 !== peg$FAILED) {
      s2 = peg$parse__();
      if (s2 !== peg$FAILED) {
        if (input.substr(peg$currPos, 8).toLowerCase() === peg$c29) {
          s3 = input.substr(peg$currPos, 8);
          peg$currPos += 8;
        } else {
          s3 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c30); }
        }
        if (s3 !== peg$FAILED) {
          s4 = peg$parse__();
          if (s4 !== peg$FAILED) {
            if (peg$c24.test(input.charAt(peg$currPos))) {
              s5 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s5 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c25); }
            }
            if (s5 !== peg$FAILED) {
              s6 = peg$parse__();
              if (s6 !== peg$FAILED) {
                s7 = [];
                s8 = peg$parseEnvironment();
                if (s8 === peg$FAILED) {
                  s8 = peg$parseBlock();
                  if (s8 === peg$FAILED) {
                    s8 = peg$parseMath();
                    if (s8 === peg$FAILED) {
                      s8 = peg$parseCommand();
                      if (s8 === peg$FAILED) {
                        s8 = peg$parseText();
                      }
                    }
                  }
                }
                while (s8 !== peg$FAILED) {
                  s7.push(s8);
                  s8 = peg$parseEnvironment();
                  if (s8 === peg$FAILED) {
                    s8 = peg$parseBlock();
                    if (s8 === peg$FAILED) {
                      s8 = peg$parseMath();
                      if (s8 === peg$FAILED) {
                        s8 = peg$parseCommand();
                        if (s8 === peg$FAILED) {
                          s8 = peg$parseText();
                        }
                      }
                    }
                  }
                }
                if (s7 !== peg$FAILED) {
                  s8 = peg$parse__();
                  if (s8 !== peg$FAILED) {
                    if (peg$c26.test(input.charAt(peg$currPos))) {
                      s9 = input.charAt(peg$currPos);
                      peg$currPos++;
                    } else {
                      s9 = peg$FAILED;
                      if (peg$silentFails === 0) { peg$fail(peg$c27); }
                    }
                    if (s9 !== peg$FAILED) {
                      s10 = peg$parse__();
                      if (s10 !== peg$FAILED) {
                        peg$savedPos = s0;
                        s1 = peg$c31(s5, s7, s9);
                        s0 = s1;
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseStringDeclaration() {
    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;

    s0 = peg$currPos;
    if (input.charCodeAt(peg$currPos) === 64) {
      s1 = peg$c1;
      peg$currPos++;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c2); }
    }
    if (s1 !== peg$FAILED) {
      s2 = peg$parse__();
      if (s2 !== peg$FAILED) {
        if (input.substr(peg$currPos, 6).toLowerCase() === peg$c32) {
          s3 = input.substr(peg$currPos, 6);
          peg$currPos += 6;
        } else {
          s3 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c33); }
        }
        if (s3 !== peg$FAILED) {
          s4 = peg$parse__();
          if (s4 !== peg$FAILED) {
            if (peg$c24.test(input.charAt(peg$currPos))) {
              s5 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s5 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c25); }
            }
            if (s5 !== peg$FAILED) {
              s6 = peg$parse__();
              if (s6 !== peg$FAILED) {
                s7 = peg$parseVariableName();
                if (s7 !== peg$FAILED) {
                  s8 = peg$parseFieldSeparator();
                  if (s8 !== peg$FAILED) {
                    s9 = [];
                    s10 = peg$parseRegularValue();
                    if (s10 !== peg$FAILED) {
                      while (s10 !== peg$FAILED) {
                        s9.push(s10);
                        s10 = peg$parseRegularValue();
                      }
                    } else {
                      s9 = peg$FAILED;
                    }
                    if (s9 !== peg$FAILED) {
                      s10 = peg$parse__();
                      if (s10 !== peg$FAILED) {
                        if (peg$c26.test(input.charAt(peg$currPos))) {
                          s11 = input.charAt(peg$currPos);
                          peg$currPos++;
                        } else {
                          s11 = peg$FAILED;
                          if (peg$silentFails === 0) { peg$fail(peg$c27); }
                        }
                        if (s11 !== peg$FAILED) {
                          s12 = peg$parse__();
                          if (s12 !== peg$FAILED) {
                            peg$savedPos = s0;
                            s1 = peg$c34(s7, s9);
                            s0 = s1;
                          } else {
                            peg$currPos = s0;
                            s0 = peg$FAILED;
                          }
                        } else {
                          peg$currPos = s0;
                          s0 = peg$FAILED;
                        }
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseEntryId() {
    var s0, s1, s2, s3, s4;

    s0 = peg$currPos;
    s1 = peg$parse__();
    if (s1 !== peg$FAILED) {
      s2 = peg$currPos;
      s3 = [];
      if (peg$c35.test(input.charAt(peg$currPos))) {
        s4 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s4 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c36); }
      }
      while (s4 !== peg$FAILED) {
        s3.push(s4);
        if (peg$c35.test(input.charAt(peg$currPos))) {
          s4 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s4 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c36); }
        }
      }
      if (s3 !== peg$FAILED) {
        s2 = input.substring(s2, peg$currPos);
      } else {
        s2 = s3;
      }
      if (s2 !== peg$FAILED) {
        s3 = peg$parse__();
        if (s3 !== peg$FAILED) {
          if (input.charCodeAt(peg$currPos) === 44) {
            s4 = peg$c37;
            peg$currPos++;
          } else {
            s4 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c38); }
          }
          if (s4 !== peg$FAILED) {
            peg$savedPos = s0;
            s1 = peg$c39(s2);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseField() {
    var s0, s1, s2, s3, s4, s5, s6, s7, s8;

    s0 = peg$currPos;
    s1 = peg$parseFieldName();
    if (s1 !== peg$FAILED) {
      peg$savedPos = peg$currPos;
      s2 = peg$c40(s1);
      if (s2) {
        s2 = void 0;
      } else {
        s2 = peg$FAILED;
      }
      if (s2 !== peg$FAILED) {
        s3 = peg$parseFieldSeparator();
        if (s3 !== peg$FAILED) {
          if (input.charCodeAt(peg$currPos) === 123) {
            s4 = peg$c15;
            peg$currPos++;
          } else {
            s4 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c16); }
          }
          if (s4 !== peg$FAILED) {
            s5 = peg$currPos;
            peg$silentFails++;
            if (input.charCodeAt(peg$currPos) === 123) {
              s6 = peg$c15;
              peg$currPos++;
            } else {
              s6 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c16); }
            }
            peg$silentFails--;
            if (s6 !== peg$FAILED) {
              peg$currPos = s5;
              s5 = void 0;
            } else {
              s5 = peg$FAILED;
            }
            if (s5 !== peg$FAILED) {
              s6 = peg$parseVerbatimFieldValue();
              if (s6 !== peg$FAILED) {
                if (input.charCodeAt(peg$currPos) === 125) {
                  s7 = peg$c19;
                  peg$currPos++;
                } else {
                  s7 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c20); }
                }
                if (s7 !== peg$FAILED) {
                  s8 = peg$parseFieldTerminator();
                  if (s8 !== peg$FAILED) {
                    peg$savedPos = s0;
                    s1 = peg$c41(s1, s6);
                    s0 = s1;
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }
    if (s0 === peg$FAILED) {
      s0 = peg$currPos;
      s1 = peg$parseFieldName();
      if (s1 !== peg$FAILED) {
        peg$savedPos = peg$currPos;
        s2 = peg$c42(s1);
        if (s2) {
          s2 = void 0;
        } else {
          s2 = peg$FAILED;
        }
        if (s2 !== peg$FAILED) {
          s3 = peg$parseFieldSeparator();
          if (s3 !== peg$FAILED) {
            s4 = peg$parseVerbatimFieldValue();
            if (s4 !== peg$FAILED) {
              s5 = peg$parseFieldTerminator();
              if (s5 !== peg$FAILED) {
                peg$savedPos = s0;
                s1 = peg$c43(s1, s4);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        s1 = peg$parseFieldName();
        if (s1 !== peg$FAILED) {
          s2 = peg$parseFieldSeparator();
          if (s2 !== peg$FAILED) {
            s3 = peg$parseFieldValue();
            if (s3 !== peg$FAILED) {
              s4 = peg$parseFieldTerminator();
              if (s4 !== peg$FAILED) {
                peg$savedPos = s0;
                s1 = peg$c44(s1, s3);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      }
    }

    return s0;
  }

  function peg$parseFieldName() {
    var s0, s1, s2, s3, s4;

    s0 = peg$currPos;
    s1 = peg$parse__();
    if (s1 !== peg$FAILED) {
      s2 = peg$currPos;
      s3 = [];
      if (peg$c45.test(input.charAt(peg$currPos))) {
        s4 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s4 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c46); }
      }
      if (s4 !== peg$FAILED) {
        while (s4 !== peg$FAILED) {
          s3.push(s4);
          if (peg$c45.test(input.charAt(peg$currPos))) {
            s4 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s4 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c46); }
          }
        }
      } else {
        s3 = peg$FAILED;
      }
      if (s3 !== peg$FAILED) {
        s2 = input.substring(s2, peg$currPos);
      } else {
        s2 = s3;
      }
      if (s2 !== peg$FAILED) {
        peg$savedPos = s0;
        s1 = peg$c47(s2);
        s0 = s1;
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseVerbatimFieldValue() {
    var s0, s1, s2, s3;

    s0 = peg$currPos;
    if (input.charCodeAt(peg$currPos) === 34) {
      s1 = peg$c48;
      peg$currPos++;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c49); }
    }
    if (s1 !== peg$FAILED) {
      s2 = peg$parseTextNoQuotes();
      if (s2 === peg$FAILED) {
        s2 = null;
      }
      if (s2 !== peg$FAILED) {
        if (input.charCodeAt(peg$currPos) === 34) {
          s3 = peg$c48;
          peg$currPos++;
        } else {
          s3 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c49); }
        }
        if (s3 !== peg$FAILED) {
          peg$savedPos = s0;
          s1 = peg$c50(s2);
          s0 = s1;
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }
    if (s0 === peg$FAILED) {
      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 123) {
        s1 = peg$c15;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c16); }
      }
      if (s1 !== peg$FAILED) {
        s2 = [];
        s3 = peg$parseVerbatimText();
        while (s3 !== peg$FAILED) {
          s2.push(s3);
          s3 = peg$parseVerbatimText();
        }
        if (s2 !== peg$FAILED) {
          if (input.charCodeAt(peg$currPos) === 125) {
            s3 = peg$c19;
            peg$currPos++;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c20); }
          }
          if (s3 !== peg$FAILED) {
            peg$savedPos = s0;
            s1 = peg$c51(s2);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    }

    return s0;
  }

  function peg$parseVerbatimText() {
    var s0, s1, s2, s3;

    s0 = peg$currPos;
    s1 = peg$currPos;
    s2 = [];
    if (peg$c17.test(input.charAt(peg$currPos))) {
      s3 = input.charAt(peg$currPos);
      peg$currPos++;
    } else {
      s3 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c18); }
    }
    if (s3 !== peg$FAILED) {
      while (s3 !== peg$FAILED) {
        s2.push(s3);
        if (peg$c17.test(input.charAt(peg$currPos))) {
          s3 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s3 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c18); }
        }
      }
    } else {
      s2 = peg$FAILED;
    }
    if (s2 !== peg$FAILED) {
      s1 = input.substring(s1, peg$currPos);
    } else {
      s1 = s2;
    }
    if (s1 !== peg$FAILED) {
      peg$savedPos = s0;
      s1 = peg$c52(s1);
    }
    s0 = s1;
    if (s0 === peg$FAILED) {
      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 123) {
        s1 = peg$c15;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c16); }
      }
      if (s1 !== peg$FAILED) {
        s2 = [];
        s3 = peg$parseVerbatimText();
        while (s3 !== peg$FAILED) {
          s2.push(s3);
          s3 = peg$parseVerbatimText();
        }
        if (s2 !== peg$FAILED) {
          if (input.charCodeAt(peg$currPos) === 125) {
            s3 = peg$c19;
            peg$currPos++;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c20); }
          }
          if (s3 !== peg$FAILED) {
            peg$savedPos = s0;
            s1 = peg$c53(s2);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    }

    return s0;
  }

  function peg$parseFieldValue() {
    var s0, s1, s2, s3;

    s0 = peg$parseNumber();
    if (s0 === peg$FAILED) {
      s0 = peg$currPos;
      peg$savedPos = peg$currPos;
      s1 = peg$c54();
      if (s1) {
        s1 = void 0;
      } else {
        s1 = peg$FAILED;
      }
      if (s1 !== peg$FAILED) {
        s2 = [];
        s3 = peg$parseRegularValue();
        if (s3 === peg$FAILED) {
          s3 = peg$parseStringValue();
        }
        while (s3 !== peg$FAILED) {
          s2.push(s3);
          s3 = peg$parseRegularValue();
          if (s3 === peg$FAILED) {
            s3 = peg$parseStringValue();
          }
        }
        if (s2 !== peg$FAILED) {
          peg$savedPos = s0;
          s1 = peg$c55(s2);
          s0 = s1;
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    }

    return s0;
  }

  function peg$parseRegularValue() {
    var s0, s1, s2, s3, s4, s5;

    s0 = peg$currPos;
    if (input.charCodeAt(peg$currPos) === 34) {
      s1 = peg$c48;
      peg$currPos++;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c49); }
    }
    if (s1 !== peg$FAILED) {
      s2 = [];
      s3 = peg$parseEnvironment();
      if (s3 === peg$FAILED) {
        s3 = peg$parseBlock();
        if (s3 === peg$FAILED) {
          s3 = peg$parseMath();
          if (s3 === peg$FAILED) {
            s3 = peg$parseCommand();
            if (s3 === peg$FAILED) {
              s3 = peg$parseTextNoQuotes();
            }
          }
        }
      }
      while (s3 !== peg$FAILED) {
        s2.push(s3);
        s3 = peg$parseEnvironment();
        if (s3 === peg$FAILED) {
          s3 = peg$parseBlock();
          if (s3 === peg$FAILED) {
            s3 = peg$parseMath();
            if (s3 === peg$FAILED) {
              s3 = peg$parseCommand();
              if (s3 === peg$FAILED) {
                s3 = peg$parseTextNoQuotes();
              }
            }
          }
        }
      }
      if (s2 !== peg$FAILED) {
        if (input.charCodeAt(peg$currPos) === 34) {
          s3 = peg$c48;
          peg$currPos++;
        } else {
          s3 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c49); }
        }
        if (s3 !== peg$FAILED) {
          s4 = peg$parseConcat();
          if (s4 === peg$FAILED) {
            s4 = null;
          }
          if (s4 !== peg$FAILED) {
            peg$savedPos = s0;
            s1 = peg$c56(s2);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }
    if (s0 === peg$FAILED) {
      s0 = peg$currPos;
      if (input.substr(peg$currPos, 6) === peg$c57) {
        s1 = peg$c57;
        peg$currPos += 6;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c58); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$currPos;
        peg$silentFails++;
        if (peg$c59.test(input.charAt(peg$currPos))) {
          s3 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s3 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c60); }
        }
        peg$silentFails--;
        if (s3 === peg$FAILED) {
          s2 = void 0;
        } else {
          peg$currPos = s2;
          s2 = peg$FAILED;
        }
        if (s2 !== peg$FAILED) {
          s3 = [];
          s4 = peg$parseVerbatimText();
          while (s4 !== peg$FAILED) {
            s3.push(s4);
            s4 = peg$parseVerbatimText();
          }
          if (s3 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 125) {
              s4 = peg$c19;
              peg$currPos++;
            } else {
              s4 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c20); }
            }
            if (s4 !== peg$FAILED) {
              s5 = peg$parseConcat();
              if (s5 === peg$FAILED) {
                s5 = null;
              }
              if (s5 !== peg$FAILED) {
                peg$savedPos = s0;
                s1 = peg$c51(s3);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        if (input.charCodeAt(peg$currPos) === 123) {
          s1 = peg$c15;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c16); }
        }
        if (s1 !== peg$FAILED) {
          s2 = [];
          s3 = peg$parseEnvironment();
          if (s3 === peg$FAILED) {
            s3 = peg$parseBlock();
            if (s3 === peg$FAILED) {
              s3 = peg$parseMath();
              if (s3 === peg$FAILED) {
                s3 = peg$parseCommand();
                if (s3 === peg$FAILED) {
                  s3 = peg$parseText();
                }
              }
            }
          }
          while (s3 !== peg$FAILED) {
            s2.push(s3);
            s3 = peg$parseEnvironment();
            if (s3 === peg$FAILED) {
              s3 = peg$parseBlock();
              if (s3 === peg$FAILED) {
                s3 = peg$parseMath();
                if (s3 === peg$FAILED) {
                  s3 = peg$parseCommand();
                  if (s3 === peg$FAILED) {
                    s3 = peg$parseText();
                  }
                }
              }
            }
          }
          if (s2 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 125) {
              s3 = peg$c19;
              peg$currPos++;
            } else {
              s3 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c20); }
            }
            if (s3 !== peg$FAILED) {
              s4 = peg$parseConcat();
              if (s4 === peg$FAILED) {
                s4 = null;
              }
              if (s4 !== peg$FAILED) {
                peg$savedPos = s0;
                s1 = peg$c56(s2);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
        if (s0 === peg$FAILED) {
          s0 = peg$currPos;
          s1 = peg$parseStringReference();
          if (s1 !== peg$FAILED) {
            s2 = peg$parseConcat();
            if (s2 === peg$FAILED) {
              s2 = null;
            }
            if (s2 !== peg$FAILED) {
              peg$savedPos = s0;
              s1 = peg$c56(s1);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        }
      }
    }

    return s0;
  }

  function peg$parseStringValue() {
    var s0, s1, s2;

    s0 = peg$currPos;
    s1 = peg$parseStringReference();
    if (s1 !== peg$FAILED) {
      s2 = peg$parseConcat();
      if (s2 === peg$FAILED) {
        s2 = null;
      }
      if (s2 !== peg$FAILED) {
        peg$savedPos = s0;
        s1 = peg$c56(s1);
        s0 = s1;
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseText() {
    var s0, s1, s2;

    s0 = peg$currPos;
    s1 = [];
    if (peg$c61.test(input.charAt(peg$currPos))) {
      s2 = input.charAt(peg$currPos);
      peg$currPos++;
    } else {
      s2 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c62); }
    }
    if (s2 !== peg$FAILED) {
      while (s2 !== peg$FAILED) {
        s1.push(s2);
        if (peg$c61.test(input.charAt(peg$currPos))) {
          s2 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s2 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c62); }
        }
      }
    } else {
      s1 = peg$FAILED;
    }
    if (s1 !== peg$FAILED) {
      peg$savedPos = s0;
      s1 = peg$c63(s1);
    }
    s0 = s1;

    return s0;
  }

  function peg$parseTextNoQuotes() {
    var s0, s1, s2;

    s0 = peg$currPos;
    s1 = [];
    if (peg$c64.test(input.charAt(peg$currPos))) {
      s2 = input.charAt(peg$currPos);
      peg$currPos++;
    } else {
      s2 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c65); }
    }
    if (s2 !== peg$FAILED) {
      while (s2 !== peg$FAILED) {
        s1.push(s2);
        if (peg$c64.test(input.charAt(peg$currPos))) {
          s2 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s2 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c65); }
        }
      }
    } else {
      s1 = peg$FAILED;
    }
    if (s1 !== peg$FAILED) {
      peg$savedPos = s0;
      s1 = peg$c63(s1);
    }
    s0 = s1;

    return s0;
  }

  function peg$parseNumber() {
    var s0, s1, s2, s3;

    s0 = peg$currPos;
    s1 = peg$currPos;
    s2 = [];
    if (peg$c66.test(input.charAt(peg$currPos))) {
      s3 = input.charAt(peg$currPos);
      peg$currPos++;
    } else {
      s3 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c67); }
    }
    if (s3 !== peg$FAILED) {
      while (s3 !== peg$FAILED) {
        s2.push(s3);
        if (peg$c66.test(input.charAt(peg$currPos))) {
          s3 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s3 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c67); }
        }
      }
    } else {
      s2 = peg$FAILED;
    }
    if (s2 !== peg$FAILED) {
      s1 = input.substring(s1, peg$currPos);
    } else {
      s1 = s2;
    }
    if (s1 !== peg$FAILED) {
      peg$savedPos = s0;
      s1 = peg$c68(s1);
    }
    s0 = s1;

    return s0;
  }

  function peg$parseStringReference() {
    var s0, s1;

    s0 = peg$currPos;
    s1 = peg$parseVariableName();
    if (s1 !== peg$FAILED) {
      peg$savedPos = s0;
      s1 = peg$c69(s1);
    }
    s0 = s1;

    return s0;
  }

  function peg$parseEnvironment() {
    var s0, s1, s2, s3, s4, s5, s6, s7, s8;

    s0 = peg$currPos;
    if (input.substr(peg$currPos, 7) === peg$c70) {
      s1 = peg$c70;
      peg$currPos += 7;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c71); }
    }
    if (s1 !== peg$FAILED) {
      s2 = peg$currPos;
      s3 = [];
      if (peg$c72.test(input.charAt(peg$currPos))) {
        s4 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s4 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c73); }
      }
      if (s4 !== peg$FAILED) {
        while (s4 !== peg$FAILED) {
          s3.push(s4);
          if (peg$c72.test(input.charAt(peg$currPos))) {
            s4 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s4 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c73); }
          }
        }
      } else {
        s3 = peg$FAILED;
      }
      if (s3 !== peg$FAILED) {
        s2 = input.substring(s2, peg$currPos);
      } else {
        s2 = s3;
      }
      if (s2 !== peg$FAILED) {
        if (input.charCodeAt(peg$currPos) === 125) {
          s3 = peg$c19;
          peg$currPos++;
        } else {
          s3 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c20); }
        }
        if (s3 !== peg$FAILED) {
          s4 = [];
          s5 = peg$parseEnvironment();
          if (s5 === peg$FAILED) {
            s5 = peg$parseBlock();
            if (s5 === peg$FAILED) {
              s5 = peg$parseCommand();
              if (s5 === peg$FAILED) {
                s5 = peg$parseMath();
                if (s5 === peg$FAILED) {
                  s5 = peg$parseText();
                }
              }
            }
          }
          while (s5 !== peg$FAILED) {
            s4.push(s5);
            s5 = peg$parseEnvironment();
            if (s5 === peg$FAILED) {
              s5 = peg$parseBlock();
              if (s5 === peg$FAILED) {
                s5 = peg$parseCommand();
                if (s5 === peg$FAILED) {
                  s5 = peg$parseMath();
                  if (s5 === peg$FAILED) {
                    s5 = peg$parseText();
                  }
                }
              }
            }
          }
          if (s4 !== peg$FAILED) {
            if (input.substr(peg$currPos, 5) === peg$c74) {
              s5 = peg$c74;
              peg$currPos += 5;
            } else {
              s5 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c75); }
            }
            if (s5 !== peg$FAILED) {
              s6 = peg$currPos;
              s7 = [];
              if (peg$c72.test(input.charAt(peg$currPos))) {
                s8 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s8 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c73); }
              }
              if (s8 !== peg$FAILED) {
                while (s8 !== peg$FAILED) {
                  s7.push(s8);
                  if (peg$c72.test(input.charAt(peg$currPos))) {
                    s8 = input.charAt(peg$currPos);
                    peg$currPos++;
                  } else {
                    s8 = peg$FAILED;
                    if (peg$silentFails === 0) { peg$fail(peg$c73); }
                  }
                }
              } else {
                s7 = peg$FAILED;
              }
              if (s7 !== peg$FAILED) {
                s6 = input.substring(s6, peg$currPos);
              } else {
                s6 = s7;
              }
              if (s6 !== peg$FAILED) {
                if (input.charCodeAt(peg$currPos) === 125) {
                  s7 = peg$c19;
                  peg$currPos++;
                } else {
                  s7 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c20); }
                }
                if (s7 !== peg$FAILED) {
                  peg$savedPos = peg$currPos;
                  s8 = peg$c76(s2, s4, s6);
                  if (s8) {
                    s8 = void 0;
                  } else {
                    s8 = peg$FAILED;
                  }
                  if (s8 !== peg$FAILED) {
                    peg$savedPos = s0;
                    s1 = peg$c77(s2, s4);
                    s0 = s1;
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseBlock() {
    var s0, s1, s2, s3, s4, s5, s6;

    s0 = peg$currPos;
    if (input.substr(peg$currPos, 2) === peg$c78) {
      s1 = peg$c78;
      peg$currPos += 2;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c79); }
    }
    if (s1 !== peg$FAILED) {
      s2 = peg$parseExtendedDiacritic();
      if (s2 !== peg$FAILED) {
        s3 = peg$parse__();
        if (s3 !== peg$FAILED) {
          if (peg$c72.test(input.charAt(peg$currPos))) {
            s4 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s4 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c73); }
          }
          if (s4 === peg$FAILED) {
            s4 = peg$currPos;
            if (input.charCodeAt(peg$currPos) === 92) {
              s5 = peg$c80;
              peg$currPos++;
            } else {
              s5 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c81); }
            }
            if (s5 !== peg$FAILED) {
              if (peg$c82.test(input.charAt(peg$currPos))) {
                s6 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s6 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c83); }
              }
              if (s6 !== peg$FAILED) {
                s5 = [s5, s6];
                s4 = s5;
              } else {
                peg$currPos = s4;
                s4 = peg$FAILED;
              }
            } else {
              peg$currPos = s4;
              s4 = peg$FAILED;
            }
          }
          if (s4 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 125) {
              s5 = peg$c19;
              peg$currPos++;
            } else {
              s5 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c20); }
            }
            if (s5 !== peg$FAILED) {
              peg$savedPos = s0;
              s1 = peg$c84(s2, s4);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }
    if (s0 === peg$FAILED) {
      s0 = peg$currPos;
      if (input.substr(peg$currPos, 6) === peg$c57) {
        s1 = peg$c57;
        peg$currPos += 6;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c58); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$currPos;
        peg$silentFails++;
        if (peg$c59.test(input.charAt(peg$currPos))) {
          s3 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s3 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c60); }
        }
        peg$silentFails--;
        if (s3 === peg$FAILED) {
          s2 = void 0;
        } else {
          peg$currPos = s2;
          s2 = peg$FAILED;
        }
        if (s2 !== peg$FAILED) {
          s3 = [];
          s4 = peg$parseVerbatimText();
          while (s4 !== peg$FAILED) {
            s3.push(s4);
            s4 = peg$parseVerbatimText();
          }
          if (s3 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 125) {
              s4 = peg$c19;
              peg$currPos++;
            } else {
              s4 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c20); }
            }
            if (s4 !== peg$FAILED) {
              peg$savedPos = s0;
              s1 = peg$c85(s3);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        if (input.charCodeAt(peg$currPos) === 123) {
          s1 = peg$c15;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c16); }
        }
        if (s1 !== peg$FAILED) {
          s2 = [];
          s3 = peg$parseEnvironment();
          if (s3 === peg$FAILED) {
            s3 = peg$parseBlock();
            if (s3 === peg$FAILED) {
              s3 = peg$parseCommand();
              if (s3 === peg$FAILED) {
                s3 = peg$parseMath();
                if (s3 === peg$FAILED) {
                  s3 = peg$parseText();
                }
              }
            }
          }
          while (s3 !== peg$FAILED) {
            s2.push(s3);
            s3 = peg$parseEnvironment();
            if (s3 === peg$FAILED) {
              s3 = peg$parseBlock();
              if (s3 === peg$FAILED) {
                s3 = peg$parseCommand();
                if (s3 === peg$FAILED) {
                  s3 = peg$parseMath();
                  if (s3 === peg$FAILED) {
                    s3 = peg$parseText();
                  }
                }
              }
            }
          }
          if (s2 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 125) {
              s3 = peg$c19;
              peg$currPos++;
            } else {
              s3 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c20); }
            }
            if (s3 !== peg$FAILED) {
              peg$savedPos = s0;
              s1 = peg$c86(s2);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      }
    }

    return s0;
  }

  function peg$parseMath() {
    var s0, s1, s2, s3, s4, s5, s6;

    s0 = peg$currPos;
    peg$savedPos = peg$currPos;
    s1 = peg$c87();
    if (s1) {
      s1 = void 0;
    } else {
      s1 = peg$FAILED;
    }
    if (s1 !== peg$FAILED) {
      if (input.charCodeAt(peg$currPos) === 36) {
        s2 = peg$c88;
        peg$currPos++;
      } else {
        s2 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c89); }
      }
      if (s2 === peg$FAILED) {
        if (input.substr(peg$currPos, 2) === peg$c90) {
          s2 = peg$c90;
          peg$currPos += 2;
        } else {
          s2 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c91); }
        }
      }
      if (s2 !== peg$FAILED) {
        peg$savedPos = peg$currPos;
        s3 = peg$c92();
        if (s3) {
          s3 = void 0;
        } else {
          s3 = peg$FAILED;
        }
        if (s3 !== peg$FAILED) {
          s4 = [];
          s5 = peg$parseBlock();
          if (s5 === peg$FAILED) {
            s5 = peg$parseCommand();
            if (s5 === peg$FAILED) {
              s5 = peg$parseText();
            }
          }
          while (s5 !== peg$FAILED) {
            s4.push(s5);
            s5 = peg$parseBlock();
            if (s5 === peg$FAILED) {
              s5 = peg$parseCommand();
              if (s5 === peg$FAILED) {
                s5 = peg$parseText();
              }
            }
          }
          if (s4 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 36) {
              s5 = peg$c88;
              peg$currPos++;
            } else {
              s5 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c89); }
            }
            if (s5 === peg$FAILED) {
              if (input.substr(peg$currPos, 2) === peg$c90) {
                s5 = peg$c90;
                peg$currPos += 2;
              } else {
                s5 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c91); }
              }
            }
            if (s5 !== peg$FAILED) {
              peg$savedPos = peg$currPos;
              s6 = peg$c93();
              if (s6) {
                s6 = void 0;
              } else {
                s6 = peg$FAILED;
              }
              if (s6 !== peg$FAILED) {
                peg$savedPos = s0;
                s1 = peg$c94(s2, s4);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseLineComment() {
    var s0, s1, s2, s3, s4, s5;

    s0 = peg$currPos;
    if (input.charCodeAt(peg$currPos) === 37) {
      s1 = peg$c95;
      peg$currPos++;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c96); }
    }
    if (s1 !== peg$FAILED) {
      s2 = peg$parse__h();
      if (s2 !== peg$FAILED) {
        s3 = peg$currPos;
        s4 = [];
        if (peg$c97.test(input.charAt(peg$currPos))) {
          s5 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s5 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c98); }
        }
        if (s5 !== peg$FAILED) {
          while (s5 !== peg$FAILED) {
            s4.push(s5);
            if (peg$c97.test(input.charAt(peg$currPos))) {
              s5 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s5 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c98); }
            }
          }
        } else {
          s4 = peg$FAILED;
        }
        if (s4 !== peg$FAILED) {
          s3 = input.substring(s3, peg$currPos);
        } else {
          s3 = s4;
        }
        if (s3 !== peg$FAILED) {
          s4 = [];
          s5 = peg$parseEOL();
          if (s5 !== peg$FAILED) {
            while (s5 !== peg$FAILED) {
              s4.push(s5);
              s5 = peg$parseEOL();
            }
          } else {
            s4 = peg$FAILED;
          }
          if (s4 !== peg$FAILED) {
            peg$savedPos = s0;
            s1 = peg$c99(s3);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseCommand() {
    var s0;

    s0 = peg$parseScriptCommand();
    if (s0 === peg$FAILED) {
      s0 = peg$parseDiacriticCommand();
      if (s0 === peg$FAILED) {
        s0 = peg$parseRegularCommand();
        if (s0 === peg$FAILED) {
          s0 = peg$parseSymbolCommand();
        }
      }
    }

    return s0;
  }

  function peg$parseScriptCommand() {
    var s0, s1, s2, s3;

    s0 = peg$currPos;
    if (peg$c100.test(input.charAt(peg$currPos))) {
      s1 = input.charAt(peg$currPos);
      peg$currPos++;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c101); }
    }
    if (s1 !== peg$FAILED) {
      s2 = peg$parse__h();
      if (s2 !== peg$FAILED) {
        s3 = peg$parseRequiredArgument();
        if (s3 !== peg$FAILED) {
          peg$savedPos = s0;
          s1 = peg$c102(s1, s3);
          s0 = s1;
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseDiacriticCommand() {
    var s0, s1, s2, s3, s4, s5, s6;

    s0 = peg$currPos;
    if (input.charCodeAt(peg$currPos) === 92) {
      s1 = peg$c80;
      peg$currPos++;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c81); }
    }
    if (s1 !== peg$FAILED) {
      s2 = peg$parseSimpleDiacritic();
      if (s2 !== peg$FAILED) {
        s3 = peg$parse__();
        if (s3 !== peg$FAILED) {
          if (peg$c72.test(input.charAt(peg$currPos))) {
            s4 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s4 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c73); }
          }
          if (s4 === peg$FAILED) {
            s4 = peg$currPos;
            if (input.charCodeAt(peg$currPos) === 92) {
              s5 = peg$c80;
              peg$currPos++;
            } else {
              s5 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c81); }
            }
            if (s5 !== peg$FAILED) {
              if (peg$c82.test(input.charAt(peg$currPos))) {
                s6 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s6 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c83); }
              }
              if (s6 !== peg$FAILED) {
                s5 = [s5, s6];
                s4 = s5;
              } else {
                peg$currPos = s4;
                s4 = peg$FAILED;
              }
            } else {
              peg$currPos = s4;
              s4 = peg$FAILED;
            }
          }
          if (s4 !== peg$FAILED) {
            peg$savedPos = s0;
            s1 = peg$c84(s2, s4);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }
    if (s0 === peg$FAILED) {
      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 92) {
        s1 = peg$c80;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c81); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$parseExtendedDiacritic();
        if (s2 !== peg$FAILED) {
          if (input.charCodeAt(peg$currPos) === 123) {
            s3 = peg$c15;
            peg$currPos++;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c16); }
          }
          if (s3 !== peg$FAILED) {
            if (peg$c72.test(input.charAt(peg$currPos))) {
              s4 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s4 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c73); }
            }
            if (s4 === peg$FAILED) {
              s4 = peg$currPos;
              if (input.charCodeAt(peg$currPos) === 92) {
                s5 = peg$c80;
                peg$currPos++;
              } else {
                s5 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c81); }
              }
              if (s5 !== peg$FAILED) {
                if (peg$c82.test(input.charAt(peg$currPos))) {
                  s6 = input.charAt(peg$currPos);
                  peg$currPos++;
                } else {
                  s6 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c83); }
                }
                if (s6 !== peg$FAILED) {
                  s5 = [s5, s6];
                  s4 = s5;
                } else {
                  peg$currPos = s4;
                  s4 = peg$FAILED;
                }
              } else {
                peg$currPos = s4;
                s4 = peg$FAILED;
              }
            }
            if (s4 !== peg$FAILED) {
              if (input.charCodeAt(peg$currPos) === 125) {
                s5 = peg$c19;
                peg$currPos++;
              } else {
                s5 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c20); }
              }
              if (s5 !== peg$FAILED) {
                peg$savedPos = s0;
                s1 = peg$c84(s2, s4);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        if (input.charCodeAt(peg$currPos) === 92) {
          s1 = peg$c80;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c81); }
        }
        if (s1 !== peg$FAILED) {
          s2 = peg$parseExtendedDiacritic();
          if (s2 !== peg$FAILED) {
            s3 = peg$currPos;
            peg$silentFails++;
            if (input.charCodeAt(peg$currPos) === 123) {
              s4 = peg$c15;
              peg$currPos++;
            } else {
              s4 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c16); }
            }
            peg$silentFails--;
            if (s4 !== peg$FAILED) {
              peg$currPos = s3;
              s3 = void 0;
            } else {
              s3 = peg$FAILED;
            }
            if (s3 !== peg$FAILED) {
              s4 = peg$parseRegularValue();
              if (s4 !== peg$FAILED) {
                peg$savedPos = s0;
                s1 = peg$c103(s2, s4);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      }
    }

    return s0;
  }

  function peg$parseSymbolCommand() {
    var s0, s1, s2, s3;

    s0 = peg$currPos;
    if (input.charCodeAt(peg$currPos) === 92) {
      s1 = peg$c80;
      peg$currPos++;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c81); }
    }
    if (s1 !== peg$FAILED) {
      s2 = peg$currPos;
      if (peg$c104.test(input.charAt(peg$currPos))) {
        s3 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s3 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c105); }
      }
      if (s3 !== peg$FAILED) {
        s2 = input.substring(s2, peg$currPos);
      } else {
        s2 = s3;
      }
      if (s2 !== peg$FAILED) {
        peg$savedPos = s0;
        s1 = peg$c106(s2);
        s0 = s1;
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseRegularCommand() {
    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;

    s0 = peg$currPos;
    if (input.charCodeAt(peg$currPos) === 92) {
      s1 = peg$c80;
      peg$currPos++;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c81); }
    }
    if (s1 !== peg$FAILED) {
      if (input.substr(peg$currPos, 10) === peg$c107) {
        s2 = peg$c107;
        peg$currPos += 10;
      } else {
        s2 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c108); }
      }
      if (s2 !== peg$FAILED) {
        s3 = peg$parseBlock();
        if (s3 !== peg$FAILED) {
          peg$savedPos = peg$currPos;
          s4 = peg$c109(s2, s3);
          if (s4) {
            s4 = void 0;
          } else {
            s4 = peg$FAILED;
          }
          if (s4 !== peg$FAILED) {
            s5 = [];
            s6 = peg$parseOptionalArgument();
            while (s6 !== peg$FAILED) {
              s5.push(s6);
              s6 = peg$parseOptionalArgument();
            }
            if (s5 !== peg$FAILED) {
              s6 = peg$parseRequiredArgument();
              if (s6 !== peg$FAILED) {
                peg$savedPos = s0;
                s1 = peg$c110(s2, s3, s5, s6);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }
    if (s0 === peg$FAILED) {
      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 92) {
        s1 = peg$c80;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c81); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$currPos;
        peg$silentFails++;
        if (input.substr(peg$currPos, 5) === peg$c111) {
          s3 = peg$c111;
          peg$currPos += 5;
        } else {
          s3 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c112); }
        }
        peg$silentFails--;
        if (s3 === peg$FAILED) {
          s2 = void 0;
        } else {
          peg$currPos = s2;
          s2 = peg$FAILED;
        }
        if (s2 !== peg$FAILED) {
          s3 = peg$currPos;
          peg$silentFails++;
          if (input.substr(peg$currPos, 3) === peg$c113) {
            s4 = peg$c113;
            peg$currPos += 3;
          } else {
            s4 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c114); }
          }
          peg$silentFails--;
          if (s4 === peg$FAILED) {
            s3 = void 0;
          } else {
            peg$currPos = s3;
            s3 = peg$FAILED;
          }
          if (s3 !== peg$FAILED) {
            s4 = peg$currPos;
            s5 = [];
            if (peg$c22.test(input.charAt(peg$currPos))) {
              s6 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s6 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c23); }
            }
            if (s6 !== peg$FAILED) {
              while (s6 !== peg$FAILED) {
                s5.push(s6);
                if (peg$c22.test(input.charAt(peg$currPos))) {
                  s6 = input.charAt(peg$currPos);
                  peg$currPos++;
                } else {
                  s6 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c23); }
                }
              }
            } else {
              s5 = peg$FAILED;
            }
            if (s5 !== peg$FAILED) {
              s4 = input.substring(s4, peg$currPos);
            } else {
              s4 = s5;
            }
            if (s4 !== peg$FAILED) {
              peg$savedPos = peg$currPos;
              s5 = peg$c115(s4);
              if (s5) {
                s5 = void 0;
              } else {
                s5 = peg$FAILED;
              }
              if (s5 !== peg$FAILED) {
                s6 = [];
                s7 = peg$parseOptionalArgument();
                while (s7 !== peg$FAILED) {
                  s6.push(s7);
                  s7 = peg$parseOptionalArgument();
                }
                if (s6 !== peg$FAILED) {
                  s7 = peg$parse__h();
                  if (s7 !== peg$FAILED) {
                    s8 = peg$currPos;
                    peg$silentFails++;
                    if (input.charCodeAt(peg$currPos) === 123) {
                      s9 = peg$c15;
                      peg$currPos++;
                    } else {
                      s9 = peg$FAILED;
                      if (peg$silentFails === 0) { peg$fail(peg$c16); }
                    }
                    peg$silentFails--;
                    if (s9 !== peg$FAILED) {
                      peg$currPos = s8;
                      s8 = void 0;
                    } else {
                      s8 = peg$FAILED;
                    }
                    if (s8 !== peg$FAILED) {
                      s9 = peg$parseVerbatimFieldValue();
                      if (s9 !== peg$FAILED) {
                        s10 = peg$parseVerbatimFieldValue();
                        if (s10 !== peg$FAILED) {
                          peg$savedPos = s0;
                          s1 = peg$c116(s4, s6, s9, s10);
                          s0 = s1;
                        } else {
                          peg$currPos = s0;
                          s0 = peg$FAILED;
                        }
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        if (input.charCodeAt(peg$currPos) === 92) {
          s1 = peg$c80;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c81); }
        }
        if (s1 !== peg$FAILED) {
          s2 = peg$currPos;
          peg$silentFails++;
          if (input.substr(peg$currPos, 5) === peg$c111) {
            s3 = peg$c111;
            peg$currPos += 5;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c112); }
          }
          peg$silentFails--;
          if (s3 === peg$FAILED) {
            s2 = void 0;
          } else {
            peg$currPos = s2;
            s2 = peg$FAILED;
          }
          if (s2 !== peg$FAILED) {
            s3 = peg$currPos;
            peg$silentFails++;
            if (input.substr(peg$currPos, 3) === peg$c113) {
              s4 = peg$c113;
              peg$currPos += 3;
            } else {
              s4 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c114); }
            }
            peg$silentFails--;
            if (s4 === peg$FAILED) {
              s3 = void 0;
            } else {
              peg$currPos = s3;
              s3 = peg$FAILED;
            }
            if (s3 !== peg$FAILED) {
              s4 = peg$currPos;
              s5 = [];
              if (peg$c22.test(input.charAt(peg$currPos))) {
                s6 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s6 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c23); }
              }
              if (s6 !== peg$FAILED) {
                while (s6 !== peg$FAILED) {
                  s5.push(s6);
                  if (peg$c22.test(input.charAt(peg$currPos))) {
                    s6 = input.charAt(peg$currPos);
                    peg$currPos++;
                  } else {
                    s6 = peg$FAILED;
                    if (peg$silentFails === 0) { peg$fail(peg$c23); }
                  }
                }
              } else {
                s5 = peg$FAILED;
              }
              if (s5 !== peg$FAILED) {
                s4 = input.substring(s4, peg$currPos);
              } else {
                s4 = s5;
              }
              if (s4 !== peg$FAILED) {
                peg$savedPos = peg$currPos;
                s5 = peg$c117(s4);
                if (s5) {
                  s5 = void 0;
                } else {
                  s5 = peg$FAILED;
                }
                if (s5 !== peg$FAILED) {
                  s6 = [];
                  s7 = peg$parseOptionalArgument();
                  while (s7 !== peg$FAILED) {
                    s6.push(s7);
                    s7 = peg$parseOptionalArgument();
                  }
                  if (s6 !== peg$FAILED) {
                    s7 = peg$parse__h();
                    if (s7 !== peg$FAILED) {
                      s8 = peg$currPos;
                      peg$silentFails++;
                      if (input.charCodeAt(peg$currPos) === 123) {
                        s9 = peg$c15;
                        peg$currPos++;
                      } else {
                        s9 = peg$FAILED;
                        if (peg$silentFails === 0) { peg$fail(peg$c16); }
                      }
                      peg$silentFails--;
                      if (s9 !== peg$FAILED) {
                        peg$currPos = s8;
                        s8 = void 0;
                      } else {
                        s8 = peg$FAILED;
                      }
                      if (s8 !== peg$FAILED) {
                        s9 = peg$parseVerbatimFieldValue();
                        if (s9 !== peg$FAILED) {
                          peg$savedPos = s0;
                          s1 = peg$c118(s4, s6, s9);
                          s0 = s1;
                        } else {
                          peg$currPos = s0;
                          s0 = peg$FAILED;
                        }
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
        if (s0 === peg$FAILED) {
          s0 = peg$currPos;
          if (input.charCodeAt(peg$currPos) === 92) {
            s1 = peg$c80;
            peg$currPos++;
          } else {
            s1 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c81); }
          }
          if (s1 !== peg$FAILED) {
            s2 = peg$currPos;
            peg$silentFails++;
            if (input.substr(peg$currPos, 5) === peg$c111) {
              s3 = peg$c111;
              peg$currPos += 5;
            } else {
              s3 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c112); }
            }
            peg$silentFails--;
            if (s3 === peg$FAILED) {
              s2 = void 0;
            } else {
              peg$currPos = s2;
              s2 = peg$FAILED;
            }
            if (s2 !== peg$FAILED) {
              s3 = peg$currPos;
              peg$silentFails++;
              if (input.substr(peg$currPos, 3) === peg$c113) {
                s4 = peg$c113;
                peg$currPos += 3;
              } else {
                s4 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c114); }
              }
              peg$silentFails--;
              if (s4 === peg$FAILED) {
                s3 = void 0;
              } else {
                peg$currPos = s3;
                s3 = peg$FAILED;
              }
              if (s3 !== peg$FAILED) {
                s4 = peg$currPos;
                s5 = [];
                if (peg$c22.test(input.charAt(peg$currPos))) {
                  s6 = input.charAt(peg$currPos);
                  peg$currPos++;
                } else {
                  s6 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c23); }
                }
                if (s6 !== peg$FAILED) {
                  while (s6 !== peg$FAILED) {
                    s5.push(s6);
                    if (peg$c22.test(input.charAt(peg$currPos))) {
                      s6 = input.charAt(peg$currPos);
                      peg$currPos++;
                    } else {
                      s6 = peg$FAILED;
                      if (peg$silentFails === 0) { peg$fail(peg$c23); }
                    }
                  }
                } else {
                  s5 = peg$FAILED;
                }
                if (s5 !== peg$FAILED) {
                  s4 = input.substring(s4, peg$currPos);
                } else {
                  s4 = s5;
                }
                if (s4 !== peg$FAILED) {
                  peg$savedPos = peg$currPos;
                  s5 = peg$c119(s4);
                  if (s5) {
                    s5 = void 0;
                  } else {
                    s5 = peg$FAILED;
                  }
                  if (s5 !== peg$FAILED) {
                    s6 = [];
                    s7 = peg$parseOptionalArgument();
                    while (s7 !== peg$FAILED) {
                      s6.push(s7);
                      s7 = peg$parseOptionalArgument();
                    }
                    if (s6 !== peg$FAILED) {
                      s7 = peg$parse__h();
                      if (s7 !== peg$FAILED) {
                        s8 = peg$parseRequiredArgument();
                        if (s8 !== peg$FAILED) {
                          s9 = peg$parseRequiredArgument();
                          if (s9 !== peg$FAILED) {
                            peg$savedPos = s0;
                            s1 = peg$c120(s4, s6, s8, s9);
                            s0 = s1;
                          } else {
                            peg$currPos = s0;
                            s0 = peg$FAILED;
                          }
                        } else {
                          peg$currPos = s0;
                          s0 = peg$FAILED;
                        }
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
          if (s0 === peg$FAILED) {
            s0 = peg$currPos;
            if (input.charCodeAt(peg$currPos) === 92) {
              s1 = peg$c80;
              peg$currPos++;
            } else {
              s1 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c81); }
            }
            if (s1 !== peg$FAILED) {
              s2 = peg$currPos;
              peg$silentFails++;
              if (input.substr(peg$currPos, 5) === peg$c111) {
                s3 = peg$c111;
                peg$currPos += 5;
              } else {
                s3 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c112); }
              }
              peg$silentFails--;
              if (s3 === peg$FAILED) {
                s2 = void 0;
              } else {
                peg$currPos = s2;
                s2 = peg$FAILED;
              }
              if (s2 !== peg$FAILED) {
                s3 = peg$currPos;
                peg$silentFails++;
                if (input.substr(peg$currPos, 3) === peg$c113) {
                  s4 = peg$c113;
                  peg$currPos += 3;
                } else {
                  s4 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c114); }
                }
                peg$silentFails--;
                if (s4 === peg$FAILED) {
                  s3 = void 0;
                } else {
                  peg$currPos = s3;
                  s3 = peg$FAILED;
                }
                if (s3 !== peg$FAILED) {
                  s4 = peg$currPos;
                  s5 = [];
                  if (peg$c22.test(input.charAt(peg$currPos))) {
                    s6 = input.charAt(peg$currPos);
                    peg$currPos++;
                  } else {
                    s6 = peg$FAILED;
                    if (peg$silentFails === 0) { peg$fail(peg$c23); }
                  }
                  if (s6 !== peg$FAILED) {
                    while (s6 !== peg$FAILED) {
                      s5.push(s6);
                      if (peg$c22.test(input.charAt(peg$currPos))) {
                        s6 = input.charAt(peg$currPos);
                        peg$currPos++;
                      } else {
                        s6 = peg$FAILED;
                        if (peg$silentFails === 0) { peg$fail(peg$c23); }
                      }
                    }
                  } else {
                    s5 = peg$FAILED;
                  }
                  if (s5 !== peg$FAILED) {
                    s4 = input.substring(s4, peg$currPos);
                  } else {
                    s4 = s5;
                  }
                  if (s4 !== peg$FAILED) {
                    peg$savedPos = peg$currPos;
                    s5 = peg$c121(s4);
                    if (s5) {
                      s5 = void 0;
                    } else {
                      s5 = peg$FAILED;
                    }
                    if (s5 !== peg$FAILED) {
                      s6 = [];
                      s7 = peg$parseOptionalArgument();
                      while (s7 !== peg$FAILED) {
                        s6.push(s7);
                        s7 = peg$parseOptionalArgument();
                      }
                      if (s6 !== peg$FAILED) {
                        s7 = peg$parse__h();
                        if (s7 !== peg$FAILED) {
                          s8 = peg$parseRequiredArgument();
                          if (s8 !== peg$FAILED) {
                            peg$savedPos = s0;
                            s1 = peg$c122(s4, s6, s8);
                            s0 = s1;
                          } else {
                            peg$currPos = s0;
                            s0 = peg$FAILED;
                          }
                        } else {
                          peg$currPos = s0;
                          s0 = peg$FAILED;
                        }
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
            if (s0 === peg$FAILED) {
              s0 = peg$currPos;
              if (input.charCodeAt(peg$currPos) === 92) {
                s1 = peg$c80;
                peg$currPos++;
              } else {
                s1 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c81); }
              }
              if (s1 !== peg$FAILED) {
                s2 = peg$currPos;
                peg$silentFails++;
                if (input.substr(peg$currPos, 5) === peg$c111) {
                  s3 = peg$c111;
                  peg$currPos += 5;
                } else {
                  s3 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c112); }
                }
                peg$silentFails--;
                if (s3 === peg$FAILED) {
                  s2 = void 0;
                } else {
                  peg$currPos = s2;
                  s2 = peg$FAILED;
                }
                if (s2 !== peg$FAILED) {
                  s3 = peg$currPos;
                  peg$silentFails++;
                  if (input.substr(peg$currPos, 3) === peg$c113) {
                    s4 = peg$c113;
                    peg$currPos += 3;
                  } else {
                    s4 = peg$FAILED;
                    if (peg$silentFails === 0) { peg$fail(peg$c114); }
                  }
                  peg$silentFails--;
                  if (s4 === peg$FAILED) {
                    s3 = void 0;
                  } else {
                    peg$currPos = s3;
                    s3 = peg$FAILED;
                  }
                  if (s3 !== peg$FAILED) {
                    s4 = peg$currPos;
                    s5 = [];
                    if (peg$c22.test(input.charAt(peg$currPos))) {
                      s6 = input.charAt(peg$currPos);
                      peg$currPos++;
                    } else {
                      s6 = peg$FAILED;
                      if (peg$silentFails === 0) { peg$fail(peg$c23); }
                    }
                    if (s6 !== peg$FAILED) {
                      while (s6 !== peg$FAILED) {
                        s5.push(s6);
                        if (peg$c22.test(input.charAt(peg$currPos))) {
                          s6 = input.charAt(peg$currPos);
                          peg$currPos++;
                        } else {
                          s6 = peg$FAILED;
                          if (peg$silentFails === 0) { peg$fail(peg$c23); }
                        }
                      }
                    } else {
                      s5 = peg$FAILED;
                    }
                    if (s5 !== peg$FAILED) {
                      s4 = input.substring(s4, peg$currPos);
                    } else {
                      s4 = s5;
                    }
                    if (s4 !== peg$FAILED) {
                      s5 = [];
                      s6 = peg$parseOptionalArgument();
                      while (s6 !== peg$FAILED) {
                        s5.push(s6);
                        s6 = peg$parseOptionalArgument();
                      }
                      if (s5 !== peg$FAILED) {
                        s6 = peg$parse__();
                        if (s6 !== peg$FAILED) {
                          peg$savedPos = s0;
                          s1 = peg$c123(s4, s5);
                          s0 = s1;
                        } else {
                          peg$currPos = s0;
                          s0 = peg$FAILED;
                        }
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            }
          }
        }
      }
    }

    return s0;
  }

  function peg$parseOptionalArgument() {
    var s0, s1, s2, s3, s4, s5;

    s0 = peg$currPos;
    if (input.charCodeAt(peg$currPos) === 91) {
      s1 = peg$c124;
      peg$currPos++;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c125); }
    }
    if (s1 !== peg$FAILED) {
      s2 = peg$parse__h();
      if (s2 !== peg$FAILED) {
        s3 = peg$currPos;
        s4 = [];
        if (peg$c126.test(input.charAt(peg$currPos))) {
          s5 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s5 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c127); }
        }
        if (s5 !== peg$FAILED) {
          while (s5 !== peg$FAILED) {
            s4.push(s5);
            if (peg$c126.test(input.charAt(peg$currPos))) {
              s5 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s5 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c127); }
            }
          }
        } else {
          s4 = peg$FAILED;
        }
        if (s4 !== peg$FAILED) {
          s3 = input.substring(s3, peg$currPos);
        } else {
          s3 = s4;
        }
        if (s3 !== peg$FAILED) {
          s4 = peg$parse__h();
          if (s4 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 93) {
              s5 = peg$c128;
              peg$currPos++;
            } else {
              s5 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c129); }
            }
            if (s5 !== peg$FAILED) {
              peg$savedPos = s0;
              s1 = peg$c130(s3);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseRequiredArgument() {
    var s0, s1, s2;

    s0 = peg$currPos;
    s1 = peg$parse__h();
    if (s1 !== peg$FAILED) {
      if (peg$c131.test(input.charAt(peg$currPos))) {
        s2 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s2 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c132); }
      }
      if (s2 !== peg$FAILED) {
        peg$savedPos = s0;
        s1 = peg$c133(s2);
        s0 = s1;
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }
    if (s0 === peg$FAILED) {
      s0 = peg$currPos;
      s1 = peg$parseBlock();
      if (s1 === peg$FAILED) {
        s1 = peg$parseCommand();
      }
      if (s1 !== peg$FAILED) {
        peg$savedPos = s0;
        s1 = peg$c52(s1);
      }
      s0 = s1;
    }

    return s0;
  }

  function peg$parseVariableName() {
    var s0, s1, s2, s3, s4;

    s0 = peg$currPos;
    s1 = peg$currPos;
    if (peg$c134.test(input.charAt(peg$currPos))) {
      s2 = input.charAt(peg$currPos);
      peg$currPos++;
    } else {
      s2 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c135); }
    }
    if (s2 !== peg$FAILED) {
      s3 = [];
      if (peg$c136.test(input.charAt(peg$currPos))) {
        s4 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s4 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c137); }
      }
      while (s4 !== peg$FAILED) {
        s3.push(s4);
        if (peg$c136.test(input.charAt(peg$currPos))) {
          s4 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s4 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c137); }
        }
      }
      if (s3 !== peg$FAILED) {
        s2 = [s2, s3];
        s1 = s2;
      } else {
        peg$currPos = s1;
        s1 = peg$FAILED;
      }
    } else {
      peg$currPos = s1;
      s1 = peg$FAILED;
    }
    if (s1 !== peg$FAILED) {
      s0 = input.substring(s0, peg$currPos);
    } else {
      s0 = s1;
    }

    return s0;
  }

  function peg$parseSimpleDiacritic() {
    var s0;

    if (peg$c138.test(input.charAt(peg$currPos))) {
      s0 = input.charAt(peg$currPos);
      peg$currPos++;
    } else {
      s0 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c139); }
    }

    return s0;
  }

  function peg$parseExtendedDiacritic() {
    var s0;

    if (peg$c140.test(input.charAt(peg$currPos))) {
      s0 = input.charAt(peg$currPos);
      peg$currPos++;
    } else {
      s0 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c141); }
    }

    return s0;
  }

  function peg$parseFieldSeparator() {
    var s0, s1, s2, s3;

    s0 = peg$currPos;
    s1 = peg$parse__();
    if (s1 !== peg$FAILED) {
      if (input.charCodeAt(peg$currPos) === 61) {
        s2 = peg$c142;
        peg$currPos++;
      } else {
        s2 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c143); }
      }
      if (s2 !== peg$FAILED) {
        s3 = peg$parse__();
        if (s3 !== peg$FAILED) {
          s1 = [s1, s2, s3];
          s0 = s1;
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseFieldTerminator() {
    var s0, s1, s2, s3, s4, s5;

    s0 = peg$currPos;
    s1 = peg$parse__();
    if (s1 !== peg$FAILED) {
      if (input.charCodeAt(peg$currPos) === 44) {
        s2 = peg$c37;
        peg$currPos++;
      } else {
        s2 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c38); }
      }
      if (s2 === peg$FAILED) {
        s2 = null;
      }
      if (s2 !== peg$FAILED) {
        s3 = peg$parse__h();
        if (s3 !== peg$FAILED) {
          s4 = [];
          s5 = peg$parseLineComment();
          if (s5 === peg$FAILED) {
            s5 = peg$parseEOL();
          }
          while (s5 !== peg$FAILED) {
            s4.push(s5);
            s5 = peg$parseLineComment();
            if (s5 === peg$FAILED) {
              s5 = peg$parseEOL();
            }
          }
          if (s4 !== peg$FAILED) {
            s1 = [s1, s2, s3, s4];
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseConcat() {
    var s0, s1, s2, s3;

    s0 = peg$currPos;
    s1 = peg$parse__();
    if (s1 !== peg$FAILED) {
      if (input.charCodeAt(peg$currPos) === 35) {
        s2 = peg$c144;
        peg$currPos++;
      } else {
        s2 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c145); }
      }
      if (s2 !== peg$FAILED) {
        s3 = peg$parse__();
        if (s3 !== peg$FAILED) {
          s1 = [s1, s2, s3];
          s0 = s1;
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
    } else {
      peg$currPos = s0;
      s0 = peg$FAILED;
    }

    return s0;
  }

  function peg$parseEOL() {
    var s0;

    if (peg$c146.test(input.charAt(peg$currPos))) {
      s0 = input.charAt(peg$currPos);
      peg$currPos++;
    } else {
      s0 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c147); }
    }

    return s0;
  }

  function peg$parse__h() {
    var s0, s1;

    peg$silentFails++;
    s0 = [];
    if (peg$c149.test(input.charAt(peg$currPos))) {
      s1 = input.charAt(peg$currPos);
      peg$currPos++;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c150); }
    }
    while (s1 !== peg$FAILED) {
      s0.push(s1);
      if (peg$c149.test(input.charAt(peg$currPos))) {
        s1 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c150); }
      }
    }
    peg$silentFails--;
    if (s0 === peg$FAILED) {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c151); }
    }

    return s0;
  }

  function peg$parse__() {
    var s0, s1;

    peg$silentFails++;
    s0 = [];
    if (peg$c155.test(input.charAt(peg$currPos))) {
      s1 = input.charAt(peg$currPos);
      peg$currPos++;
    } else {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c156); }
    }
    while (s1 !== peg$FAILED) {
      s0.push(s1);
      if (peg$c155.test(input.charAt(peg$currPos))) {
        s1 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c156); }
      }
    }
    peg$silentFails--;
    if (s0 === peg$FAILED) {
      s1 = peg$FAILED;
      if (peg$silentFails === 0) { peg$fail(peg$c157); }
    }

    return s0;
  }


    /*
      MIT License

      Copyright (c) 2017 Derek P Sifford, parts copyright (c) 2019 by Emiliano Heyns

      Permission is hereby granted, free of charge, to any person obtaining a copy
      of this software and associated documentation files (the "Software"), to deal
      in the Software without restriction, including without limitation the rights
      to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
      copies of the Software, and to permit persons to whom the Software is
      furnished to do so, subject to the following conditions:

      The above copyright notice and this permission notice shall be included in all
      copies or substantial portions of the Software.

      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
      AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
      OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
      SOFTWARE.
    */

    const markup = {
      sl: 'italics',
      em: 'italics',
      it: 'italics',
      itshape: 'italics',

      bf: 'bold',
      bfseries: 'bold',

      sc: 'smallCaps',
      scshape: 'smallCaps',

      tt: 'fixedWidth',
      rm: 'roman',
      sf: 'sansSerif',
      verb: 'verbatim',
    };

    const unnestFields = (options.unnestFields || []).map(field => field.toLowerCase());
    const verbatimFields = (options.verbatimFields || [ 'urlraw', 'url', 'doi', 'file', 'files', 'eprint', 'verba', 'verbb', 'verbc' ]).map(field => typeof field === 'string' ? field.toLowerCase() : field);
    const verbatimCommands = (options.verbatimCommands || ['texttt', 'url', 'href']);

    function isVerbatimField(name) {
      return verbatimFields.find(p => (typeof p === 'string') ? name === p : name.match(p))
    }

    function normalizeWhitespace(textArr) {
      return textArr.reduce((prev, curr) => {
        if (/\s/.test(curr)) {
          if (/\s/.test(prev[prev.length - 1])) {
            return prev;
          } else {
            return prev + ' ';
          }
        }
        return prev + curr;
      }, '');
    }

    const has_arguments = {
      ElsevierGlyph: 1,
      end: 1,
      begin: 1,
      bibcyr: 1,
      bibstring: 1,
      chsf: 1,
      cite: 1,
      cyrchar: 1,
      ding: 1,
      emph: 1,
      enquote: 1,
      frac: 2,
      href: 2,
      hspace: 1,
      mathrm: 1,
      mbox: 1,
      mkbibbold: 1,
      mkbibemph: 1,
      mkbibitalic: 1,
      mkbibquote: 1,
      newcommand: 2,
      noopsort: 1,
      ocirc: 1,
      section: 1,
      sb: 1,
      sp: 1,
      subsection: 1,
      subsubsection: 1,
      subsubsubsection: 1,
      t: 1,
      textbf: 1,
      textit: 1,
      textrm: 1,
      textsc: 1,
      textsubscript: 1,
      textsuperscript: 1,
      texttt: 1,
      url: 1,
      vphantom: 1,
      vspace: 1,
    };

    if (options.combiningDiacritics) {
      for (const cmd of options.combiningDiacritics) {
        has_arguments[cmd] = 1;
      }
    }

    const math = {
      on: false,

      set: function(state) {
        this.on = state;
        return true
      }
    };

    function basicTextConversions(node) {
      if (node.kind !== 'Text') throw new Error(node.kind + ' is not a Text node')

      switch (node.mode) {
        case 'verbatim':
          break

        case 'math':
          node.value = node.value.replace(/~/g, '\u00A0');
          break

        case 'text':
          node.value = node.value
            .replace(/---/g, '\u2014')
            .replace(/--/g, '\u2013')
            .replace(/</g, '\u00A1')
            .replace(/>/g, '\u00BF')
            .replace(/~/g, '\u00A0')
            .replace(/``/g, options.markup.enquote.open)
            .replace(/''/g, options.markup.enquote.close);
          break

        default:
          throw new Error(`Unexpected text mode ${node.mode}`)
      }

      return node
    }

    function protect(v) {
      let source;
      if (Array.isArray(v)) {
        source = v.map(e => e.source).join('');
      } else {
        v = [ v ];
        source = v.source;
      }

      return {
        kind: 'Block',
        value: v,
        markup: {},
        case: 'protect',
        source: source,
      }
    }

    function handle_markup_switches(block) {
      const value = block.value;
      if (!Array.isArray(value)) return block

      block.value = [];

      const pseudo = {
        block: null,
        markup: {},
      };
      function pseudo_block() {
        pseudo.block = {
          kind: 'Block',
          loc: location(),
          source: '',
          value: [],
          markup: JSON.parse(JSON.stringify(pseudo.markup)),
          pseudo: true,
        };
        block.value.push(pseudo.block);
      }
      for (const node of value) {
        if (node.kind === 'Environment' || node.kind === 'Block') {
          block.value.push(node);

          if (Object.keys(pseudo.markup).length) {
            pseudo_block();
          } else {
            pseudo.block = null;
          }
          continue
        }

        if (node.kind === 'RegularCommand' && markup[node.command]) {
          if (pseudo.markup.italics) { // https://github.com/citation-js/bibtex-parser-experiments/commit/cae475f075a05d1c074485a061b08ed245170c7e
            delete pseudo.markup.italics;
            if (markup[node.command] !== 'italics') pseudo.markup[markup[node.command]] = true;
          } else {
            pseudo.markup[markup[node.command]] = true;
          }

          if (Object.keys(pseudo.markup).length) {
            pseudo_block();
          } else {
             pseudo.block = null;
          }
        }

        if (pseudo.block) {
          pseudo.block.source += node.source;
          pseudo.block.value.push(node);

        } else {
          block.value.push(node);

        }
      }

      block.value = block.value.filter(node => !(node.pseudo && node.value.length === 0));

      return block
    }


  peg$result = peg$startRuleFunction();

  if (peg$result !== peg$FAILED && peg$currPos === input.length) {
    return peg$result;
  } else {
    if (peg$result !== peg$FAILED && peg$currPos < input.length) {
      peg$fail(peg$endExpectation());
    }

    throw peg$buildStructuredError(
      peg$maxFailExpected,
      peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,
      peg$maxFailPos < input.length
        ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
        : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
    );
  }
}

var grammar = {
  SyntaxError: peg$SyntaxError,
  parse:       peg$parse
};

var chunker = createCommonjsModule(function (module, exports) {
// Original work by Henrik Muehe (c) 2010
//
// CommonJS port by Mikola Lysenko 2013
//
Object.defineProperty(exports, "__esModule", { value: true });
exports.parse = void 0;
class ParseError extends Error {
    constructor(message, parser) {
        message += ` @ ${parser.pos}`;
        if (parser.parsing)
            message += ` in ${JSON.stringify(parser.parsing)}`;
        super(message);
        this.name = 'ParseError';
    }
}
// tslint:disable-next-line prefer-template
const letter = new RegExp('[' + [
    // Letter, Uppercase
    /\u0041-\u005A\u00C0-\u00D6\u00D8-\u00DE\u0100\u0102\u0104\u0106\u0108\u010A\u010C\u010E\u0110\u0112\u0114\u0116\u0118\u011A\u011C\u011E\u0120\u0122\u0124\u0126\u0128\u012A\u012C\u012E\u0130\u0132\u0134\u0136\u0139\u013B\u013D\u013F\u0141\u0143\u0145\u0147\u014A\u014C\u014E\u0150\u0152\u0154\u0156\u0158\u015A\u015C\u015E\u0160\u0162\u0164\u0166\u0168\u016A\u016C\u016E\u0170\u0172\u0174\u0176\u0178-\u0179\u017B\u017D\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018B\u018E-\u0191\u0193-\u0194\u0196-\u0198\u019C-\u019D\u019F-\u01A0\u01A2\u01A4\u01A6-\u01A7\u01A9\u01AC\u01AE-\u01AF\u01B1-\u01B3\u01B5\u01B7-\u01B8\u01BC\u01C4\u01C7\u01CA\u01CD\u01CF\u01D1\u01D3\u01D5\u01D7\u01D9\u01DB\u01DE\u01E0\u01E2\u01E4\u01E6\u01E8\u01EA\u01EC\u01EE\u01F1\u01F4\u01F6-\u01F8\u01FA\u01FC\u01FE\u0200\u0202\u0204\u0206\u0208\u020A\u020C\u020E\u0210\u0212\u0214\u0216\u0218\u021A\u021C\u021E\u0220\u0222\u0224\u0226\u0228\u022A\u022C\u022E\u0230\u0232\u023A-\u023B\u023D-\u023E\u0241\u0243-\u0246\u0248\u024A\u024C\u024E\u0370\u0372\u0376\u037F\u0386\u0388-\u038A\u038C\u038E-\u038F\u0391-\u03A1\u03A3-\u03AB\u03CF\u03D2-\u03D4\u03D8\u03DA\u03DC\u03DE\u03E0\u03E2\u03E4\u03E6\u03E8\u03EA\u03EC\u03EE\u03F4\u03F7\u03F9-\u03FA\u03FD-\u042F\u0460\u0462\u0464\u0466\u0468\u046A\u046C\u046E\u0470\u0472\u0474\u0476\u0478\u047A\u047C\u047E\u0480\u048A\u048C\u048E\u0490\u0492\u0494\u0496\u0498\u049A\u049C\u049E\u04A0\u04A2\u04A4\u04A6\u04A8\u04AA\u04AC\u04AE\u04B0\u04B2\u04B4\u04B6\u04B8\u04BA\u04BC\u04BE\u04C0-\u04C1\u04C3\u04C5\u04C7\u04C9\u04CB\u04CD\u04D0\u04D2\u04D4\u04D6\u04D8\u04DA\u04DC\u04DE\u04E0\u04E2\u04E4\u04E6\u04E8\u04EA\u04EC\u04EE\u04F0\u04F2\u04F4\u04F6\u04F8\u04FA\u04FC\u04FE\u0500\u0502\u0504\u0506\u0508\u050A\u050C\u050E\u0510\u0512\u0514\u0516\u0518\u051A\u051C\u051E\u0520\u0522\u0524\u0526\u0528\u052A\u052C\u052E\u0531-\u0556\u10A0-\u10C5\u10C7\u10CD\u13A0-\u13F5\u1E00\u1E02\u1E04\u1E06\u1E08\u1E0A\u1E0C\u1E0E\u1E10\u1E12\u1E14\u1E16\u1E18\u1E1A\u1E1C\u1E1E\u1E20\u1E22\u1E24\u1E26\u1E28\u1E2A\u1E2C\u1E2E\u1E30\u1E32\u1E34\u1E36\u1E38\u1E3A\u1E3C\u1E3E\u1E40\u1E42\u1E44\u1E46\u1E48\u1E4A\u1E4C\u1E4E\u1E50\u1E52\u1E54\u1E56\u1E58\u1E5A\u1E5C\u1E5E\u1E60\u1E62\u1E64\u1E66\u1E68\u1E6A\u1E6C\u1E6E\u1E70\u1E72\u1E74\u1E76\u1E78\u1E7A\u1E7C\u1E7E\u1E80\u1E82\u1E84\u1E86\u1E88\u1E8A\u1E8C\u1E8E\u1E90\u1E92\u1E94\u1E9E\u1EA0\u1EA2\u1EA4\u1EA6\u1EA8\u1EAA\u1EAC\u1EAE\u1EB0\u1EB2\u1EB4\u1EB6\u1EB8\u1EBA\u1EBC\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6\u1EC8\u1ECA\u1ECC\u1ECE\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u1EDA\u1EDC\u1EDE\u1EE0\u1EE2\u1EE4\u1EE6\u1EE8\u1EEA\u1EEC\u1EEE\u1EF0\u1EF2\u1EF4\u1EF6\u1EF8\u1EFA\u1EFC\u1EFE\u1F08-\u1F0F\u1F18-\u1F1D\u1F28-\u1F2F\u1F38-\u1F3F\u1F48-\u1F4D\u1F59\u1F5B\u1F5D\u1F5F\u1F68-\u1F6F\u1FB8-\u1FBB\u1FC8-\u1FCB\u1FD8-\u1FDB\u1FE8-\u1FEC\u1FF8-\u1FFB\u2102\u2107\u210B-\u210D\u2110-\u2112\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u2130-\u2133\u213E-\u213F\u2145\u2183\u2C00-\u2C2E\u2C60\u2C62-\u2C64\u2C67\u2C69\u2C6B\u2C6D-\u2C70\u2C72\u2C75\u2C7E-\u2C80\u2C82\u2C84\u2C86\u2C88\u2C8A\u2C8C\u2C8E\u2C90\u2C92\u2C94\u2C96\u2C98\u2C9A\u2C9C\u2C9E\u2CA0\u2CA2\u2CA4\u2CA6\u2CA8\u2CAA\u2CAC\u2CAE\u2CB0\u2CB2\u2CB4\u2CB6\u2CB8\u2CBA\u2CBC\u2CBE\u2CC0\u2CC2\u2CC4\u2CC6\u2CC8\u2CCA\u2CCC\u2CCE\u2CD0\u2CD2\u2CD4\u2CD6\u2CD8\u2CDA\u2CDC\u2CDE\u2CE0\u2CE2\u2CEB\u2CED\u2CF2\uA640\uA642\uA644\uA646\uA648\uA64A\uA64C\uA64E\uA650\uA652\uA654\uA656\uA658\uA65A\uA65C\uA65E\uA660\uA662\uA664\uA666\uA668\uA66A\uA66C\uA680\uA682\uA684\uA686\uA688\uA68A\uA68C\uA68E\uA690\uA692\uA694\uA696\uA698\uA69A\uA722\uA724\uA726\uA728\uA72A\uA72C\uA72E\uA732\uA734\uA736\uA738\uA73A\uA73C\uA73E\uA740\uA742\uA744\uA746\uA748\uA74A\uA74C\uA74E\uA750\uA752\uA754\uA756\uA758\uA75A\uA75C\uA75E\uA760\uA762\uA764\uA766\uA768\uA76A\uA76C\uA76E\uA779\uA77B\uA77D-\uA77E\uA780\uA782\uA784\uA786\uA78B\uA78D\uA790\uA792\uA796\uA798\uA79A\uA79C\uA79E\uA7A0\uA7A2\uA7A4\uA7A6\uA7A8\uA7AA-\uA7AD\uA7B0-\uA7B4\uA7B6\uFF21-\uFF3A/.source,
    // Letter, Titlecase
    /\u01C5\u01C8\u01CB\u01F2\u1F88-\u1F8F\u1F98-\u1F9F\u1FA8-\u1FAF\u1FBC\u1FCC\u1FFC/.source,
    // Letter, Lowercase
    /\u0061-\u007A\u00B5\u00DF-\u00F6\u00F8-\u00FF\u0101\u0103\u0105\u0107\u0109\u010B\u010D\u010F\u0111\u0113\u0115\u0117\u0119\u011B\u011D\u011F\u0121\u0123\u0125\u0127\u0129\u012B\u012D\u012F\u0131\u0133\u0135\u0137-\u0138\u013A\u013C\u013E\u0140\u0142\u0144\u0146\u0148-\u0149\u014B\u014D\u014F\u0151\u0153\u0155\u0157\u0159\u015B\u015D\u015F\u0161\u0163\u0165\u0167\u0169\u016B\u016D\u016F\u0171\u0173\u0175\u0177\u017A\u017C\u017E-\u0180\u0183\u0185\u0188\u018C-\u018D\u0192\u0195\u0199-\u019B\u019E\u01A1\u01A3\u01A5\u01A8\u01AA-\u01AB\u01AD\u01B0\u01B4\u01B6\u01B9-\u01BA\u01BD-\u01BF\u01C6\u01C9\u01CC\u01CE\u01D0\u01D2\u01D4\u01D6\u01D8\u01DA\u01DC-\u01DD\u01DF\u01E1\u01E3\u01E5\u01E7\u01E9\u01EB\u01ED\u01EF-\u01F0\u01F3\u01F5\u01F9\u01FB\u01FD\u01FF\u0201\u0203\u0205\u0207\u0209\u020B\u020D\u020F\u0211\u0213\u0215\u0217\u0219\u021B\u021D\u021F\u0221\u0223\u0225\u0227\u0229\u022B\u022D\u022F\u0231\u0233-\u0239\u023C\u023F-\u0240\u0242\u0247\u0249\u024B\u024D\u024F-\u0293\u0295-\u02AF\u0371\u0373\u0377\u037B-\u037D\u0390\u03AC-\u03CE\u03D0-\u03D1\u03D5-\u03D7\u03D9\u03DB\u03DD\u03DF\u03E1\u03E3\u03E5\u03E7\u03E9\u03EB\u03ED\u03EF-\u03F3\u03F5\u03F8\u03FB-\u03FC\u0430-\u045F\u0461\u0463\u0465\u0467\u0469\u046B\u046D\u046F\u0471\u0473\u0475\u0477\u0479\u047B\u047D\u047F\u0481\u048B\u048D\u048F\u0491\u0493\u0495\u0497\u0499\u049B\u049D\u049F\u04A1\u04A3\u04A5\u04A7\u04A9\u04AB\u04AD\u04AF\u04B1\u04B3\u04B5\u04B7\u04B9\u04BB\u04BD\u04BF\u04C2\u04C4\u04C6\u04C8\u04CA\u04CC\u04CE-\u04CF\u04D1\u04D3\u04D5\u04D7\u04D9\u04DB\u04DD\u04DF\u04E1\u04E3\u04E5\u04E7\u04E9\u04EB\u04ED\u04EF\u04F1\u04F3\u04F5\u04F7\u04F9\u04FB\u04FD\u04FF\u0501\u0503\u0505\u0507\u0509\u050B\u050D\u050F\u0511\u0513\u0515\u0517\u0519\u051B\u051D\u051F\u0521\u0523\u0525\u0527\u0529\u052B\u052D\u052F\u0561-\u0587\u13F8-\u13FD\u1D00-\u1D2B\u1D6B-\u1D77\u1D79-\u1D9A\u1E01\u1E03\u1E05\u1E07\u1E09\u1E0B\u1E0D\u1E0F\u1E11\u1E13\u1E15\u1E17\u1E19\u1E1B\u1E1D\u1E1F\u1E21\u1E23\u1E25\u1E27\u1E29\u1E2B\u1E2D\u1E2F\u1E31\u1E33\u1E35\u1E37\u1E39\u1E3B\u1E3D\u1E3F\u1E41\u1E43\u1E45\u1E47\u1E49\u1E4B\u1E4D\u1E4F\u1E51\u1E53\u1E55\u1E57\u1E59\u1E5B\u1E5D\u1E5F\u1E61\u1E63\u1E65\u1E67\u1E69\u1E6B\u1E6D\u1E6F\u1E71\u1E73\u1E75\u1E77\u1E79\u1E7B\u1E7D\u1E7F\u1E81\u1E83\u1E85\u1E87\u1E89\u1E8B\u1E8D\u1E8F\u1E91\u1E93\u1E95-\u1E9D\u1E9F\u1EA1\u1EA3\u1EA5\u1EA7\u1EA9\u1EAB\u1EAD\u1EAF\u1EB1\u1EB3\u1EB5\u1EB7\u1EB9\u1EBB\u1EBD\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7\u1EC9\u1ECB\u1ECD\u1ECF\u1ED1\u1ED3\u1ED5\u1ED7\u1ED9\u1EDB\u1EDD\u1EDF\u1EE1\u1EE3\u1EE5\u1EE7\u1EE9\u1EEB\u1EED\u1EEF\u1EF1\u1EF3\u1EF5\u1EF7\u1EF9\u1EFB\u1EFD\u1EFF-\u1F07\u1F10-\u1F15\u1F20-\u1F27\u1F30-\u1F37\u1F40-\u1F45\u1F50-\u1F57\u1F60-\u1F67\u1F70-\u1F7D\u1F80-\u1F87\u1F90-\u1F97\u1FA0-\u1FA7\u1FB0-\u1FB4\u1FB6-\u1FB7\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FC7\u1FD0-\u1FD3\u1FD6-\u1FD7\u1FE0-\u1FE7\u1FF2-\u1FF4\u1FF6-\u1FF7\u210A\u210E-\u210F\u2113\u212F\u2134\u2139\u213C-\u213D\u2146-\u2149\u214E\u2184\u2C30-\u2C5E\u2C61\u2C65-\u2C66\u2C68\u2C6A\u2C6C\u2C71\u2C73-\u2C74\u2C76-\u2C7B\u2C81\u2C83\u2C85\u2C87\u2C89\u2C8B\u2C8D\u2C8F\u2C91\u2C93\u2C95\u2C97\u2C99\u2C9B\u2C9D\u2C9F\u2CA1\u2CA3\u2CA5\u2CA7\u2CA9\u2CAB\u2CAD\u2CAF\u2CB1\u2CB3\u2CB5\u2CB7\u2CB9\u2CBB\u2CBD\u2CBF\u2CC1\u2CC3\u2CC5\u2CC7\u2CC9\u2CCB\u2CCD\u2CCF\u2CD1\u2CD3\u2CD5\u2CD7\u2CD9\u2CDB\u2CDD\u2CDF\u2CE1\u2CE3-\u2CE4\u2CEC\u2CEE\u2CF3\u2D00-\u2D25\u2D27\u2D2D\uA641\uA643\uA645\uA647\uA649\uA64B\uA64D\uA64F\uA651\uA653\uA655\uA657\uA659\uA65B\uA65D\uA65F\uA661\uA663\uA665\uA667\uA669\uA66B\uA66D\uA681\uA683\uA685\uA687\uA689\uA68B\uA68D\uA68F\uA691\uA693\uA695\uA697\uA699\uA69B\uA723\uA725\uA727\uA729\uA72B\uA72D\uA72F-\uA731\uA733\uA735\uA737\uA739\uA73B\uA73D\uA73F\uA741\uA743\uA745\uA747\uA749\uA74B\uA74D\uA74F\uA751\uA753\uA755\uA757\uA759\uA75B\uA75D\uA75F\uA761\uA763\uA765\uA767\uA769\uA76B\uA76D\uA76F\uA771-\uA778\uA77A\uA77C\uA77F\uA781\uA783\uA785\uA787\uA78C\uA78E\uA791\uA793-\uA795\uA797\uA799\uA79B\uA79D\uA79F\uA7A1\uA7A3\uA7A5\uA7A7\uA7A9\uA7B5\uA7B7\uA7FA\uAB30-\uAB5A\uAB60-\uAB65\uAB70-\uABBF\uFB00-\uFB06\uFB13-\uFB17\uFF41-\uFF5A/.source,
    // Letter, Modifier
    /\u02B0-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0374\u037A\u0559\u0640\u06E5-\u06E6\u07F4-\u07F5\u07FA\u081A\u0824\u0828\u0971\u0E46\u0EC6\u10FC\u17D7\u1843\u1AA7\u1C78-\u1C7D\u1D2C-\u1D6A\u1D78\u1D9B-\u1DBF\u2071\u207F\u2090-\u209C\u2C7C-\u2C7D\u2D6F\u2E2F\u3005\u3031-\u3035\u303B\u309D-\u309E\u30FC-\u30FE\uA015\uA4F8-\uA4FD\uA60C\uA67F\uA69C-\uA69D\uA717-\uA71F\uA770\uA788\uA7F8-\uA7F9\uA9CF\uA9E6\uAA70\uAADD\uAAF3-\uAAF4\uAB5C-\uAB5F\uFF70\uFF9E-\uFF9F/.source,
    // Letter, Other
    /\u00AA\u00BA\u01BB\u01C0-\u01C3\u0294\u05D0-\u05EA\u05F0-\u05F2\u0620-\u063F\u0641-\u064A\u066E-\u066F\u0671-\u06D3\u06D5\u06EE-\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u0800-\u0815\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0972-\u0980\u0985-\u098C\u098F-\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC-\u09DD\u09DF-\u09E1\u09F0-\u09F1\u0A05-\u0A0A\u0A0F-\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32-\u0A33\u0A35-\u0A36\u0A38-\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2-\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0-\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F-\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32-\u0B33\u0B35-\u0B39\u0B3D\u0B5C-\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99-\u0B9A\u0B9C\u0B9E-\u0B9F\u0BA3-\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60-\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0-\u0CE1\u0CF1-\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32-\u0E33\u0E40-\u0E45\u0E81-\u0E82\u0E84\u0E87-\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA-\u0EAB\u0EAD-\u0EB0\u0EB2-\u0EB3\u0EBD\u0EC0-\u0EC4\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065-\u1066\u106E-\u1070\u1075-\u1081\u108E\u10D0-\u10FA\u10FD-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17DC\u1820-\u1842\u1844-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE-\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C77\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5-\u1CF6\u2135-\u2138\u2D30-\u2D67\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3006\u303C\u3041-\u3096\u309F\u30A1-\u30FA\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA014\uA016-\uA48C\uA4D0-\uA4F7\uA500-\uA60B\uA610-\uA61F\uA62A-\uA62B\uA66E\uA6A0-\uA6E5\uA78F\uA7F7\uA7FB-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9E0-\uA9E4\uA9E7-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA6F\uAA71-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5-\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADC\uAAE0-\uAAEA\uAAF2\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40-\uFB41\uFB43-\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF66-\uFF6F\uFF71-\uFF9D\uFFA0-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC/.source,
].join('') + ']');
class BibtexParser {
    parse(input, options = {}) {
        // this._progress = 0
        this.pos = 0;
        this.input = input;
        this.max_entries = options.max_entries || 0;
        this.entries = 0;
        this.parsing = null;
        this.chunks = [];
        if (options.async) {
            return this.bibtexAsync().then(() => this.chunks);
        }
        else {
            this.bibtex();
            return this.chunks;
        }
    }
    isWhitespace(s, horizontalOnly = false) {
        return (s === ' ' || s === '\t' || (!horizontalOnly && (s === '\r' || s === '\n')));
    }
    match(s) {
        this.skipWhitespace();
        if (this.input.substr(this.pos, s.length) !== s) {
            throw new ParseError(`Token mismatch, expected ${JSON.stringify(s)}, found ${JSON.stringify(this.input.substr(this.pos, 20))}...`, this); // tslint:disable-line no-magic-numbers
        }
        this.pos += s.length;
        this.skipWhitespace();
    }
    tryMatch(s) {
        this.skipWhitespace();
        return (this.input.substr(this.pos, s.length) === s);
        // this.skipWhitespace()
    }
    skipWhitespace() {
        while (this.pos < this.input.length && this.isWhitespace(this.input[this.pos]))
            this.pos++;
        // shady
        if (this.input[this.pos] === '%') {
            while (this.pos < this.input.length && this.input[this.pos] !== '\n')
                this.pos++;
            while (this.pos < this.input.length && this.isWhitespace(this.input[this.pos]))
                this.pos++;
        }
    }
    value_braces() {
        let bracecount = 0;
        this.match('{');
        const start = this.pos;
        let math = false;
        while (true) {
            switch (this.input[this.pos]) {
                case '\\':
                    this.pos += 1;
                    break;
                case '{':
                    bracecount++;
                    break;
                case '}':
                    if (bracecount === 0) {
                        if (math)
                            throw new ParseError('Unclosed math section', this);
                        this.pos++;
                        return this.input.substring(start, this.pos - 1);
                    }
                    bracecount--;
                    break;
                case '$':
                    math = !math;
                    break;
            }
            this.pos++;
            if (this.pos >= this.input.length) {
                throw new ParseError(`Unterminated brace-value ${JSON.stringify(this.input.substr(start, 20))}`, this); // tslint:disable-line no-magic-numbers
            }
        }
    }
    value_quotes() {
        this.match('"');
        const start = this.pos;
        let bracecount = 0;
        while (true) {
            switch (this.input[this.pos]) {
                case '\\':
                    this.pos += 1;
                    break;
                case '{':
                    bracecount++;
                    break;
                case '}':
                    bracecount--;
                    break;
                case '"':
                    if (bracecount <= 0) {
                        this.pos++;
                        return this.input.substring(start, this.pos - 1);
                    }
            }
            this.pos++;
            if (this.pos >= this.input.length) {
                throw new ParseError(`Unterminated quote-value ${JSON.stringify(this.input.substr(start, 20))}`, this); // tslint:disable-line no-magic-numbers
            }
        }
    }
    single_value() {
        if (this.tryMatch('{')) {
            return this.value_braces();
        }
        else if (this.tryMatch('"')) {
            return this.value_quotes();
        }
        else {
            return this.key();
        }
    }
    value() {
        const values = [];
        values.push(this.single_value());
        while (this.tryMatch('#')) {
            this.match('#');
            values.push(this.single_value());
        }
        return values.join('');
    }
    key(allowUnicode = false) {
        const start = this.pos;
        while (true) {
            if (this.pos === this.input.length) {
                throw new ParseError('Runaway key', this);
            }
            if (this.input[this.pos].match(/['a-zA-Z0-9&;_:\\./-]/)) {
                this.pos++;
            }
            else if (allowUnicode && this.input[this.pos].match(letter)) {
                this.pos++;
            }
            else {
                return this.input.substring(start, this.pos);
            }
        }
    }
    key_equals_value() {
        const key = this.key();
        if (!this.tryMatch('=')) {
            throw new ParseError(`... = value expected, equals sign missing: ${JSON.stringify(this.input.substr(this.pos, 20))}...`, this); // tslint:disable-line no-magic-numbers
        }
        this.match('=');
        const val = this.value();
        return [key, val];
    }
    key_value_list() {
        this.key_equals_value();
        while (this.tryMatch(',')) {
            this.match(',');
            // fixes problems with commas at the end of a list
            if (this.tryMatch('}')) {
                break;
            }
            this.key_equals_value();
        }
    }
    entry(d) {
        this.parsing = this.key(true);
        this.match(',');
        this.key_value_list();
    }
    directive() {
        this.match('@');
        return `@${this.key()}`.toLowerCase();
    }
    string() {
        this.key_equals_value();
    }
    preamble() {
        this.value();
    }
    comment() {
        while (this.isWhitespace(this.input[this.pos], true))
            this.pos++;
        if (this.input[this.pos] === '{') {
            this.value_braces();
            return;
        }
        while (this.input[this.pos] !== '\n' && this.pos < this.input.length)
            this.pos++;
    }
    /*
    private progress() {
      const progress = Math.round((this.pos / this.input.length * 100) / 5) * 5 // tslint:disable-line no-magic-numbers
      if (this._progress !== progress) {
        this._progress = progress
        process.stdout.write(` (${this._progress}%) `)
      }
    }
    */
    hasMore() {
        if (this.max_entries && this.entries >= this.max_entries)
            return false;
        return (this.pos < this.input.length);
    }
    bibtex() {
        while (this.hasMore()) {
            this.parseNext();
        }
    }
    bibtexAsync() {
        return this.hasMore() ? (new Promise(resolve => resolve(this.parseNext()))).then(() => this.bibtexAsync()) : Promise.resolve(null);
    }
    parseNext() {
        // this.progress()
        const chunk = {
            offset: {
                pos: this.pos,
                line: this.input.substring(0, this.pos).split('\n').length - 1,
            },
            error: null,
            text: null,
        };
        this.skipWhitespace();
        if (this.pos >= this.input.length)
            return;
        let guard = '';
        try {
            const d = this.directive();
            switch (d) {
                case '@string':
                    this.match('{');
                    this.string();
                    this.match('}');
                    chunk.stringDeclaration = true;
                    break;
                case '@preamble':
                    this.match('{');
                    this.preamble();
                    this.match('}');
                    chunk.preamble = true;
                    break;
                case '@comment':
                    this.comment();
                    chunk.comment = true;
                    break;
                default:
                    if (this.tryMatch('{')) {
                        guard = '{}';
                    }
                    else if (this.tryMatch('(')) {
                        guard = '()';
                    }
                    else {
                        throw new ParseError(`Token mismatch, expected '{' or '(', found ${JSON.stringify(this.input.substr(this.pos, 20))}...`, this); // tslint:disable-line no-magic-numbers
                    }
                    this.match(guard[0]);
                    this.entry(d);
                    this.match(guard[1]);
                    chunk.entry = true;
                    this.entries++;
                    break;
            }
        }
        catch (err) {
            if (err.name !== 'ParseError')
                throw err;
            chunk.error = err.message,
                // skip ahead to the next @ and try again
                this.pos = chunk.offset.pos + 1;
            while (this.pos < this.input.length && this.input[this.pos] !== '@')
                this.pos++;
        }
        const text = this.input.substring(chunk.offset.pos, this.pos);
        const last = this.chunks.length - 1;
        if (chunk.error && this.chunks.length && this.chunks[last].error) {
            this.chunks[last].text += text;
        }
        else {
            chunk.text = text;
            this.chunks.push(chunk);
        }
    }
}
/**
 * Reads the bibtex input and splits it into separate chunks of `@string`s, `@comment`s, and bibtex entries. Useful for detecting if a file is bibtex file and for filtering out basic errors that would
 * make the more sophisticated [[bibtex.parse]] reject the whole file
 *
 * @returns array of chunks, with markers for type and errors (if any) found.
 */
function parse(input, options = {}) {
    return (new BibtexParser).parse(input, options);
}
exports.parse = parse;

});

var $ = {
	math: "\\$",
	text: "\\$"
};
var _ = {
	math: "\\_",
	text: "\\_"
};
var require$$0$1 = {
	"#": {
	math: "\\#",
	text: "\\#"
},
	$: $,
	"%": {
	math: "\\%",
	text: "\\%"
},
	"&": {
	math: "\\&",
	text: "\\&"
},
	"/​": {
	text: "\\slash",
	commandspacer: true
},
	"<": {
	math: "<"
},
	">": {
	math: ">"
},
	"\\": {
	math: "\\backslash",
	text: "\\textbackslash",
	commandspacer: true
},
	"^": {
	math: "\\sphat",
	text: "\\^"
},
	_: _,
	"i︠a︡": {
	text: "\\t{ia}"
},
	"{": {
	math: "\\lbrace",
	text: "\\{"
},
	"}": {
	math: "\\rbrace",
	text: "\\}"
},
	"~": {
	math: "\\sptilde",
	text: "\\textasciitilde",
	commandspacer: true
},
	" ": {
	math: "~",
	space: true,
	text: "~"
},
	"¡": {
	text: "\\textexclamdown",
	commandspacer: true
},
	"¢": {
	math: "\\cent",
	text: "\\textcent",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"£": {
	math: "\\pounds",
	text: "\\textsterling",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"¤": {
	text: "\\textcurrency",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"¥": {
	math: "\\yen",
	text: "\\textyen",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"¦": {
	text: "\\textbrokenbar",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"§": {
	text: "\\textsection",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"¨": {
	math: "\\spddot",
	text: "\\textasciidieresis",
	commandspacer: true
},
	"©": {
	text: "\\textcopyright",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"ª": {
	text: "\\textordfeminine",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"«": {
	text: "\\guillemotleft",
	commandspacer: true
},
	"¬": {
	math: "\\lnot"
},
	"­": {
	math: "\\-",
	text: "\\-"
},
	"®": {
	math: "\\circledR",
	text: "\\textregistered",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"¯": {
	text: "\\textasciimacron",
	commandspacer: true
},
	"°": {
	math: "^\\circ",
	text: "\\textdegree",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"±": {
	math: "\\pm"
},
	"²": {
	math: "^{2}"
},
	"³": {
	math: "^{3}"
},
	"´": {
	text: "\\textasciiacute",
	commandspacer: true
},
	"µ": {
	text: "\\textmu",
	commandspacer: true
},
	"¶": {
	text: "\\textparagraph",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"·": {
	math: "\\cdot"
},
	"¸": {
	text: "\\c",
	commandspacer: true
},
	"¹": {
	math: "^{1}"
},
	"º": {
	text: "\\textordmasculine",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"»": {
	text: "\\guillemotright",
	commandspacer: true
},
	"¼": {
	math: "\\frac{1}{4}"
},
	"½": {
	math: "\\frac{1}{2}"
},
	"¾": {
	math: "\\frac{3}{4}"
},
	"¿": {
	text: "\\textquestiondown",
	commandspacer: true
},
	"À": {
	text: "\\`A"
},
	"Á": {
	text: "\\'A"
},
	"Â": {
	text: "\\^A"
},
	"Ã": {
	text: "\\~A"
},
	"Ä": {
	text: "\\\"A"
},
	"Å": {
	text: "\\AA",
	commandspacer: true
},
	"Æ": {
	text: "\\AE",
	commandspacer: true
},
	"Ç": {
	text: "\\c{C}"
},
	"È": {
	text: "\\`E"
},
	"É": {
	text: "\\'E"
},
	"Ê": {
	text: "\\^E"
},
	"Ë": {
	text: "\\\"E"
},
	"Ì": {
	text: "\\`I"
},
	"Í": {
	text: "\\'I"
},
	"Î": {
	text: "\\^I"
},
	"Ï": {
	text: "\\\"I"
},
	"Ð": {
	text: "\\DH",
	commandspacer: true
},
	"Ñ": {
	text: "\\~N"
},
	"Ò": {
	text: "\\`O"
},
	"Ó": {
	text: "\\'O"
},
	"Ô": {
	text: "\\^O"
},
	"Õ": {
	text: "\\~O"
},
	"Ö": {
	text: "\\\"O"
},
	"×": {
	math: "\\times",
	text: "\\texttimes",
	commandspacer: true
},
	"Ø": {
	text: "\\O",
	commandspacer: true
},
	"Ù": {
	text: "\\`U"
},
	"Ú": {
	text: "\\'U"
},
	"Û": {
	text: "\\^U"
},
	"Ü": {
	text: "\\\"U"
},
	"Ý": {
	text: "\\'Y"
},
	"Þ": {
	text: "\\TH",
	commandspacer: true
},
	"ß": {
	text: "\\ss",
	commandspacer: true
},
	"à": {
	text: "\\`a"
},
	"á": {
	text: "\\'a"
},
	"â": {
	text: "\\^a"
},
	"ã": {
	text: "\\~a"
},
	"ä": {
	text: "\\\"a"
},
	"å": {
	text: "\\aa",
	commandspacer: true
},
	"æ": {
	text: "\\ae",
	commandspacer: true
},
	"ç": {
	text: "\\c{c}"
},
	"è": {
	text: "\\`e"
},
	"é": {
	text: "\\'e"
},
	"ê": {
	text: "\\^e"
},
	"ë": {
	text: "\\\"e"
},
	"ì": {
	text: "\\`i"
},
	"í": {
	text: "\\'i"
},
	"î": {
	text: "\\^i"
},
	"ï": {
	text: "\\\"i"
},
	"ð": {
	math: "\\eth",
	mathpackages: [
		"amssymb",
		"arevmath"
	],
	text: "\\dh",
	commandspacer: true
},
	"ñ": {
	text: "\\~n"
},
	"ò": {
	text: "\\`o"
},
	"ó": {
	text: "\\'o"
},
	"ô": {
	text: "\\^o"
},
	"õ": {
	text: "\\~o"
},
	"ö": {
	text: "\\\"o"
},
	"÷": {
	math: "\\div"
},
	"ø": {
	text: "\\o",
	commandspacer: true
},
	"ù": {
	text: "\\`u"
},
	"ú": {
	text: "\\'u"
},
	"û": {
	text: "\\^u"
},
	"ü": {
	text: "\\\"u"
},
	"ý": {
	text: "\\'y"
},
	"þ": {
	text: "\\th",
	commandspacer: true
},
	"ÿ": {
	text: "\\\"y"
},
	"Ā": {
	text: "\\=A"
},
	"ā": {
	text: "\\=a"
},
	"Ă": {
	text: "\\u{A}"
},
	"ă": {
	text: "\\u{a}"
},
	"Ą": {
	text: "\\k{A}"
},
	"ą": {
	text: "\\k{a}"
},
	"Ć": {
	text: "\\'C"
},
	"ć": {
	text: "\\'c"
},
	"Ĉ": {
	text: "\\^C"
},
	"ĉ": {
	text: "\\^c"
},
	"Ċ": {
	text: "\\.C"
},
	"ċ": {
	text: "\\.c"
},
	"Č": {
	text: "\\v{C}"
},
	"č": {
	text: "\\v{c}"
},
	"Ď": {
	text: "\\v{D}"
},
	"ď": {
	text: "\\v{d}"
},
	"Đ": {
	text: "\\DJ",
	commandspacer: true
},
	"đ": {
	text: "\\dj",
	commandspacer: true
},
	"Ē": {
	text: "\\=E"
},
	"ē": {
	text: "\\=e"
},
	"Ĕ": {
	text: "\\u{E}"
},
	"ĕ": {
	text: "\\u{e}"
},
	"Ė": {
	text: "\\.E"
},
	"ė": {
	text: "\\.e"
},
	"Ę": {
	text: "\\k{E}"
},
	"ę": {
	text: "\\k{e}"
},
	"Ě": {
	text: "\\v{E}"
},
	"ě": {
	text: "\\v{e}"
},
	"Ĝ": {
	text: "\\^G"
},
	"ĝ": {
	text: "\\^g"
},
	"Ğ": {
	text: "\\u{G}"
},
	"ğ": {
	text: "\\u{g}"
},
	"Ġ": {
	text: "\\.G"
},
	"ġ": {
	text: "\\.g"
},
	"Ģ": {
	text: "\\c{G}"
},
	"ģ": {
	text: "\\c{g}"
},
	"Ĥ": {
	text: "\\^H"
},
	"ĥ": {
	text: "\\^h"
},
	"Ħ": {
	text: "{\\fontencoding{LELA}\\selectfont\\char40}"
},
	"ħ": {
	math: "\\Elzxh"
},
	"Ĩ": {
	text: "\\~I"
},
	"ĩ": {
	text: "\\~i"
},
	"Ī": {
	text: "\\=I"
},
	"ī": {
	text: "\\=i"
},
	"Ĭ": {
	text: "\\u{I}"
},
	"ĭ": {
	text: "{\\u \\i}"
},
	"Į": {
	text: "\\k{I}"
},
	"į": {
	text: "\\k{i}"
},
	"İ": {
	text: "\\.I"
},
	"ı": {
	math: "\\imath",
	text: "\\i",
	commandspacer: true
},
	"Ĳ": {
	text: "IJ"
},
	"ĳ": {
	text: "ij"
},
	"Ĵ": {
	text: "\\^J"
},
	"ĵ": {
	text: "\\^\\j",
	commandspacer: true
},
	"Ķ": {
	text: "\\c{K}"
},
	"ķ": {
	text: "\\c{k}"
},
	"ĸ": {
	text: "{\\fontencoding{LELA}\\selectfont\\char91}"
},
	"Ĺ": {
	text: "\\'L"
},
	"ĺ": {
	text: "\\'l"
},
	"Ļ": {
	text: "\\c{L}"
},
	"ļ": {
	text: "\\c{l}"
},
	"Ľ": {
	text: "\\v{L}"
},
	"ľ": {
	text: "\\v{l}"
},
	"Ŀ": {
	text: "{\\fontencoding{LELA}\\selectfont\\char201}"
},
	"ŀ": {
	text: "{\\fontencoding{LELA}\\selectfont\\char202}"
},
	"Ł": {
	text: "\\L",
	commandspacer: true
},
	"ł": {
	text: "\\l",
	commandspacer: true
},
	"Ń": {
	text: "\\'N"
},
	"ń": {
	text: "\\'n"
},
	"Ņ": {
	text: "\\c{N}"
},
	"ņ": {
	text: "\\c{n}"
},
	"Ň": {
	text: "\\v{N}"
},
	"ň": {
	text: "\\v{n}"
},
	"ŉ": {
	text: "'n"
},
	"Ŋ": {
	text: "\\NG",
	commandspacer: true
},
	"ŋ": {
	text: "\\ng",
	commandspacer: true
},
	"Ō": {
	text: "\\=O"
},
	"ō": {
	text: "\\=o"
},
	"Ŏ": {
	text: "\\u{O}"
},
	"ŏ": {
	text: "\\u{o}"
},
	"Ő": {
	text: "\\H{O}"
},
	"ő": {
	text: "\\H{o}"
},
	"Œ": {
	text: "\\OE",
	commandspacer: true
},
	"œ": {
	text: "\\oe",
	commandspacer: true
},
	"Ŕ": {
	text: "\\'R"
},
	"ŕ": {
	text: "\\'r"
},
	"Ŗ": {
	text: "\\c{R}"
},
	"ŗ": {
	text: "\\c{r}"
},
	"Ř": {
	text: "\\v{R}"
},
	"ř": {
	text: "\\v{r}"
},
	"Ś": {
	text: "\\'S"
},
	"ś": {
	text: "\\'s"
},
	"Ŝ": {
	text: "\\^S"
},
	"ŝ": {
	text: "\\^s"
},
	"Ş": {
	text: "\\c{S}"
},
	"ş": {
	text: "\\c{s}"
},
	"Š": {
	text: "\\v{S}"
},
	"š": {
	text: "\\v{s}"
},
	"Ţ": {
	text: "\\c{T}"
},
	"ţ": {
	text: "\\c{t}"
},
	"Ť": {
	text: "\\v{T}"
},
	"ť": {
	text: "\\v{t}"
},
	"Ŧ": {
	text: "{\\fontencoding{LELA}\\selectfont\\char47}"
},
	"ŧ": {
	text: "{\\fontencoding{LELA}\\selectfont\\char63}"
},
	"Ũ": {
	text: "\\~U"
},
	"ũ": {
	text: "\\~u"
},
	"Ū": {
	text: "\\=U"
},
	"ū": {
	text: "\\=u"
},
	"Ŭ": {
	text: "\\u{U}"
},
	"ŭ": {
	text: "\\u{u}"
},
	"Ů": {
	text: "\\r{U}"
},
	"ů": {
	text: "\\r{u}"
},
	"Ű": {
	text: "\\H{U}"
},
	"ű": {
	text: "\\H{u}"
},
	"Ų": {
	text: "\\k{U}"
},
	"ų": {
	text: "\\k{u}"
},
	"Ŵ": {
	text: "\\^W"
},
	"ŵ": {
	text: "\\^w"
},
	"Ŷ": {
	text: "\\^Y"
},
	"ŷ": {
	text: "\\^y"
},
	"Ÿ": {
	text: "\\\"Y"
},
	"Ź": {
	text: "\\'Z"
},
	"ź": {
	text: "\\'z"
},
	"Ż": {
	text: "\\.Z"
},
	"ż": {
	text: "\\.z"
},
	"Ž": {
	text: "\\v{Z}"
},
	"ž": {
	text: "\\v{z}"
},
	"ſ": {
	text: "s"
},
	"ƒ": {
	math: "f"
},
	"ƕ": {
	text: "\\texthvlig",
	commandspacer: true
},
	"ƞ": {
	text: "\\textnrleg",
	commandspacer: true
},
	"ƪ": {
	text: "\\textesh",
	commandspacer: true
},
	"Ƶ": {
	math: "\\Zbar"
},
	"ƺ": {
	text: "{\\fontencoding{LELA}\\selectfont\\char195}"
},
	"ǂ": {
	text: "\\textdoublepipe",
	commandspacer: true
},
	"Ǎ": {
	text: "\\v{A}"
},
	"ǎ": {
	text: "\\v{a}"
},
	"Ǐ": {
	text: "\\v{I}"
},
	"ǐ": {
	text: "\\v{i}"
},
	"Ǒ": {
	text: "\\v{O}"
},
	"ǒ": {
	text: "\\v{o}"
},
	"Ǔ": {
	text: "\\v{U}"
},
	"ǔ": {
	text: "\\v{u}"
},
	"Ǧ": {
	text: "\\v{G}"
},
	"ǧ": {
	text: "\\v{g}"
},
	"Ǩ": {
	text: "\\v{K}"
},
	"ǩ": {
	text: "\\v{k}"
},
	"Ǫ": {
	text: "\\k{O}"
},
	"ǫ": {
	text: "\\k{o}"
},
	"ǰ": {
	text: "\\v{j}"
},
	"Ǵ": {
	text: "\\'G"
},
	"ǵ": {
	text: "\\'g"
},
	"Ȩ": {
	text: "\\c{E}"
},
	"ȩ": {
	text: "\\c{e}"
},
	"ȷ": {
	math: "\\jmath"
},
	"ɐ": {
	math: "\\Elztrna"
},
	"ɒ": {
	math: "\\Elztrnsa"
},
	"ɔ": {
	math: "\\Elzopeno"
},
	"ɖ": {
	math: "\\Elzrtld"
},
	"ɘ": {
	text: "{\\fontencoding{LEIP}\\selectfont\\char61}"
},
	"ə": {
	math: "\\Elzschwa"
},
	"ɛ": {
	math: "\\varepsilon"
},
	"ɡ": {
	text: "g"
},
	"ɣ": {
	math: "\\Elzpgamma"
},
	"ɤ": {
	math: "\\Elzpbgam"
},
	"ɥ": {
	math: "\\Elztrnh"
},
	"ɬ": {
	math: "\\Elzbtdl"
},
	"ɭ": {
	math: "\\Elzrtll"
},
	"ɯ": {
	math: "\\Elztrnm"
},
	"ɰ": {
	math: "\\Elztrnmlr"
},
	"ɱ": {
	math: "\\Elzltlmr"
},
	"ɲ": {
	text: "\\Elzltln",
	commandspacer: true
},
	"ɳ": {
	math: "\\Elzrtln"
},
	"ɷ": {
	math: "\\Elzclomeg"
},
	"ɸ": {
	text: "\\textphi",
	commandspacer: true
},
	"ɹ": {
	math: "\\Elztrnr"
},
	"ɺ": {
	math: "\\Elztrnrl"
},
	"ɻ": {
	math: "\\Elzrttrnr"
},
	"ɼ": {
	math: "\\Elzrl"
},
	"ɽ": {
	math: "\\Elzrtlr"
},
	"ɾ": {
	math: "\\Elzfhr"
},
	"ɿ": {
	text: "{\\fontencoding{LEIP}\\selectfont\\char202}"
},
	"ʂ": {
	math: "\\Elzrtls"
},
	"ʃ": {
	math: "\\Elzesh"
},
	"ʇ": {
	math: "\\Elztrnt"
},
	"ʈ": {
	math: "\\Elzrtlt"
},
	"ʊ": {
	math: "\\Elzpupsil"
},
	"ʋ": {
	math: "\\Elzpscrv"
},
	"ʌ": {
	math: "\\Elzinvv"
},
	"ʍ": {
	math: "\\Elzinvw"
},
	"ʎ": {
	math: "\\Elztrny"
},
	"ʐ": {
	math: "\\Elzrtlz"
},
	"ʒ": {
	math: "\\Elzyogh"
},
	"ʔ": {
	math: "\\Elzglst"
},
	"ʕ": {
	math: "\\Elzreglst"
},
	"ʖ": {
	math: "\\Elzinglst"
},
	"ʞ": {
	text: "\\textturnk",
	commandspacer: true
},
	"ʤ": {
	math: "\\Elzdyogh"
},
	"ʧ": {
	math: "\\Elztesh"
},
	"ʰ": {
	math: "^{h}",
	text: "\\textsuperscript{h}"
},
	"ʲ": {
	math: "^{j}",
	text: "\\textsuperscript{j}"
},
	"ʳ": {
	math: "^{r}",
	text: "\\textsuperscript{r}"
},
	"ʷ": {
	math: "^{w}",
	text: "\\textsuperscript{w}"
},
	"ʸ": {
	math: "^{y}",
	text: "\\textsuperscript{y}"
},
	"ʹ": {
	text: "'"
},
	"ʻ": {
	text: "'"
},
	"ʼ": {
	text: "'"
},
	"ʽ": {
	text: "'"
},
	"ʿ": {
	text: "\\lasp",
	commandspacer: true,
	textpackages: [
		"mathscinet"
	]
},
	"ˆ": {
	text: "\\textasciicircum",
	commandspacer: true
},
	"ˇ": {
	text: "\\textasciicaron",
	commandspacer: true
},
	"ˈ": {
	math: "\\Elzverts"
},
	"ˉ": {
	text: "-"
},
	"ˌ": {
	math: "\\Elzverti"
},
	"ː": {
	math: "\\Elzlmrk"
},
	"ˑ": {
	math: "\\Elzhlmrk"
},
	"˒": {
	math: "\\Elzsbrhr"
},
	"˓": {
	math: "\\Elzsblhr"
},
	"˔": {
	math: "\\Elzrais"
},
	"˕": {
	math: "\\Elzlow"
},
	"˘": {
	text: "\\textasciibreve",
	commandspacer: true
},
	"˙": {
	text: "\\textperiodcentered",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"˚": {
	text: "\\r{}"
},
	"˛": {
	text: "\\k{}"
},
	"˜": {
	text: "\\texttildelow",
	commandspacer: true
},
	"˝": {
	text: "\\H{}"
},
	"ˡ": {
	math: "^{l}",
	text: "\\textsuperscript{l}"
},
	"ˢ": {
	math: "^{s}",
	text: "\\textsuperscript{s}"
},
	"ˣ": {
	math: "^{x}",
	text: "\\textsuperscript{x}"
},
	"˥": {
	text: "\\tone{55}"
},
	"˦": {
	text: "\\tone{44}"
},
	"˧": {
	text: "\\tone{33}"
},
	"˨": {
	text: "\\tone{22}"
},
	"˩": {
	text: "\\tone{11}"
},
	"̀": {
	math: "\\grave",
	combiningdiacritic: true,
	text: "\\`"
},
	"̀̄": {
	text: "\\textgravemacron",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̄̀": {
	text: "\\textgravemacron",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̀̇": {
	text: "\\textgravedot",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̇̀": {
	text: "\\textgravedot",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"́": {
	math: "\\acute",
	combiningdiacritic: true,
	text: "\\'"
},
	"́̄": {
	text: "\\textacutemacron",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̄́": {
	text: "\\textacutemacron",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"́̌": {
	text: "\\textacutewedge",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̌́": {
	text: "\\textacutewedge",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̂": {
	math: "\\hat",
	combiningdiacritic: true,
	text: "\\^"
},
	"̂̇": {
	text: "\\textcircumdot",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̇̂": {
	text: "\\textcircumdot",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̃": {
	math: "\\tilde",
	combiningdiacritic: true,
	text: "\\~"
},
	"̃̇": {
	text: "\\texttildedot",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̇̃": {
	text: "\\texttildedot",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̄": {
	math: "\\bar",
	combiningdiacritic: true,
	text: "\\="
},
	"̅": {
	math: "\\overline",
	combiningdiacritic: true
},
	"̆": {
	math: "\\breve",
	combiningdiacritic: true,
	text: "\\u",
	commandspacer: true
},
	"̆̄": {
	text: "\\textbrevemacron",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̄̆": {
	text: "\\textbrevemacron",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̇": {
	math: "\\dot",
	combiningdiacritic: true,
	text: "\\."
},
	"̇́": {
	text: "\\textdotacute",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"́̇": {
	text: "\\textdotacute",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̇̆": {
	text: "\\textdotbreve",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̆̇": {
	text: "\\textdotbreve",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̈": {
	math: "\\ddot",
	combiningdiacritic: true,
	text: "\\\""
},
	"̉": {
	math: "\\ovhook"
},
	"̊": {
	math: "\\mathring",
	combiningdiacritic: true,
	text: "\\r",
	commandspacer: true
},
	"̊̄": {
	text: "\\textringmacron",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̄̊": {
	text: "\\textringmacron",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̋": {
	text: "\\H",
	commandspacer: true,
	combiningdiacritic: true
},
	"̌": {
	math: "\\check",
	text: "\\v",
	commandspacer: true,
	combiningdiacritic: true
},
	"̍": {
	text: "\\textvbaraccent",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̎": {
	text: "\\textdoublevbaraccent",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̏": {
	text: "\\textdoublegrave",
	commandspacer: true,
	combiningdiacritic: true
},
	"̐": {
	text: "\\textdotbreve",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̑": {
	text: "{\\fontencoding{LECO}\\selectfont\\char177}"
},
	"̒": {
	math: "\\oturnedcomma"
},
	"̕": {
	math: "\\ocommatopright"
},
	"̖": {
	text: "\\textsubgrave",
	commandspacer: true,
	combiningdiacritic: true
},
	"̘": {
	text: "\\textadvancing",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̙": {
	text: "\\textretracting",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̚": {
	math: "\\droang",
	text: "\\textcorner",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̜": {
	text: "\\textsublhalfring",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̝": {
	text: "\\textraising",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̞": {
	text: "\\textlowering",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̟": {
	text: "\\textsubplus",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̡": {
	math: "\\Elzpalh"
},
	"̢": {
	text: "\\Elzrh",
	commandspacer: true
},
	"̣": {
	text: "\\d",
	commandspacer: true,
	combiningdiacritic: true
},
	"̤": {
	text: "\\textsubumlaut",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̥": {
	text: "\\textsubring",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̧": {
	text: "\\c",
	commandspacer: true,
	combiningdiacritic: true
},
	"̨": {
	text: "\\k",
	commandspacer: true,
	combiningdiacritic: true
},
	"̩": {
	text: "\\textsyllabic",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̪": {
	math: "\\Elzsbbrg",
	text: "\\textsubbridge",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̫": {
	text: "{\\fontencoding{LECO}\\selectfont\\char203}"
},
	"̬": {
	text: "\\textsubwedge",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̯": {
	text: "\\textsubarch",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̰": {
	math: "\\utilde",
	text: "\\textsubtilde",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̱": {
	math: "\\underbar",
	combiningdiacritic: true,
	text: "\\textsubbar",
	commandspacer: true,
	textpackages: [
		"tipa"
	]
},
	"̲": {
	math: "\\underline"
},
	"̴": {
	text: "\\textsuperimposetilde",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̵": {
	text: "\\Elzxl",
	commandspacer: true
},
	"̶": {
	text: "\\Elzbar",
	commandspacer: true
},
	"̷": {
	text: "{\\fontencoding{LECO}\\selectfont\\char215}"
},
	"̸": {
	math: "\\not"
},
	"̹": {
	text: "\\textsubrhalfring",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̺": {
	text: "\\textinvsubbridge",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̻": {
	text: "\\textsubsquare",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̼": {
	text: "\\textseagull",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̽": {
	text: "\\textovercross",
	commandspacer: true,
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"͡": {
	text: "{\\fontencoding{LECO}\\selectfont\\char225}"
},
	"ʹ": {
	text: "'"
},
	"͵": {
	text: ","
},
	";": {
	text: ";"
},
	"Ά": {
	text: "\\'A"
},
	"Έ": {
	text: "\\'E"
},
	"Ή": {
	text: "\\'H"
},
	"Ί": {
	text: "{\\'{}I}"
},
	"Ό": {
	text: "{\\'{}O}"
},
	"Ύ": {
	math: "\\mathrm{'Y}"
},
	"Ώ": {
	math: "\\mathrm{'\\Omega}"
},
	"ΐ": {
	math: "\\acute{\\ddot{\\iota}}"
},
	"Α": {
	math: "A"
},
	"Β": {
	math: "B"
},
	"Γ": {
	math: "\\Gamma"
},
	"Δ": {
	math: "\\Delta"
},
	"Ε": {
	math: "E"
},
	"Ζ": {
	math: "Z"
},
	"Η": {
	math: "H"
},
	"Θ": {
	math: "\\Theta"
},
	"Ι": {
	math: "I"
},
	"Κ": {
	math: "K"
},
	"Λ": {
	math: "\\Lambda"
},
	"Μ": {
	math: "M"
},
	"Ν": {
	math: "N"
},
	"Ξ": {
	math: "\\Xi"
},
	"Ο": {
	math: "O"
},
	"Π": {
	math: "\\Pi"
},
	"Ρ": {
	math: "P"
},
	"Σ": {
	math: "\\Sigma"
},
	"Τ": {
	math: "T"
},
	"Υ": {
	math: "\\Upsilon"
},
	"Φ": {
	math: "\\Phi"
},
	"Χ": {
	math: "X"
},
	"Ψ": {
	math: "\\Psi"
},
	"Ω": {
	math: "\\Omega"
},
	"Ϊ": {
	math: "\\mathrm{\\ddot{I}}"
},
	"Ϋ": {
	math: "\\mathrm{\\ddot{Y}}"
},
	"ά": {
	text: "{\\'$\\alpha$}"
},
	"έ": {
	math: "\\acute{\\epsilon}"
},
	"ή": {
	math: "\\acute{\\eta}"
},
	"ί": {
	math: "\\acute{\\iota}"
},
	"ΰ": {
	math: "\\acute{\\ddot{\\upsilon}}"
},
	"α": {
	math: "\\alpha"
},
	"β": {
	math: "\\beta"
},
	"γ": {
	math: "\\gamma"
},
	"δ": {
	math: "\\delta"
},
	"ε": {
	math: "\\epsilon"
},
	"ζ": {
	math: "\\zeta"
},
	"η": {
	math: "\\eta"
},
	"θ": {
	math: "\\theta",
	text: "\\texttheta",
	commandspacer: true
},
	"ι": {
	math: "\\iota"
},
	"κ": {
	math: "\\kappa"
},
	"λ": {
	math: "\\lambda"
},
	"μ": {
	math: "\\mu"
},
	"ν": {
	math: "\\nu"
},
	"ξ": {
	math: "\\xi"
},
	"ο": {
	math: "o"
},
	"π": {
	math: "\\pi"
},
	"ρ": {
	math: "\\rho"
},
	"ς": {
	math: "\\varsigma"
},
	"σ": {
	math: "\\sigma"
},
	"τ": {
	math: "\\tau"
},
	"υ": {
	math: "\\upsilon"
},
	"φ": {
	math: "\\varphi"
},
	"χ": {
	math: "\\chi"
},
	"ψ": {
	math: "\\psi"
},
	"ω": {
	math: "\\omega"
},
	"ϊ": {
	math: "\\ddot{\\iota}"
},
	"ϋ": {
	math: "\\ddot{\\upsilon}"
},
	"ό": {
	text: "\\'o"
},
	"ύ": {
	math: "\\acute{\\upsilon}"
},
	"ώ": {
	math: "\\acute{\\omega}"
},
	"ϐ": {
	math: "\\varbeta",
	text: "\\Pisymbol{ppi022}{87}"
},
	"ϑ": {
	math: "\\vartheta",
	text: "\\textvartheta",
	commandspacer: true
},
	"ϒ": {
	math: "\\Upsilon"
},
	"ϕ": {
	math: "\\phi"
},
	"ϖ": {
	math: "\\varpi"
},
	"Ϙ": {
	math: "\\Qoppa"
},
	"ϙ": {
	math: "\\qoppa"
},
	"Ϛ": {
	math: "\\Stigma"
},
	"ϛ": {
	math: "\\stigma"
},
	"Ϝ": {
	math: "\\Digamma"
},
	"ϝ": {
	math: "\\digamma"
},
	"Ϟ": {
	math: "\\Koppa"
},
	"ϟ": {
	math: "\\koppa"
},
	"Ϡ": {
	math: "\\Sampi"
},
	"ϡ": {
	math: "\\sampi"
},
	"ϰ": {
	math: "\\varkappa"
},
	"ϱ": {
	math: "\\varrho"
},
	"ϴ": {
	math: "\\upvarTheta",
	text: "\\textTheta",
	commandspacer: true
},
	"ϵ": {
	math: "\\epsilon"
},
	"϶": {
	math: "\\backepsilon"
},
	"Ё": {
	text: "\\cyrchar\\CYRYO",
	commandspacer: true
},
	"Ђ": {
	text: "\\cyrchar\\CYRDJE",
	commandspacer: true
},
	"Ѓ": {
	text: "\\cyrchar{\\'\\CYRG}"
},
	"Є": {
	text: "\\cyrchar\\CYRIE",
	commandspacer: true
},
	"Ѕ": {
	text: "\\cyrchar\\CYRDZE",
	commandspacer: true
},
	"І": {
	text: "\\cyrchar\\CYRII",
	commandspacer: true
},
	"Ї": {
	text: "\\cyrchar\\CYRYI",
	commandspacer: true
},
	"Ј": {
	text: "\\cyrchar\\CYRJE",
	commandspacer: true
},
	"Љ": {
	text: "\\cyrchar\\CYRLJE",
	commandspacer: true
},
	"Њ": {
	text: "\\cyrchar\\CYRNJE",
	commandspacer: true
},
	"Ћ": {
	text: "\\cyrchar\\CYRTSHE",
	commandspacer: true
},
	"Ќ": {
	text: "\\cyrchar{\\'\\CYRK}"
},
	"Ў": {
	text: "\\cyrchar\\CYRUSHRT",
	commandspacer: true
},
	"Џ": {
	text: "\\cyrchar\\CYRDZHE",
	commandspacer: true
},
	"А": {
	text: "\\cyrchar\\CYRA",
	commandspacer: true
},
	"Б": {
	text: "\\cyrchar\\CYRB",
	commandspacer: true
},
	"В": {
	text: "\\cyrchar\\CYRV",
	commandspacer: true
},
	"Г": {
	text: "\\cyrchar\\CYRG",
	commandspacer: true
},
	"Д": {
	text: "\\cyrchar\\CYRD",
	commandspacer: true
},
	"Е": {
	text: "\\cyrchar\\CYRE",
	commandspacer: true
},
	"Ж": {
	text: "\\cyrchar\\CYRZH",
	commandspacer: true
},
	"З": {
	text: "\\cyrchar\\CYRZ",
	commandspacer: true
},
	"И": {
	text: "\\cyrchar\\CYRI",
	commandspacer: true
},
	"Й": {
	text: "\\cyrchar\\CYRISHRT",
	commandspacer: true
},
	"К": {
	text: "\\cyrchar\\CYRK",
	commandspacer: true
},
	"Л": {
	text: "\\cyrchar\\CYRL",
	commandspacer: true
},
	"М": {
	text: "\\cyrchar\\CYRM",
	commandspacer: true
},
	"Н": {
	text: "\\cyrchar\\CYRN",
	commandspacer: true
},
	"О": {
	text: "\\cyrchar\\CYRO",
	commandspacer: true
},
	"П": {
	text: "\\cyrchar\\CYRP",
	commandspacer: true
},
	"Р": {
	text: "\\cyrchar\\CYRR",
	commandspacer: true
},
	"С": {
	text: "\\cyrchar\\CYRS",
	commandspacer: true
},
	"Т": {
	text: "\\cyrchar\\CYRT",
	commandspacer: true
},
	"У": {
	text: "\\cyrchar\\CYRU",
	commandspacer: true
},
	"Ф": {
	text: "\\cyrchar\\CYRF",
	commandspacer: true
},
	"Х": {
	text: "\\cyrchar\\CYRH",
	commandspacer: true
},
	"Ц": {
	text: "\\cyrchar\\CYRC",
	commandspacer: true
},
	"Ч": {
	text: "\\cyrchar\\CYRCH",
	commandspacer: true
},
	"Ш": {
	text: "\\cyrchar\\CYRSH",
	commandspacer: true
},
	"Щ": {
	text: "\\cyrchar\\CYRSHCH",
	commandspacer: true
},
	"Ъ": {
	text: "\\cyrchar\\CYRHRDSN",
	commandspacer: true
},
	"Ы": {
	text: "\\cyrchar\\CYRERY",
	commandspacer: true
},
	"Ь": {
	text: "\\cyrchar\\CYRSFTSN",
	commandspacer: true
},
	"Э": {
	text: "\\cyrchar\\CYREREV",
	commandspacer: true
},
	"Ю": {
	text: "\\cyrchar\\CYRYU",
	commandspacer: true
},
	"Я": {
	text: "\\cyrchar\\CYRYA",
	commandspacer: true
},
	"а": {
	text: "\\cyrchar\\cyra",
	commandspacer: true
},
	"б": {
	text: "\\cyrchar\\cyrb",
	commandspacer: true
},
	"в": {
	text: "\\cyrchar\\cyrv",
	commandspacer: true
},
	"г": {
	text: "\\cyrchar\\cyrg",
	commandspacer: true
},
	"д": {
	text: "\\cyrchar\\cyrd",
	commandspacer: true
},
	"е": {
	text: "\\cyrchar\\cyre",
	commandspacer: true
},
	"ж": {
	text: "\\cyrchar\\cyrzh",
	commandspacer: true
},
	"з": {
	text: "\\cyrchar\\cyrz",
	commandspacer: true
},
	"и": {
	text: "\\cyrchar\\cyri",
	commandspacer: true
},
	"й": {
	text: "\\cyrchar\\cyrishrt",
	commandspacer: true
},
	"к": {
	text: "\\cyrchar\\cyrk",
	commandspacer: true
},
	"л": {
	text: "\\cyrchar\\cyrl",
	commandspacer: true
},
	"м": {
	text: "\\cyrchar\\cyrm",
	commandspacer: true
},
	"н": {
	text: "\\cyrchar\\cyrn",
	commandspacer: true
},
	"о": {
	text: "\\cyrchar\\cyro",
	commandspacer: true
},
	"п": {
	text: "\\cyrchar\\cyrp",
	commandspacer: true
},
	"р": {
	text: "\\cyrchar\\cyrr",
	commandspacer: true
},
	"с": {
	text: "\\cyrchar\\cyrs",
	commandspacer: true
},
	"т": {
	text: "\\cyrchar\\cyrt",
	commandspacer: true
},
	"у": {
	text: "\\cyrchar\\cyru",
	commandspacer: true
},
	"ф": {
	text: "\\cyrchar\\cyrf",
	commandspacer: true
},
	"х": {
	text: "\\cyrchar\\cyrh",
	commandspacer: true
},
	"ц": {
	text: "\\cyrchar\\cyrc",
	commandspacer: true
},
	"ч": {
	text: "\\cyrchar\\cyrch",
	commandspacer: true
},
	"ш": {
	text: "\\cyrchar\\cyrsh",
	commandspacer: true
},
	"щ": {
	text: "\\cyrchar\\cyrshch",
	commandspacer: true
},
	"ъ": {
	text: "\\cyrchar\\cyrhrdsn",
	commandspacer: true
},
	"ы": {
	text: "\\cyrchar\\cyrery",
	commandspacer: true
},
	"ь": {
	text: "\\cyrchar\\cyrsftsn",
	commandspacer: true
},
	"э": {
	text: "\\cyrchar\\cyrerev",
	commandspacer: true
},
	"ю": {
	text: "\\cyrchar\\cyryu",
	commandspacer: true
},
	"я": {
	text: "\\cyrchar\\cyrya",
	commandspacer: true
},
	"ё": {
	text: "\\cyrchar\\cyryo",
	commandspacer: true
},
	"ђ": {
	text: "\\cyrchar\\cyrdje",
	commandspacer: true
},
	"ѓ": {
	text: "\\cyrchar{\\'\\cyrg}"
},
	"є": {
	text: "\\cyrchar\\cyrie",
	commandspacer: true
},
	"ѕ": {
	text: "\\cyrchar\\cyrdze",
	commandspacer: true
},
	"і": {
	text: "\\cyrchar\\cyrii",
	commandspacer: true
},
	"ї": {
	text: "\\cyrchar\\cyryi",
	commandspacer: true
},
	"ј": {
	text: "\\cyrchar\\cyrje",
	commandspacer: true
},
	"љ": {
	text: "\\cyrchar\\cyrlje",
	commandspacer: true
},
	"њ": {
	text: "\\cyrchar\\cyrnje",
	commandspacer: true
},
	"ћ": {
	text: "\\cyrchar\\cyrtshe",
	commandspacer: true
},
	"ќ": {
	text: "\\cyrchar{\\'\\cyrk}"
},
	"ў": {
	text: "\\cyrchar\\cyrushrt",
	commandspacer: true
},
	"џ": {
	text: "\\cyrchar\\cyrdzhe",
	commandspacer: true
},
	"Ѡ": {
	text: "\\cyrchar\\CYROMEGA",
	commandspacer: true
},
	"ѡ": {
	text: "\\cyrchar\\cyromega",
	commandspacer: true
},
	"Ѣ": {
	text: "\\cyrchar\\CYRYAT",
	commandspacer: true
},
	"Ѥ": {
	text: "\\cyrchar\\CYRIOTE",
	commandspacer: true
},
	"ѥ": {
	text: "\\cyrchar\\cyriote",
	commandspacer: true
},
	"Ѧ": {
	text: "\\cyrchar\\CYRLYUS",
	commandspacer: true
},
	"ѧ": {
	text: "\\cyrchar\\cyrlyus",
	commandspacer: true
},
	"Ѩ": {
	text: "\\cyrchar\\CYRIOTLYUS",
	commandspacer: true
},
	"ѩ": {
	text: "\\cyrchar\\cyriotlyus",
	commandspacer: true
},
	"Ѫ": {
	text: "\\cyrchar\\CYRBYUS",
	commandspacer: true
},
	"Ѭ": {
	text: "\\cyrchar\\CYRIOTBYUS",
	commandspacer: true
},
	"ѭ": {
	text: "\\cyrchar\\cyriotbyus",
	commandspacer: true
},
	"Ѯ": {
	text: "\\cyrchar\\CYRKSI",
	commandspacer: true
},
	"ѯ": {
	text: "\\cyrchar\\cyrksi",
	commandspacer: true
},
	"Ѱ": {
	text: "\\cyrchar\\CYRPSI",
	commandspacer: true
},
	"ѱ": {
	text: "\\cyrchar\\cyrpsi",
	commandspacer: true
},
	"Ѳ": {
	text: "\\cyrchar\\CYRFITA",
	commandspacer: true
},
	"Ѵ": {
	text: "\\cyrchar\\CYRIZH",
	commandspacer: true
},
	"Ѹ": {
	text: "\\cyrchar\\CYRUK",
	commandspacer: true
},
	"ѹ": {
	text: "\\cyrchar\\cyruk",
	commandspacer: true
},
	"Ѻ": {
	text: "\\cyrchar\\CYROMEGARND",
	commandspacer: true
},
	"ѻ": {
	text: "\\cyrchar\\cyromegarnd",
	commandspacer: true
},
	"Ѽ": {
	text: "\\cyrchar\\CYROMEGATITLO",
	commandspacer: true
},
	"ѽ": {
	text: "\\cyrchar\\cyromegatitlo",
	commandspacer: true
},
	"Ѿ": {
	text: "\\cyrchar\\CYROT",
	commandspacer: true
},
	"ѿ": {
	text: "\\cyrchar\\cyrot",
	commandspacer: true
},
	"Ҁ": {
	text: "\\cyrchar\\CYRKOPPA",
	commandspacer: true
},
	"ҁ": {
	text: "\\cyrchar\\cyrkoppa",
	commandspacer: true
},
	"҂": {
	text: "\\cyrchar\\cyrthousands",
	commandspacer: true
},
	"҈": {
	text: "\\cyrchar\\cyrhundredthousands",
	commandspacer: true
},
	"҉": {
	text: "\\cyrchar\\cyrmillions",
	commandspacer: true
},
	"Ҍ": {
	text: "\\cyrchar\\CYRSEMISFTSN",
	commandspacer: true
},
	"ҍ": {
	text: "\\cyrchar\\cyrsemisftsn",
	commandspacer: true
},
	"Ҏ": {
	text: "\\cyrchar\\CYRRTICK",
	commandspacer: true
},
	"ҏ": {
	text: "\\cyrchar\\cyrrtick",
	commandspacer: true
},
	"Ґ": {
	text: "\\cyrchar\\CYRGUP",
	commandspacer: true
},
	"ґ": {
	text: "\\cyrchar\\cyrgup",
	commandspacer: true
},
	"Ғ": {
	text: "\\cyrchar\\CYRGHCRS",
	commandspacer: true
},
	"ғ": {
	text: "\\cyrchar\\cyrghcrs",
	commandspacer: true
},
	"Ҕ": {
	text: "\\cyrchar\\CYRGHK",
	commandspacer: true
},
	"ҕ": {
	text: "\\cyrchar\\cyrghk",
	commandspacer: true
},
	"Җ": {
	text: "\\cyrchar\\CYRZHDSC",
	commandspacer: true
},
	"җ": {
	text: "\\cyrchar\\cyrzhdsc",
	commandspacer: true
},
	"Ҙ": {
	text: "\\cyrchar\\CYRZDSC",
	commandspacer: true
},
	"ҙ": {
	text: "\\cyrchar\\cyrzdsc",
	commandspacer: true
},
	"Қ": {
	text: "\\cyrchar\\CYRKDSC",
	commandspacer: true
},
	"қ": {
	text: "\\cyrchar\\cyrkdsc",
	commandspacer: true
},
	"Ҝ": {
	text: "\\cyrchar\\CYRKVCRS",
	commandspacer: true
},
	"ҝ": {
	text: "\\cyrchar\\cyrkvcrs",
	commandspacer: true
},
	"Ҟ": {
	text: "\\cyrchar\\CYRKHCRS",
	commandspacer: true
},
	"ҟ": {
	text: "\\cyrchar\\cyrkhcrs",
	commandspacer: true
},
	"Ҡ": {
	text: "\\cyrchar\\CYRKBEAK",
	commandspacer: true
},
	"ҡ": {
	text: "\\cyrchar\\cyrkbeak",
	commandspacer: true
},
	"Ң": {
	text: "\\cyrchar\\CYRNDSC",
	commandspacer: true
},
	"ң": {
	text: "\\cyrchar\\cyrndsc",
	commandspacer: true
},
	"Ҥ": {
	text: "\\cyrchar\\CYRNG",
	commandspacer: true
},
	"ҥ": {
	text: "\\cyrchar\\cyrng",
	commandspacer: true
},
	"Ҧ": {
	text: "\\cyrchar\\CYRPHK",
	commandspacer: true
},
	"ҧ": {
	text: "\\cyrchar\\cyrphk",
	commandspacer: true
},
	"Ҩ": {
	text: "\\cyrchar\\CYRABHHA",
	commandspacer: true
},
	"ҩ": {
	text: "\\cyrchar\\cyrabhha",
	commandspacer: true
},
	"Ҫ": {
	text: "\\cyrchar\\CYRSDSC",
	commandspacer: true
},
	"ҫ": {
	text: "\\cyrchar\\cyrsdsc",
	commandspacer: true
},
	"Ҭ": {
	text: "\\cyrchar\\CYRTDSC",
	commandspacer: true
},
	"ҭ": {
	text: "\\cyrchar\\cyrtdsc",
	commandspacer: true
},
	"Ү": {
	text: "\\cyrchar\\CYRY",
	commandspacer: true
},
	"ү": {
	text: "\\cyrchar\\cyry",
	commandspacer: true
},
	"Ұ": {
	text: "\\cyrchar\\CYRYHCRS",
	commandspacer: true
},
	"ұ": {
	text: "\\cyrchar\\cyryhcrs",
	commandspacer: true
},
	"Ҳ": {
	text: "\\cyrchar\\CYRHDSC",
	commandspacer: true
},
	"ҳ": {
	text: "\\cyrchar\\cyrhdsc",
	commandspacer: true
},
	"Ҵ": {
	text: "\\cyrchar\\CYRTETSE",
	commandspacer: true
},
	"ҵ": {
	text: "\\cyrchar\\cyrtetse",
	commandspacer: true
},
	"Ҷ": {
	text: "\\cyrchar\\CYRCHRDSC",
	commandspacer: true
},
	"ҷ": {
	text: "\\cyrchar\\cyrchrdsc",
	commandspacer: true
},
	"Ҹ": {
	text: "\\cyrchar\\CYRCHVCRS",
	commandspacer: true
},
	"ҹ": {
	text: "\\cyrchar\\cyrchvcrs",
	commandspacer: true
},
	"Һ": {
	text: "\\cyrchar\\CYRSHHA",
	commandspacer: true
},
	"һ": {
	text: "\\cyrchar\\cyrshha",
	commandspacer: true
},
	"Ҽ": {
	text: "\\cyrchar\\CYRABHCH",
	commandspacer: true
},
	"ҽ": {
	text: "\\cyrchar\\cyrabhch",
	commandspacer: true
},
	"Ҿ": {
	text: "\\cyrchar\\CYRABHCHDSC",
	commandspacer: true
},
	"ҿ": {
	text: "\\cyrchar\\cyrabhchdsc",
	commandspacer: true
},
	"Ӏ": {
	text: "\\cyrchar\\CYRpalochka",
	commandspacer: true
},
	"Ӄ": {
	text: "\\cyrchar\\CYRKHK",
	commandspacer: true
},
	"ӄ": {
	text: "\\cyrchar\\cyrkhk",
	commandspacer: true
},
	"Ӈ": {
	text: "\\cyrchar\\CYRNHK",
	commandspacer: true
},
	"ӈ": {
	text: "\\cyrchar\\cyrnhk",
	commandspacer: true
},
	"Ӌ": {
	text: "\\cyrchar\\CYRCHLDSC",
	commandspacer: true
},
	"ӌ": {
	text: "\\cyrchar\\cyrchldsc",
	commandspacer: true
},
	"Ӕ": {
	text: "\\cyrchar\\CYRAE",
	commandspacer: true
},
	"ӕ": {
	text: "\\cyrchar\\cyrae",
	commandspacer: true
},
	"Ә": {
	text: "\\cyrchar\\CYRSCHWA",
	commandspacer: true
},
	"ә": {
	text: "\\cyrchar\\cyrschwa",
	commandspacer: true
},
	"Ӡ": {
	text: "\\cyrchar\\CYRABHDZE",
	commandspacer: true
},
	"ӡ": {
	text: "\\cyrchar\\cyrabhdze",
	commandspacer: true
},
	"Ө": {
	text: "\\cyrchar\\CYROTLD",
	commandspacer: true
},
	"ө": {
	text: "\\cyrchar\\cyrotld",
	commandspacer: true
},
	"ࡱ": {
	math: "\\\\backslash"
},
	"ᵃ": {
	math: "^{a}",
	text: "\\textsuperscript{a}"
},
	"ᵇ": {
	math: "^{b}",
	text: "\\textsuperscript{b}"
},
	"ᵈ": {
	math: "^{d}",
	text: "\\textsuperscript{d}"
},
	"ᵉ": {
	math: "^{e}",
	text: "\\textsuperscript{e}"
},
	"ᵍ": {
	math: "^{g}",
	text: "\\textsuperscript{g}"
},
	"ᵏ": {
	math: "^{k}",
	text: "\\textsuperscript{k}"
},
	"ᵐ": {
	math: "^{m}",
	text: "\\textsuperscript{m}"
},
	"ᵒ": {
	math: "^{o}",
	text: "\\textsuperscript{o}"
},
	"ᵖ": {
	math: "^{p}",
	text: "\\textsuperscript{p}"
},
	"ᵗ": {
	math: "^{t}",
	text: "\\textsuperscript{t}"
},
	"ᵘ": {
	math: "^{u}",
	text: "\\textsuperscript{u}"
},
	"ᵛ": {
	math: "^{v}",
	text: "\\textsuperscript{v}"
},
	"ᶜ": {
	math: "^{c}",
	text: "\\textsuperscript{c}"
},
	"ᶠ": {
	math: "^{f}",
	text: "\\textsuperscript{f}"
},
	"ᶻ": {
	math: "^{z}",
	text: "\\textsuperscript{z}"
},
	"Ḃ": {
	text: "\\.B"
},
	"ḃ": {
	text: "\\.b"
},
	"Ḅ": {
	text: "\\d{B}"
},
	"ḅ": {
	text: "\\d{b}"
},
	"Ḇ": {
	text: "\\b{B}"
},
	"ḇ": {
	text: "\\b{b}"
},
	"Ḋ": {
	text: "\\.D"
},
	"ḋ": {
	text: "\\.d"
},
	"Ḍ": {
	text: "\\d{D}"
},
	"ḍ": {
	text: "\\d{d}"
},
	"Ḏ": {
	text: "\\b{D}"
},
	"ḏ": {
	text: "\\b{d}"
},
	"Ḑ": {
	text: "\\c{D}"
},
	"ḑ": {
	text: "\\c{d}"
},
	"Ḝ": {
	text: "\\c{\\u{E}}"
},
	"ḝ": {
	text: "\\c{\\u{e}}"
},
	"Ḟ": {
	text: "\\.F"
},
	"ḟ": {
	text: "\\.f"
},
	"Ḡ": {
	text: "\\=G"
},
	"ḡ": {
	text: "\\=g"
},
	"Ḣ": {
	text: "\\.H"
},
	"ḣ": {
	text: "\\.h"
},
	"Ḥ": {
	text: "\\d{H}"
},
	"ḥ": {
	text: "\\d{h}"
},
	"Ḧ": {
	text: "\\\"H"
},
	"ḧ": {
	text: "\\\"h"
},
	"Ḩ": {
	text: "\\c{H}"
},
	"ḩ": {
	text: "\\c{h}"
},
	"Ḱ": {
	text: "\\'K"
},
	"ḱ": {
	text: "\\'k"
},
	"Ḳ": {
	text: "\\d{K}"
},
	"ḳ": {
	text: "\\d{k}"
},
	"Ḵ": {
	text: "\\b{K}"
},
	"ḵ": {
	text: "\\b{k}"
},
	"Ḷ": {
	text: "\\d{L}"
},
	"ḷ": {
	text: "\\d{l}"
},
	"Ḻ": {
	text: "\\b{L}"
},
	"ḻ": {
	text: "\\b{l}"
},
	"Ḿ": {
	text: "\\'M"
},
	"ḿ": {
	text: "\\'m"
},
	"Ṁ": {
	text: "\\.M"
},
	"ṁ": {
	text: "\\.m"
},
	"Ṃ": {
	text: "\\d{M}"
},
	"ṃ": {
	text: "\\d{m}"
},
	"Ṅ": {
	text: "\\.N"
},
	"ṅ": {
	text: "\\.n"
},
	"Ṇ": {
	text: "\\d{N}"
},
	"ṇ": {
	text: "\\d{n}"
},
	"Ṉ": {
	text: "\\b{N}"
},
	"ṉ": {
	text: "\\b{n}"
},
	"Ṕ": {
	text: "\\'P"
},
	"ṕ": {
	text: "\\'p"
},
	"Ṗ": {
	text: "\\.P"
},
	"ṗ": {
	text: "\\.p"
},
	"Ṙ": {
	text: "\\.R"
},
	"ṙ": {
	text: "\\.r"
},
	"Ṛ": {
	text: "\\d{R}"
},
	"ṛ": {
	text: "\\d{r}"
},
	"Ṟ": {
	text: "\\b{R}"
},
	"ṟ": {
	text: "\\b{r}"
},
	"Ṡ": {
	text: "\\.S"
},
	"ṡ": {
	text: "\\.s"
},
	"Ṣ": {
	text: "\\d{S}"
},
	"ṣ": {
	text: "\\d{s}"
},
	"Ṫ": {
	text: "\\.T"
},
	"ṫ": {
	text: "\\.t"
},
	"Ṭ": {
	text: "\\d{T}"
},
	"ṭ": {
	text: "\\d{t}"
},
	"Ṯ": {
	text: "\\b{T}"
},
	"ṯ": {
	text: "\\b{t}"
},
	"Ṽ": {
	text: "\\~V"
},
	"ṽ": {
	text: "\\~v"
},
	"Ṿ": {
	text: "\\d{V}"
},
	"ṿ": {
	text: "\\d{v}"
},
	"Ẁ": {
	text: "\\`W"
},
	"ẁ": {
	text: "\\`w"
},
	"Ẃ": {
	text: "\\'W"
},
	"ẃ": {
	text: "\\'w"
},
	"Ẅ": {
	text: "\\\"W"
},
	"ẅ": {
	text: "\\\"w"
},
	"Ẇ": {
	text: "\\.W"
},
	"ẇ": {
	text: "\\.w"
},
	"Ẉ": {
	text: "\\d{W}"
},
	"ẉ": {
	text: "\\d{w}"
},
	"Ẋ": {
	text: "\\.X"
},
	"ẋ": {
	text: "\\.x"
},
	"Ẍ": {
	text: "\\\"X"
},
	"ẍ": {
	text: "\\\"x"
},
	"Ẏ": {
	text: "\\.Y"
},
	"ẏ": {
	text: "\\.y"
},
	"Ẑ": {
	text: "\\^Z"
},
	"ẑ": {
	text: "\\^z"
},
	"Ẓ": {
	text: "\\d{Z}"
},
	"ẓ": {
	text: "\\d{z}"
},
	"Ẕ": {
	text: "\\b{Z}"
},
	"ẕ": {
	text: "\\b{z}"
},
	"ẖ": {
	text: "\\b{h}"
},
	"ẗ": {
	text: "\\\"t"
},
	"ẘ": {
	text: "\\r{w}"
},
	"ẙ": {
	text: "\\r{y}"
},
	"Ạ": {
	text: "\\d{A}"
},
	"ạ": {
	text: "\\d{a}"
},
	"Ẹ": {
	text: "\\d{E}"
},
	"ẹ": {
	text: "\\d{e}"
},
	"Ẽ": {
	text: "\\~E"
},
	"ẽ": {
	text: "\\~e"
},
	"Ị": {
	text: "\\d{I}"
},
	"ị": {
	text: "\\d{i}"
},
	"Ọ": {
	text: "\\d{O}"
},
	"ọ": {
	text: "\\d{o}"
},
	"Ụ": {
	text: "\\d{U}"
},
	"ụ": {
	text: "\\d{u}"
},
	"Ỳ": {
	text: "\\`Y"
},
	"ỳ": {
	text: "\\`y"
},
	"Ỵ": {
	text: "\\d{Y}"
},
	"ỵ": {
	text: "\\d{y}"
},
	"Ỹ": {
	text: "\\~Y"
},
	"ỹ": {
	text: "\\~y"
},
	" ": {
	text: " ",
	space: true
},
	" ": {
	math: "\\quad",
	space: true
},
	" ": {
	text: "\\hspace{0.6em}",
	space: true
},
	" ": {
	math: "\\quad",
	space: true,
	text: "\\hspace{1em}"
},
	" ": {
	text: "\\;",
	space: true
},
	" ": {
	text: "\\hspace{0.25em}",
	space: true
},
	" ": {
	text: "\\hspace{0.166em}",
	space: true
},
	" ": {
	text: "\\hphantom{0}",
	space: true
},
	" ": {
	text: "\\hphantom{,}",
	space: true
},
	" ": {
	text: "\\,",
	space: true
},
	" ": {
	math: "\\mkern1mu",
	space: true
},
	"​": {
	text: "\\mbox",
	commandspacer: true,
	space: true
},
	"‌": {
	text: "{\\aftergroup\\ignorespaces}"
},
	"‐": {
	text: "-"
},
	"‑": {
	text: "-"
},
	"‒": {
	text: "-"
},
	"–": {
	text: "\\textendash",
	commandspacer: true
},
	"—": {
	text: "\\textemdash",
	commandspacer: true
},
	"―": {
	math: "\\horizbar",
	text: "\\rule{1em}{1pt}"
},
	"‖": {
	math: "\\Vert"
},
	"‗": {
	math: "\\twolowline"
},
	"‘": {
	text: "`"
},
	"’": {
	text: "'"
},
	"‚": {
	text: ","
},
	"‛": {
	math: "\\Elzreapos"
},
	"“": {
	text: "``"
},
	"”": {
	text: "''"
},
	"„": {
	text: ",,"
},
	"‟": {
	text: "\\quotedblbase",
	commandspacer: true
},
	"†": {
	math: "\\dagger",
	text: "\\textdagger",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"‡": {
	math: "\\ddagger",
	text: "\\textdaggerdbl",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"•": {
	math: "\\bullet",
	text: "\\textbullet",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"‣": {
	text: ">"
},
	"․": {
	text: "."
},
	"‥": {
	math: "\\enleadertwodots",
	text: ".."
},
	"…": {
	math: "\\ldots",
	text: "\\ldots",
	commandspacer: true
},
	"‧": {
	text: "-"
},
	" ": {
	text: " ",
	space: true
},
	"‰": {
	text: "\\textperthousand",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"‱": {
	text: "\\textpertenthousand",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"′": {
	math: "{'}"
},
	"″": {
	math: "{''}"
},
	"‴": {
	math: "{'''}"
},
	"‵": {
	math: "\\backprime"
},
	"‶": {
	math: "\\backdprime"
},
	"‷": {
	math: "\\backtrprime"
},
	"‸": {
	math: "\\caretinsert"
},
	"‹": {
	text: "\\guilsinglleft",
	commandspacer: true
},
	"›": {
	text: "\\guilsinglright",
	commandspacer: true
},
	"‼": {
	math: "\\Exclam"
},
	"‾": {
	text: "-"
},
	"⁃": {
	math: "\\hyphenbullet"
},
	"⁄": {
	math: "\\fracslash"
},
	"⁇": {
	math: "\\Question"
},
	"⁈": {
	text: "?!"
},
	"⁉": {
	text: "!?"
},
	"⁊": {
	text: "7"
},
	"⁐": {
	math: "\\closure"
},
	"⁗": {
	math: "''''"
},
	" ": {
	math: "\\:",
	space: true,
	text: "\\:"
},
	"⁠": {
	text: "\\nolinebreak",
	commandspacer: true
},
	"⁰": {
	math: "^{0}"
},
	"ⁱ": {
	math: "^{i}",
	text: "\\textsuperscript{i}"
},
	"⁴": {
	math: "^{4}"
},
	"⁵": {
	math: "^{5}"
},
	"⁶": {
	math: "^{6}"
},
	"⁷": {
	math: "^{7}"
},
	"⁸": {
	math: "^{8}"
},
	"⁹": {
	math: "^{9}"
},
	"⁺": {
	math: "^{+}"
},
	"⁻": {
	math: "^{-}"
},
	"⁼": {
	math: "^{=}"
},
	"⁽": {
	math: "^{(}"
},
	"⁾": {
	math: "^{)}"
},
	"ⁿ": {
	math: "^{n}",
	text: "\\textsuperscript{n}"
},
	"₀": {
	math: "_{0}"
},
	"₁": {
	math: "_{1}"
},
	"₂": {
	math: "_{2}"
},
	"₃": {
	math: "_{3}"
},
	"₄": {
	math: "_{4}"
},
	"₅": {
	math: "_{5}"
},
	"₆": {
	math: "_{6}"
},
	"₇": {
	math: "_{7}"
},
	"₈": {
	math: "_{8}"
},
	"₉": {
	math: "_{9}"
},
	"₊": {
	math: "_{+}"
},
	"₋": {
	math: "_{-}"
},
	"₌": {
	math: "_{=}"
},
	"₍": {
	math: "_{(}"
},
	"₎": {
	math: "_{)}"
},
	"ₐ": {
	math: "_{a}",
	text: "\\textsubscript{a}"
},
	"ₑ": {
	math: "_{e}",
	text: "\\textsubscript{e}"
},
	"ₒ": {
	math: "_{o}",
	text: "\\textsubscript{o}"
},
	"ₓ": {
	math: "_{x}",
	text: "\\textsubscript{x}"
},
	"ₔ": {
	text: "\\textsubscript{\\textschwa}",
	textpackages: [
		"tipa"
	]
},
	"ₕ": {
	math: "_{h}",
	text: "\\textsubscript{h}"
},
	"ₖ": {
	math: "_{k}",
	text: "\\textsubscript{k}"
},
	"ₗ": {
	math: "_{l}",
	text: "\\textsubscript{l}"
},
	"ₘ": {
	math: "_{m}",
	text: "\\textsubscript{m}"
},
	"ₙ": {
	math: "_{n}",
	text: "\\textsubscript{n}"
},
	"ₚ": {
	math: "_{p}",
	text: "\\textsubscript{p}"
},
	"ₛ": {
	math: "_{s}",
	text: "\\textsubscript{s}"
},
	"ₜ": {
	math: "_{t}",
	text: "\\textsubscript{t}"
},
	"₧": {
	text: "\\ensuremath{\\Elzpes}"
},
	"€": {
	math: "\\euro",
	text: "\\texteuro",
	commandspacer: true
},
	"⃐": {
	math: "\\lvec"
},
	"⃑": {
	math: "\\rightharpoonup",
	mathpackages: [
		"amsmath",
		"amssymb"
	]
},
	"⃒": {
	math: "\\vertoverlay"
},
	"⃖": {
	math: "\\LVec"
},
	"⃗": {
	math: "\\vec"
},
	"⃛": {
	math: "\\dddot"
},
	"⃜": {
	math: "\\ddddot"
},
	"⃝": {
	math: "\\enclosecircle"
},
	"⃞": {
	math: "\\enclosesquare"
},
	"⃟": {
	math: "\\enclosediamond"
},
	"⃡": {
	math: "\\overleftrightarrow"
},
	"⃤": {
	math: "\\enclosetriangle"
},
	"⃧": {
	math: "\\annuity"
},
	"⃨": {
	math: "\\threeunderdot"
},
	"⃩": {
	math: "\\widebridgeabove"
},
	"⃬": {
	math: "\\underrightharpoondown"
},
	"⃭": {
	math: "\\underleftharpoondown"
},
	"⃮": {
	math: "\\underleftarrow"
},
	"⃯": {
	math: "\\underrightarrow"
},
	"⃰": {
	math: "\\asteraccent"
},
	"℀": {
	text: "a/c"
},
	"℁": {
	text: "a/s"
},
	"ℂ": {
	math: "\\mathbb{C}"
},
	"℃": {
	text: "\\textcelsius",
	commandspacer: true
},
	"℅": {
	text: "c/o"
},
	"℆": {
	text: "c/u"
},
	"ℇ": {
	math: "\\Euler"
},
	"℉": {
	text: "F"
},
	"ℊ": {
	math: "\\mathscr{g}"
},
	"ℋ": {
	math: "\\mathscr{H}"
},
	"ℌ": {
	math: "\\mathfrak{H}"
},
	"ℍ": {
	math: "\\mathbb{H}"
},
	"ℎ": {
	math: "\\Planckconst"
},
	"ℏ": {
	math: "\\hslash"
},
	"ℐ": {
	math: "\\mathscr{I}"
},
	"ℑ": {
	math: "\\mathfrak{I}"
},
	"ℒ": {
	math: "\\mathscr{L}"
},
	"ℓ": {
	math: "\\mathscr{l}"
},
	"ℕ": {
	math: "\\mathbb{N}"
},
	"№": {
	text: "\\cyrchar\\textnumero",
	commandspacer: true
},
	"℗": {
	text: "\\textcircledP",
	commandspacer: true
},
	"℘": {
	math: "\\wp"
},
	"ℙ": {
	math: "\\mathbb{P}"
},
	"ℚ": {
	math: "\\mathbb{Q}"
},
	"ℛ": {
	math: "\\mathscr{R}"
},
	"ℜ": {
	math: "\\mathfrak{R}"
},
	"ℝ": {
	math: "\\mathbb{R}"
},
	"℞": {
	math: "\\Elzxrat"
},
	"℠": {
	text: "\\textservicemark",
	commandspacer: true
},
	"℡": {
	text: "TEL"
},
	"™": {
	text: "\\texttrademark",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"ℤ": {
	math: "\\mathbb{Z}"
},
	"Ω": {
	math: "\\Omega"
},
	"℧": {
	math: "\\mho"
},
	"ℨ": {
	math: "\\mathfrak{Z}"
},
	"℩": {
	text: "\\textriota",
	commandspacer: true
},
	"K": {
	text: "K"
},
	"Å": {
	math: "\\Angstroem",
	text: "\\AA",
	commandspacer: true
},
	"ℬ": {
	math: "\\mathscr{B}"
},
	"ℭ": {
	math: "\\mathfrak{C}"
},
	"℮": {
	text: "\\textestimated",
	commandspacer: true
},
	"ℯ": {
	math: "\\mathscr{e}"
},
	"ℰ": {
	math: "\\mathscr{E}"
},
	"ℱ": {
	math: "\\mathscr{F}"
},
	"Ⅎ": {
	math: "\\Finv"
},
	"ℳ": {
	math: "\\mathscr{M}"
},
	"ℴ": {
	math: "\\mathscr{o}"
},
	"ℵ": {
	math: "\\aleph"
},
	"ℶ": {
	math: "\\beth"
},
	"ℷ": {
	math: "\\gimel"
},
	"ℸ": {
	math: "\\daleth"
},
	"ℼ": {
	math: "\\mathbb{\\pi}"
},
	"ℽ": {
	math: "\\mathbb{\\gamma}"
},
	"ℾ": {
	math: "\\mathbb{\\Gamma}"
},
	"ℿ": {
	math: "\\mathbb{\\Pi}"
},
	"⅀": {
	math: "\\mathbb{\\Sigma}"
},
	"⅁": {
	math: "\\Game"
},
	"⅂": {
	math: "\\sansLturned"
},
	"⅃": {
	math: "\\sansLmirrored"
},
	"⅄": {
	math: "\\Yup"
},
	"ⅅ": {
	math: "\\CapitalDifferentialD"
},
	"ⅆ": {
	math: "\\DifferentialD"
},
	"ⅇ": {
	math: "\\ExponetialE"
},
	"ⅈ": {
	math: "\\ComplexI"
},
	"ⅉ": {
	math: "\\ComplexJ"
},
	"⅊": {
	math: "\\PropertyLine"
},
	"⅋": {
	math: "\\invamp"
},
	"⅐": {
	math: "\\frac{1}{7}"
},
	"⅑": {
	math: "\\frac{1}{9}"
},
	"⅒": {
	math: "\\frac{1}{10}"
},
	"⅓": {
	math: "\\frac{1}{3}"
},
	"⅔": {
	math: "\\frac{2}{3}"
},
	"⅕": {
	math: "\\frac{1}{5}"
},
	"⅖": {
	math: "\\frac{2}{5}"
},
	"⅗": {
	math: "\\frac{3}{5}"
},
	"⅘": {
	math: "\\frac{4}{5}"
},
	"⅙": {
	math: "\\frac{1}{6}"
},
	"⅚": {
	math: "\\frac{5}{6}"
},
	"⅛": {
	math: "\\frac{1}{8}"
},
	"⅜": {
	math: "\\frac{3}{8}"
},
	"⅝": {
	math: "\\frac{5}{8}"
},
	"⅞": {
	math: "\\frac{7}{8}"
},
	"⅟": {
	math: "\\frac{1}"
},
	"Ⅰ": {
	text: "I"
},
	"Ⅱ": {
	text: "II"
},
	"Ⅲ": {
	text: "III"
},
	"Ⅳ": {
	text: "IV"
},
	"Ⅴ": {
	text: "V"
},
	"Ⅵ": {
	text: "VI"
},
	"Ⅶ": {
	text: "VII"
},
	"Ⅷ": {
	text: "VIII"
},
	"Ⅸ": {
	text: "IX"
},
	"Ⅹ": {
	text: "X"
},
	"Ⅺ": {
	text: "XI"
},
	"Ⅻ": {
	text: "XII"
},
	"Ⅼ": {
	text: "L"
},
	"Ⅽ": {
	text: "C"
},
	"Ⅾ": {
	text: "D"
},
	"Ⅿ": {
	text: "M"
},
	"ⅰ": {
	text: "i"
},
	"ⅱ": {
	text: "ii"
},
	"ⅲ": {
	text: "iii"
},
	"ⅳ": {
	text: "iv"
},
	"ⅴ": {
	text: "v"
},
	"ⅵ": {
	text: "vi"
},
	"ⅶ": {
	text: "vii"
},
	"ⅷ": {
	text: "viii"
},
	"ⅸ": {
	text: "ix"
},
	"ⅹ": {
	text: "x"
},
	"ⅺ": {
	text: "xi"
},
	"ⅻ": {
	text: "xii"
},
	"ⅼ": {
	text: "l"
},
	"ⅽ": {
	text: "c"
},
	"ⅾ": {
	text: "d"
},
	"ⅿ": {
	text: "m"
},
	"↉": {
	math: "\\frac{0}{3}"
},
	"←": {
	math: "\\leftarrow"
},
	"↑": {
	math: "\\uparrow"
},
	"→": {
	math: "\\rightarrow",
	text: "\\textrightarrow",
	commandspacer: true,
	textpackages: [
		"textcomp"
	]
},
	"↓": {
	math: "\\downarrow"
},
	"↔": {
	math: "\\leftrightarrow"
},
	"↕": {
	math: "\\updownarrow"
},
	"↖": {
	math: "\\nwarrow"
},
	"↗": {
	math: "\\nearrow"
},
	"↘": {
	math: "\\searrow"
},
	"↙": {
	math: "\\swarrow"
},
	"↚": {
	math: "\\nleftarrow"
},
	"↛": {
	math: "\\nrightarrow"
},
	"↜": {
	math: "\\arrowwaveleft"
},
	"↝": {
	math: "\\arrowwaveright"
},
	"↞": {
	math: "\\twoheadleftarrow"
},
	"↟": {
	math: "\\twoheaduparrow"
},
	"↠": {
	math: "\\twoheadrightarrow"
},
	"↡": {
	math: "\\twoheaddownarrow"
},
	"↢": {
	math: "\\leftarrowtail"
},
	"↣": {
	math: "\\rightarrowtail"
},
	"↤": {
	math: "\\mapsfrom"
},
	"↥": {
	math: "\\MapsUp"
},
	"↦": {
	math: "\\mapsto"
},
	"↧": {
	math: "\\MapsDown"
},
	"↨": {
	math: "\\updownarrowbar"
},
	"↩": {
	math: "\\hookleftarrow"
},
	"↪": {
	math: "\\hookrightarrow"
},
	"↫": {
	math: "\\looparrowleft"
},
	"↬": {
	math: "\\looparrowright"
},
	"↭": {
	math: "\\leftrightsquigarrow"
},
	"↮": {
	math: "\\nleftrightarrow"
},
	"↯": {
	math: "\\lightning"
},
	"↰": {
	math: "\\Lsh"
},
	"↱": {
	math: "\\Rsh"
},
	"↲": {
	math: "\\dlsh"
},
	"↳": {
	text: "\\reflectbox{\\carriagereturn}",
	textpackages: [
		"graphics",
		"unicode-math"
	]
},
	"↴": {
	math: "\\linefeed"
},
	"↵": {
	math: "\\carriagereturn"
},
	"↶": {
	math: "\\curvearrowleft"
},
	"↷": {
	math: "\\curvearrowright"
},
	"↸": {
	math: "\\barovernorthwestarrow"
},
	"↹": {
	math: "\\barleftarrowrightarrowba"
},
	"↺": {
	math: "\\circlearrowleft"
},
	"↻": {
	math: "\\circlearrowright"
},
	"↼": {
	math: "\\leftharpoonup"
},
	"↽": {
	math: "\\leftharpoondown"
},
	"↾": {
	math: "\\upharpoonright"
},
	"↿": {
	math: "\\upharpoonleft"
},
	"⇀": {
	math: "\\rightharpoonup",
	mathpackages: [
		"amsmath",
		"amssymb"
	]
},
	"⇁": {
	math: "\\rightharpoondown"
},
	"⇂": {
	math: "\\downharpoonright"
},
	"⇃": {
	math: "\\downharpoonleft"
},
	"⇄": {
	math: "\\rightleftarrows"
},
	"⇅": {
	math: "\\dblarrowupdown"
},
	"⇆": {
	math: "\\leftrightarrows"
},
	"⇇": {
	math: "\\leftleftarrows"
},
	"⇈": {
	math: "\\upuparrows"
},
	"⇉": {
	math: "\\rightrightarrows"
},
	"⇊": {
	math: "\\downdownarrows"
},
	"⇋": {
	math: "\\leftrightharpoons"
},
	"⇌": {
	math: "\\rightleftharpoons"
},
	"⇍": {
	math: "\\nLeftarrow"
},
	"⇎": {
	math: "\\nLeftrightarrow"
},
	"⇏": {
	math: "\\nRightarrow"
},
	"⇐": {
	math: "\\Leftarrow"
},
	"⇑": {
	math: "\\Uparrow"
},
	"⇒": {
	math: "\\Rightarrow"
},
	"⇓": {
	math: "\\Downarrow"
},
	"⇔": {
	math: "\\Leftrightarrow"
},
	"⇕": {
	math: "\\Updownarrow"
},
	"⇖": {
	math: "\\Nwarrow"
},
	"⇗": {
	math: "\\Nearrow"
},
	"⇘": {
	math: "\\Searrow"
},
	"⇙": {
	math: "\\Swarrow"
},
	"⇚": {
	math: "\\Lleftarrow"
},
	"⇛": {
	math: "\\Rrightarrow"
},
	"⇜": {
	math: "\\leftsquigarrow"
},
	"⇝": {
	math: "\\rightsquigarrow"
},
	"⇞": {
	math: "\\nHuparrow"
},
	"⇟": {
	math: "\\nHdownarrow"
},
	"⇠": {
	math: "\\dashleftarrow"
},
	"⇡": {
	math: "\\updasharrow"
},
	"⇢": {
	math: "\\dashrightarrow"
},
	"⇣": {
	math: "\\downdasharrow"
},
	"⇤": {
	math: "\\LeftArrowBar"
},
	"⇥": {
	math: "\\RightArrowBar"
},
	"⇦": {
	math: "\\leftwhitearrow"
},
	"⇧": {
	math: "\\upwhitearrow"
},
	"⇨": {
	math: "\\rightwhitearrow"
},
	"⇩": {
	math: "\\downwhitearrow"
},
	"⇪": {
	math: "\\whitearrowupfrombar"
},
	"⇴": {
	math: "\\circleonrightarrow"
},
	"⇵": {
	math: "\\DownArrowUpArrow"
},
	"⇶": {
	math: "\\rightthreearrows"
},
	"⇷": {
	math: "\\nvleftarrow"
},
	"⇸": {
	math: "\\pfun"
},
	"⇹": {
	math: "\\nvleftrightarrow"
},
	"⇺": {
	math: "\\nVleftarrow"
},
	"⇻": {
	math: "\\ffun"
},
	"⇼": {
	math: "\\nVleftrightarrow"
},
	"⇽": {
	math: "\\leftarrowtriangle"
},
	"⇾": {
	math: "\\rightarrowtriangle"
},
	"⇿": {
	math: "\\leftrightarrowtriangle"
},
	"∀": {
	math: "\\forall"
},
	"∁": {
	math: "\\complement"
},
	"∂": {
	math: "\\partial"
},
	"∃": {
	math: "\\exists"
},
	"∄": {
	math: "\\nexists"
},
	"∅": {
	math: "\\varnothing"
},
	"∆": {
	math: "\\increment"
},
	"∇": {
	math: "\\nabla"
},
	"∈": {
	math: "\\in"
},
	"∉": {
	math: "\\not\\in"
},
	"∊": {
	math: "\\smallin"
},
	"∋": {
	math: "\\ni"
},
	"∌": {
	math: "\\not\\ni"
},
	"∍": {
	math: "\\smallni"
},
	"∎": {
	math: "\\QED"
},
	"∏": {
	math: "\\prod"
},
	"∐": {
	math: "\\coprod"
},
	"∑": {
	math: "\\sum"
},
	"−": {
	math: "-",
	text: "-"
},
	"∓": {
	math: "\\mp"
},
	"∔": {
	math: "\\dotplus"
},
	"∕": {
	text: "/"
},
	"∖": {
	math: "\\setminus"
},
	"∗": {
	math: "{_\\ast}"
},
	"∘": {
	math: "\\circ"
},
	"∙": {
	math: "\\bullet"
},
	"√": {
	math: "\\surd"
},
	"∛": {
	math: "\\sqrt[3]"
},
	"∜": {
	math: "\\sqrt[4]"
},
	"∝": {
	math: "\\propto"
},
	"∞": {
	math: "\\infty"
},
	"∟": {
	math: "\\rightangle"
},
	"∠": {
	math: "\\angle"
},
	"∡": {
	math: "\\measuredangle"
},
	"∢": {
	math: "\\sphericalangle"
},
	"∣": {
	math: "\\mid"
},
	"∤": {
	math: "\\nmid"
},
	"∥": {
	math: "\\parallel"
},
	"∦": {
	math: "\\nparallel"
},
	"∧": {
	math: "\\wedge"
},
	"∨": {
	math: "\\vee"
},
	"∩": {
	math: "\\cap"
},
	"∪": {
	math: "\\cup"
},
	"∫": {
	math: "\\int"
},
	"∬": {
	math: "{\\int\\!\\int}"
},
	"∭": {
	math: "{\\int\\!\\int\\!\\int}"
},
	"∮": {
	math: "\\oint"
},
	"∯": {
	math: "\\surfintegral"
},
	"∰": {
	math: "\\volintegral"
},
	"∱": {
	math: "\\clwintegral"
},
	"∲": {
	math: "\\lcirclerightint",
	mathpackages: [
		"MnSymbol"
	]
},
	"∳": {
	math: "\\rcirclerightint",
	mathpackages: [
		"MnSymbol"
	]
},
	"∴": {
	math: "\\therefore"
},
	"∵": {
	math: "\\because"
},
	"∶": {
	math: ":"
},
	"∷": {
	math: "\\Colon"
},
	"∸": {
	math: "\\dotdiv",
	mathpackages: [
		"mathabx"
	]
},
	"∹": {
	math: "\\eqcolon"
},
	"∺": {
	math: "\\mathbin{{:}\\!\\!{-}\\!\\!{:}}"
},
	"∻": {
	math: "\\homothetic"
},
	"∼": {
	math: "\\sim"
},
	"∽": {
	math: "\\backsim"
},
	"∾": {
	math: "\\lazysinv"
},
	"∿": {
	math: "\\AC"
},
	"≀": {
	math: "\\wr"
},
	"≁": {
	math: "\\not\\sim"
},
	"≂": {
	math: "\\texteqsim",
	mathpackages: [
		"xecjk"
	]
},
	"≂̸": {
	math: "\\NotEqualTilde"
},
	"≃": {
	math: "\\simeq"
},
	"≄": {
	math: "\\not\\simeq"
},
	"≅": {
	math: "\\cong"
},
	"≆": {
	math: "\\approxnotequal"
},
	"≇": {
	math: "\\not\\cong"
},
	"≈": {
	math: "\\approx"
},
	"≉": {
	math: "\\not\\approx"
},
	"≊": {
	math: "\\approxeq"
},
	"≋": {
	math: "\\tildetrpl"
},
	"≋̸": {
	math: "\\not\\apid"
},
	"≌": {
	math: "\\allequal"
},
	"≍": {
	math: "\\asymp"
},
	"≎": {
	math: "\\Bumpeq"
},
	"≎̸": {
	math: "\\NotHumpDownHump"
},
	"≏": {
	math: "\\bumpeq"
},
	"≏̸": {
	math: "\\NotHumpEqual"
},
	"≐": {
	math: "\\doteq"
},
	"≐̸": {
	math: "\\not\\doteq"
},
	"≑": {
	math: "\\doteqdot"
},
	"≒": {
	math: "\\fallingdotseq"
},
	"≓": {
	math: "\\risingdotseq"
},
	"≔": {
	math: "\\coloneq",
	text: ":="
},
	"≕": {
	math: "=:"
},
	"≖": {
	math: "\\eqcirc"
},
	"≗": {
	math: "\\circeq"
},
	"≘": {
	math: "\\arceq"
},
	"≙": {
	math: "\\estimates"
},
	"≛": {
	math: "\\starequal"
},
	"≜": {
	math: "\\triangleq"
},
	"≝": {
	math: "\\eqdef"
},
	"≞": {
	math: "\\measeq"
},
	"≠": {
	math: "\\neq"
},
	"≡": {
	math: "\\equiv"
},
	"≢": {
	math: "\\not\\equiv"
},
	"≣": {
	math: "\\Equiv"
},
	"≤": {
	math: "\\leq"
},
	"≥": {
	math: "\\geq"
},
	"≦": {
	math: "\\leqq"
},
	"≧": {
	math: "\\geqq"
},
	"≨": {
	math: "\\lneqq"
},
	"≨︀": {
	math: "\\lvertneqq"
},
	"≩": {
	math: "\\gneqq"
},
	"≩︀": {
	math: "\\gvertneqq"
},
	"≪": {
	math: "\\ll"
},
	"≪̸": {
	math: "\\NotLessLess"
},
	"≫": {
	math: "\\gg"
},
	"≫̸": {
	math: "\\NotGreaterGreater"
},
	"≬": {
	math: "\\between"
},
	"≭": {
	math: "{\\not\\kern-0.3em\\times}"
},
	"≮": {
	math: "\\not<"
},
	"≯": {
	math: "\\not>"
},
	"≰": {
	math: "\\not\\leq"
},
	"≱": {
	math: "\\not\\geq"
},
	"≲": {
	math: "\\lessequivlnt"
},
	"≳": {
	math: "\\greaterequivlnt"
},
	"≶": {
	math: "\\lessgtr"
},
	"≷": {
	math: "\\gtrless"
},
	"≸": {
	math: "\\notlessgreater"
},
	"≹": {
	math: "\\notgreaterless"
},
	"≺": {
	math: "\\prec"
},
	"≻": {
	math: "\\succ"
},
	"≼": {
	math: "\\preccurlyeq"
},
	"≽": {
	math: "\\succcurlyeq"
},
	"≾": {
	math: "\\precapprox"
},
	"≾̸": {
	math: "\\NotPrecedesTilde"
},
	"≿": {
	math: "\\succapprox"
},
	"≿̸": {
	math: "\\NotSucceedsTilde"
},
	"⊀": {
	math: "\\not\\prec"
},
	"⊁": {
	math: "\\not\\succ"
},
	"⊂": {
	math: "\\subset"
},
	"⊃": {
	math: "\\supset"
},
	"⊄": {
	math: "\\not\\subset"
},
	"⊅": {
	math: "\\not\\supset"
},
	"⊆": {
	math: "\\subseteq"
},
	"⊇": {
	math: "\\supseteq"
},
	"⊈": {
	math: "\\not\\subseteq"
},
	"⊉": {
	math: "\\not\\supseteq"
},
	"⊊": {
	math: "\\subsetneq"
},
	"⊊︀": {
	math: "\\varsubsetneqq"
},
	"⊋": {
	math: "\\supsetneq"
},
	"⊋︀": {
	math: "\\varsupsetneq"
},
	"⊌": {
	math: "\\cupleftarrow"
},
	"⊍": {
	math: "\\cupdot"
},
	"⊎": {
	math: "\\uplus"
},
	"⊏": {
	math: "\\sqsubset"
},
	"⊏̸": {
	math: "\\NotSquareSubset"
},
	"⊐": {
	math: "\\sqsupset"
},
	"⊐̸": {
	math: "\\NotSquareSuperset"
},
	"⊑": {
	math: "\\sqsubseteq"
},
	"⊒": {
	math: "\\sqsupseteq"
},
	"⊓": {
	math: "\\sqcap"
},
	"⊔": {
	math: "\\sqcup"
},
	"⊕": {
	math: "\\oplus"
},
	"⊖": {
	math: "\\ominus"
},
	"⊗": {
	math: "\\otimes"
},
	"⊘": {
	math: "\\oslash"
},
	"⊙": {
	math: "\\odot"
},
	"⊚": {
	math: "\\circledcirc"
},
	"⊛": {
	math: "\\circledast"
},
	"⊜": {
	math: "\\circledequal"
},
	"⊝": {
	math: "\\circleddash"
},
	"⊞": {
	math: "\\boxplus"
},
	"⊟": {
	math: "\\boxminus"
},
	"⊠": {
	math: "\\boxtimes"
},
	"⊡": {
	math: "\\boxdot"
},
	"⊢": {
	math: "\\vdash"
},
	"⊣": {
	math: "\\dashv"
},
	"⊤": {
	math: "\\top"
},
	"⊥": {
	math: "\\perp"
},
	"⊦": {
	math: "\\assert"
},
	"⊧": {
	math: "\\truestate"
},
	"⊨": {
	math: "\\forcesextra"
},
	"⊩": {
	math: "\\Vdash"
},
	"⊪": {
	math: "\\Vvdash"
},
	"⊫": {
	math: "\\VDash"
},
	"⊬": {
	math: "\\nvdash"
},
	"⊭": {
	math: "\\nvDash"
},
	"⊮": {
	math: "\\nVdash"
},
	"⊯": {
	math: "\\nVDash"
},
	"⊰": {
	math: "\\prurel"
},
	"⊱": {
	math: "\\scurel"
},
	"⊲": {
	math: "\\vartriangleleft"
},
	"⊳": {
	math: "\\vartriangleright"
},
	"⊴": {
	math: "\\trianglelefteq"
},
	"⊵": {
	math: "\\trianglerighteq"
},
	"⊶": {
	math: "\\original"
},
	"⊷": {
	math: "\\image"
},
	"⊸": {
	math: "\\multimap"
},
	"⊹": {
	math: "\\hermitconjmatrix"
},
	"⊺": {
	math: "\\intercal"
},
	"⊻": {
	math: "\\veebar"
},
	"⊼": {
	math: "\\barwedge"
},
	"⊽": {
	math: "\\barvee"
},
	"⊾": {
	math: "\\rightanglearc"
},
	"⊿": {
	math: "\\varlrtriangle"
},
	"⋂": {
	math: "\\bigcap"
},
	"⋃": {
	math: "\\bigcup"
},
	"⋄": {
	math: "\\diamond"
},
	"⋅": {
	math: "\\cdot"
},
	"⋆": {
	math: "\\star"
},
	"⋇": {
	math: "\\divideontimes"
},
	"⋈": {
	math: "\\bowtie"
},
	"⋉": {
	math: "\\ltimes"
},
	"⋊": {
	math: "\\rtimes"
},
	"⋋": {
	math: "\\leftthreetimes"
},
	"⋌": {
	math: "\\rightthreetimes"
},
	"⋍": {
	math: "\\backsimeq"
},
	"⋎": {
	math: "\\curlyvee"
},
	"⋏": {
	math: "\\curlywedge"
},
	"⋐": {
	math: "\\Subset"
},
	"⋑": {
	math: "\\Supset"
},
	"⋒": {
	math: "\\Cap"
},
	"⋓": {
	math: "\\Cup"
},
	"⋔": {
	math: "\\pitchfork"
},
	"⋕": {
	math: "\\hash"
},
	"⋖": {
	math: "\\lessdot"
},
	"⋗": {
	math: "\\gtrdot"
},
	"⋘": {
	math: "\\verymuchless"
},
	"⋙": {
	math: "\\verymuchgreater"
},
	"⋚": {
	math: "\\lesseqgtr"
},
	"⋛": {
	math: "\\gtreqless"
},
	"⋜": {
	math: "\\eqless"
},
	"⋝": {
	math: "\\eqgtr"
},
	"⋞": {
	math: "\\curlyeqprec"
},
	"⋟": {
	math: "\\curlyeqsucc"
},
	"⋠": {
	math: "\\npreceq"
},
	"⋡": {
	math: "\\nsucceq"
},
	"⋢": {
	math: "\\not\\sqsubseteq"
},
	"⋣": {
	math: "\\not\\sqsupseteq"
},
	"⋤": {
	math: "\\sqsubsetneq"
},
	"⋥": {
	math: "\\Elzsqspne"
},
	"⋦": {
	math: "\\lnsim"
},
	"⋧": {
	math: "\\gnsim"
},
	"⋨": {
	math: "\\precedesnotsimilar"
},
	"⋩": {
	math: "\\succnsim"
},
	"⋪": {
	math: "\\ntriangleleft"
},
	"⋫": {
	math: "\\ntriangleright"
},
	"⋬": {
	math: "\\ntrianglelefteq"
},
	"⋭": {
	math: "\\ntrianglerighteq"
},
	"⋮": {
	math: "\\vdots"
},
	"⋯": {
	math: "\\cdots"
},
	"⋰": {
	math: "\\upslopeellipsis"
},
	"⋱": {
	math: "\\downslopeellipsis"
},
	"⋲": {
	math: "\\disin"
},
	"⋳": {
	math: "\\varisins"
},
	"⋴": {
	math: "\\isins"
},
	"⋵": {
	math: "\\isindot"
},
	"⋶": {
	math: "\\barin"
},
	"⋷": {
	math: "\\isinobar"
},
	"⋸": {
	math: "\\isinvb"
},
	"⋹": {
	math: "\\isinE"
},
	"⋺": {
	math: "\\nisd"
},
	"⋻": {
	math: "\\varnis"
},
	"⋼": {
	math: "\\nis"
},
	"⋽": {
	math: "\\varniobar"
},
	"⋾": {
	math: "\\niobar"
},
	"⋿": {
	math: "\\bagmember"
},
	"⌀": {
	math: "\\diameter"
},
	"⌂": {
	math: "\\house"
},
	"⌅": {
	math: "\\varbarwedge",
	text: "\\barwedge",
	commandspacer: true
},
	"⌆": {
	math: "\\perspcorrespond"
},
	"⌈": {
	math: "\\lceil"
},
	"⌉": {
	math: "\\rceil"
},
	"⌊": {
	math: "\\lfloor"
},
	"⌋": {
	math: "\\rfloor"
},
	"⌐": {
	math: "\\invneg"
},
	"⌑": {
	math: "\\wasylozenge"
},
	"⌒": {
	math: "\\profline"
},
	"⌓": {
	math: "\\profsurf"
},
	"⌕": {
	math: "\\recorder"
},
	"⌖": {
	math: "{\\mathchar\"2208}"
},
	"⌗": {
	math: "\\viewdata"
},
	"⌙": {
	math: "\\turnednot"
},
	"⌜": {
	math: "\\ulcorner"
},
	"⌝": {
	math: "\\urcorner"
},
	"⌞": {
	math: "\\llcorner"
},
	"⌟": {
	math: "\\lrcorner"
},
	"⌠": {
	math: "\\inttop"
},
	"⌡": {
	math: "\\intbottom"
},
	"⌢": {
	math: "\\frown"
},
	"⌣": {
	math: "\\smile"
},
	"〈": {
	math: "\\langle"
},
	"〉": {
	math: "\\rangle"
},
	"⌬": {
	math: "\\varhexagonlrbonds"
},
	"⌲": {
	math: "\\conictaper"
},
	"⌶": {
	math: "\\topbot"
},
	"⌹": {
	math: "\\APLinv"
},
	"⌿": {
	math: "\\notslash"
},
	"⍀": {
	math: "\\notbackslash"
},
	"⍇": {
	math: "\\APLleftarrowbox"
},
	"⍈": {
	math: "\\APLrightarrowbox"
},
	"⍉": {
	math: "\\invdiameter"
},
	"⍐": {
	math: "\\APLuparrowbox"
},
	"⍓": {
	math: "\\APLboxupcaret"
},
	"⍗": {
	math: "\\APLdownarrowbox"
},
	"⍝": {
	math: "\\APLcomment"
},
	"⍞": {
	math: "\\APLinput"
},
	"⍟": {
	math: "\\APLlog"
},
	"⍰": {
	math: "\\APLboxquestion"
},
	"⍼": {
	math: "\\rangledownzigzagarrow"
},
	"⎔": {
	math: "\\hexagon"
},
	"⎛": {
	math: "\\lparenuend"
},
	"⎜": {
	math: "\\lparenextender"
},
	"⎝": {
	math: "\\lparenlend"
},
	"⎞": {
	math: "\\rparenuend"
},
	"⎟": {
	math: "\\rparenextender"
},
	"⎠": {
	math: "\\rparenlend"
},
	"⎡": {
	math: "\\lbrackuend"
},
	"⎢": {
	math: "\\lbrackextender"
},
	"⎣": {
	math: "\\Elzdlcorn"
},
	"⎤": {
	math: "\\rbrackuend"
},
	"⎥": {
	math: "\\rbrackextender"
},
	"⎦": {
	math: "\\rbracklend"
},
	"⎧": {
	math: "\\lbraceuend"
},
	"⎨": {
	math: "\\lbracemid"
},
	"⎩": {
	math: "\\lbracelend"
},
	"⎪": {
	math: "\\vbraceextender"
},
	"⎫": {
	math: "\\rbraceuend"
},
	"⎬": {
	math: "\\rbracemid"
},
	"⎭": {
	math: "\\rbracelend"
},
	"⎮": {
	math: "\\intextender"
},
	"⎯": {
	math: "\\harrowextender"
},
	"⎰": {
	math: "\\lmoustache"
},
	"⎱": {
	math: "\\rmoustache"
},
	"⎲": {
	math: "\\sumtop"
},
	"⎳": {
	math: "\\sumbottom"
},
	"⎴": {
	math: "\\overbracket"
},
	"⎵": {
	math: "\\underbracket"
},
	"⎶": {
	math: "\\bbrktbrk"
},
	"⎷": {
	math: "\\sqrtbottom"
},
	"⎸": {
	math: "\\lvboxline"
},
	"⎹": {
	math: "\\rvboxline"
},
	"⏎": {
	math: "\\varcarriagereturn"
},
	"⏜": {
	math: "\\overparen"
},
	"⏝": {
	math: "\\underparen"
},
	"⏞": {
	math: "\\overbrace"
},
	"⏟": {
	math: "\\underbrace"
},
	"⏠": {
	math: "\\obrbrak"
},
	"⏡": {
	math: "\\ubrbrak"
},
	"⏢": {
	math: "\\trapezium"
},
	"⏣": {
	math: "\\benzenr"
},
	"⏤": {
	math: "\\strns"
},
	"⏥": {
	math: "\\fltns"
},
	"⏦": {
	math: "\\accurrent"
},
	"⏧": {
	math: "\\elinters"
},
	"␀": {
	text: "NUL"
},
	"␁": {
	text: "SOH"
},
	"␂": {
	text: "STX"
},
	"␃": {
	text: "ETX"
},
	"␄": {
	text: "EOT"
},
	"␅": {
	text: "ENQ"
},
	"␆": {
	text: "ACK"
},
	"␇": {
	text: "BEL"
},
	"␈": {
	text: "BS"
},
	"␉": {
	text: "HT"
},
	"␊": {
	text: "LF"
},
	"␋": {
	text: "VT"
},
	"␌": {
	text: "FF"
},
	"␍": {
	text: "CR"
},
	"␎": {
	text: "SO"
},
	"␏": {
	text: "SI"
},
	"␐": {
	text: "DLE"
},
	"␑": {
	text: "DC1"
},
	"␒": {
	text: "DC2"
},
	"␓": {
	text: "DC3"
},
	"␔": {
	text: "DC4"
},
	"␕": {
	text: "NAK"
},
	"␖": {
	text: "SYN"
},
	"␗": {
	text: "ETB"
},
	"␘": {
	text: "CAN"
},
	"␙": {
	text: "EM"
},
	"␚": {
	text: "SUB"
},
	"␛": {
	text: "ESC"
},
	"␜": {
	text: "FS"
},
	"␝": {
	text: "GS"
},
	"␞": {
	text: "RS"
},
	"␟": {
	text: "US"
},
	"␠": {
	text: "SP"
},
	"␡": {
	text: "DEL"
},
	"␣": {
	text: "\\textvisiblespace",
	commandspacer: true
},
	"␤": {
	text: "NL"
},
	"␥": {
	text: "///"
},
	"␦": {
	text: "?"
},
	"①": {
	text: "\\ding{172}"
},
	"②": {
	text: "\\ding{173}"
},
	"③": {
	text: "\\ding{174}"
},
	"④": {
	text: "\\ding{175}"
},
	"⑤": {
	text: "\\ding{176}"
},
	"⑥": {
	text: "\\ding{177}"
},
	"⑦": {
	text: "\\ding{178}"
},
	"⑧": {
	text: "\\ding{179}"
},
	"⑨": {
	text: "\\ding{180}"
},
	"⑩": {
	text: "\\ding{181}"
},
	"⑪": {
	text: "(11)"
},
	"⑫": {
	text: "(12)"
},
	"⑬": {
	text: "(13)"
},
	"⑭": {
	text: "(14)"
},
	"⑮": {
	text: "(15)"
},
	"⑯": {
	text: "(16)"
},
	"⑰": {
	text: "(17)"
},
	"⑱": {
	text: "(18)"
},
	"⑲": {
	text: "(19)"
},
	"⑳": {
	text: "(20)"
},
	"⑴": {
	text: "(1)"
},
	"⑵": {
	text: "(2)"
},
	"⑶": {
	text: "(3)"
},
	"⑷": {
	text: "(4)"
},
	"⑸": {
	text: "(5)"
},
	"⑹": {
	text: "(6)"
},
	"⑺": {
	text: "(7)"
},
	"⑻": {
	text: "(8)"
},
	"⑼": {
	text: "(9)"
},
	"⑽": {
	text: "(10)"
},
	"⑾": {
	text: "(11)"
},
	"⑿": {
	text: "(12)"
},
	"⒀": {
	text: "(13)"
},
	"⒁": {
	text: "(14)"
},
	"⒂": {
	text: "(15)"
},
	"⒃": {
	text: "(16)"
},
	"⒄": {
	text: "(17)"
},
	"⒅": {
	text: "(18)"
},
	"⒆": {
	text: "(19)"
},
	"⒇": {
	text: "(20)"
},
	"⒈": {
	text: "1."
},
	"⒉": {
	text: "2."
},
	"⒊": {
	text: "3."
},
	"⒋": {
	text: "4."
},
	"⒌": {
	text: "5."
},
	"⒍": {
	text: "6."
},
	"⒎": {
	text: "7."
},
	"⒏": {
	text: "8."
},
	"⒐": {
	text: "9."
},
	"⒑": {
	text: "10."
},
	"⒒": {
	text: "11."
},
	"⒓": {
	text: "12."
},
	"⒔": {
	text: "13."
},
	"⒕": {
	text: "14."
},
	"⒖": {
	text: "15."
},
	"⒗": {
	text: "16."
},
	"⒘": {
	text: "17."
},
	"⒙": {
	text: "18."
},
	"⒚": {
	text: "19."
},
	"⒛": {
	text: "20."
},
	"⒜": {
	text: "(a)"
},
	"⒝": {
	text: "(b)"
},
	"⒞": {
	text: "(c)"
},
	"⒟": {
	text: "(d)"
},
	"⒠": {
	text: "(e)"
},
	"⒡": {
	text: "(f)"
},
	"⒢": {
	text: "(g)"
},
	"⒣": {
	text: "(h)"
},
	"⒤": {
	text: "(i)"
},
	"⒥": {
	text: "(j)"
},
	"⒦": {
	text: "(k)"
},
	"⒧": {
	text: "(l)"
},
	"⒨": {
	text: "(m)"
},
	"⒩": {
	text: "(n)"
},
	"⒪": {
	text: "(o)"
},
	"⒫": {
	text: "(p)"
},
	"⒬": {
	text: "(q)"
},
	"⒭": {
	text: "(r)"
},
	"⒮": {
	text: "(s)"
},
	"⒯": {
	text: "(t)"
},
	"⒰": {
	text: "(u)"
},
	"⒱": {
	text: "(v)"
},
	"⒲": {
	text: "(w)"
},
	"⒳": {
	text: "(x)"
},
	"⒴": {
	text: "(y)"
},
	"⒵": {
	text: "(z)"
},
	"Ⓐ": {
	text: "(A)"
},
	"Ⓑ": {
	text: "(B)"
},
	"Ⓒ": {
	text: "(C)"
},
	"Ⓓ": {
	text: "(D)"
},
	"Ⓔ": {
	text: "(E)"
},
	"Ⓕ": {
	text: "(F)"
},
	"Ⓖ": {
	text: "(G)"
},
	"Ⓗ": {
	text: "(H)"
},
	"Ⓘ": {
	text: "(I)"
},
	"Ⓙ": {
	text: "(J)"
},
	"Ⓚ": {
	text: "(K)"
},
	"Ⓛ": {
	text: "(L)"
},
	"Ⓜ": {
	text: "(M)"
},
	"Ⓝ": {
	text: "(N)"
},
	"Ⓞ": {
	text: "(O)"
},
	"Ⓟ": {
	text: "(P)"
},
	"Ⓠ": {
	text: "(Q)"
},
	"Ⓡ": {
	text: "(R)"
},
	"Ⓢ": {
	math: "\\circledS"
},
	"Ⓣ": {
	text: "(T)"
},
	"Ⓤ": {
	text: "(U)"
},
	"Ⓥ": {
	text: "(V)"
},
	"Ⓦ": {
	text: "(W)"
},
	"Ⓧ": {
	text: "(X)"
},
	"Ⓨ": {
	text: "(Y)"
},
	"Ⓩ": {
	text: "(Z)"
},
	"ⓐ": {
	text: "(a)"
},
	"ⓑ": {
	text: "(b)"
},
	"ⓒ": {
	text: "(c)"
},
	"ⓓ": {
	text: "(d)"
},
	"ⓔ": {
	text: "(e)"
},
	"ⓕ": {
	text: "(f)"
},
	"ⓖ": {
	text: "(g)"
},
	"ⓗ": {
	text: "(h)"
},
	"ⓘ": {
	text: "(i)"
},
	"ⓙ": {
	text: "(j)"
},
	"ⓚ": {
	text: "(k)"
},
	"ⓛ": {
	text: "(l)"
},
	"ⓜ": {
	text: "(m)"
},
	"ⓝ": {
	text: "(n)"
},
	"ⓞ": {
	text: "(o)"
},
	"ⓟ": {
	text: "(p)"
},
	"ⓠ": {
	text: "(q)"
},
	"ⓡ": {
	text: "(r)"
},
	"ⓢ": {
	text: "(s)"
},
	"ⓣ": {
	text: "(t)"
},
	"ⓤ": {
	text: "(u)"
},
	"ⓥ": {
	text: "(v)"
},
	"ⓦ": {
	text: "(w)"
},
	"ⓧ": {
	text: "(x)"
},
	"ⓨ": {
	text: "(y)"
},
	"ⓩ": {
	text: "(z)"
},
	"⓪": {
	text: "(0)"
},
	"─": {
	text: "-"
},
	"━": {
	text: "="
},
	"│": {
	text: "|"
},
	"┃": {
	text: "|"
},
	"┄": {
	text: "-"
},
	"┅": {
	text: "="
},
	"┆": {
	math: "\\Elzdshfnc"
},
	"┇": {
	text: "|"
},
	"┈": {
	text: "-"
},
	"┉": {
	text: "="
},
	"┊": {
	text: "|"
},
	"┋": {
	text: "|"
},
	"┌": {
	text: "+"
},
	"┍": {
	text: "+"
},
	"┎": {
	text: "+"
},
	"┏": {
	text: "+"
},
	"┐": {
	text: "+"
},
	"┑": {
	text: "+"
},
	"┒": {
	text: "+"
},
	"┓": {
	text: "+"
},
	"└": {
	text: "+"
},
	"┕": {
	text: "+"
},
	"┖": {
	text: "+"
},
	"┗": {
	text: "+"
},
	"┘": {
	text: "+"
},
	"┙": {
	math: "\\Elzsqfnw"
},
	"┚": {
	text: "+"
},
	"┛": {
	text: "+"
},
	"├": {
	text: "+"
},
	"┝": {
	text: "+"
},
	"┞": {
	text: "+"
},
	"┟": {
	text: "+"
},
	"┠": {
	text: "+"
},
	"┡": {
	text: "+"
},
	"┢": {
	text: "+"
},
	"┣": {
	text: "+"
},
	"┤": {
	text: "+"
},
	"┥": {
	text: "+"
},
	"┦": {
	text: "+"
},
	"┧": {
	text: "+"
},
	"┨": {
	text: "+"
},
	"┩": {
	text: "+"
},
	"┪": {
	text: "+"
},
	"┫": {
	text: "+"
},
	"┬": {
	text: "+"
},
	"┭": {
	text: "+"
},
	"┮": {
	text: "+"
},
	"┯": {
	text: "+"
},
	"┰": {
	text: "+"
},
	"┱": {
	text: "+"
},
	"┲": {
	text: "+"
},
	"┳": {
	text: "+"
},
	"┴": {
	text: "+"
},
	"┵": {
	text: "+"
},
	"┶": {
	text: "+"
},
	"┷": {
	text: "+"
},
	"┸": {
	text: "+"
},
	"┹": {
	text: "+"
},
	"┺": {
	text: "+"
},
	"┻": {
	text: "+"
},
	"┼": {
	text: "+"
},
	"┽": {
	text: "+"
},
	"┾": {
	text: "+"
},
	"┿": {
	text: "+"
},
	"╀": {
	text: "+"
},
	"╁": {
	text: "+"
},
	"╂": {
	text: "+"
},
	"╃": {
	text: "+"
},
	"╄": {
	text: "+"
},
	"╅": {
	text: "+"
},
	"╆": {
	text: "+"
},
	"╇": {
	text: "+"
},
	"╈": {
	text: "+"
},
	"╉": {
	text: "+"
},
	"╊": {
	text: "+"
},
	"╋": {
	text: "+"
},
	"╌": {
	text: "-"
},
	"╍": {
	text: "="
},
	"╎": {
	text: "|"
},
	"╏": {
	text: "|"
},
	"═": {
	text: "="
},
	"║": {
	text: "|"
},
	"╒": {
	text: "+"
},
	"╓": {
	text: "+"
},
	"╔": {
	text: "+"
},
	"╕": {
	text: "+"
},
	"╖": {
	text: "+"
},
	"╗": {
	text: "+"
},
	"╘": {
	text: "+"
},
	"╙": {
	text: "+"
},
	"╚": {
	text: "+"
},
	"╛": {
	text: "+"
},
	"╜": {
	text: "+"
},
	"╝": {
	text: "+"
},
	"╞": {
	text: "+"
},
	"╟": {
	text: "+"
},
	"╠": {
	text: "+"
},
	"╡": {
	text: "+"
},
	"╢": {
	text: "+"
},
	"╣": {
	text: "+"
},
	"╤": {
	text: "+"
},
	"╥": {
	text: "+"
},
	"╦": {
	text: "+"
},
	"╧": {
	text: "+"
},
	"╨": {
	text: "+"
},
	"╩": {
	text: "+"
},
	"╪": {
	text: "+"
},
	"╫": {
	text: "+"
},
	"╬": {
	text: "+"
},
	"╭": {
	text: "+"
},
	"╮": {
	text: "+"
},
	"╯": {
	text: "+"
},
	"╰": {
	text: "+"
},
	"╱": {
	math: "\\diagup"
},
	"╲": {
	text: "\\"
},
	"╳": {
	text: "X"
},
	"╼": {
	text: "-"
},
	"╽": {
	text: "|"
},
	"╾": {
	text: "-"
},
	"╿": {
	text: "|"
},
	"▀": {
	math: "\\blockuphalf"
},
	"▄": {
	math: "\\blocklowhalf"
},
	"█": {
	math: "\\blockfull"
},
	"▌": {
	math: "\\blocklefthalf"
},
	"▐": {
	math: "\\blockrighthalf"
},
	"░": {
	math: "\\blockqtrshaded"
},
	"▒": {
	math: "\\blockhalfshaded"
},
	"▓": {
	math: "\\blockthreeqtrshaded"
},
	"■": {
	math: "\\mdlgblksquare",
	text: "\\ding{110}"
},
	"□": {
	math: "\\square"
},
	"▢": {
	math: "\\squoval"
},
	"▣": {
	math: "\\blackinwhitesquare"
},
	"▤": {
	math: "\\squarehfill"
},
	"▥": {
	math: "\\squarevfill"
},
	"▦": {
	math: "\\squarehvfill"
},
	"▧": {
	math: "\\squarenwsefill"
},
	"▨": {
	math: "\\squareneswfill"
},
	"▩": {
	math: "\\squarecrossfill"
},
	"▪": {
	math: "\\blacksquare"
},
	"▫": {
	math: "\\smwhtsquare"
},
	"▬": {
	math: "\\hrectangleblack"
},
	"▭": {
	math: "\\fbox{~~}"
},
	"▮": {
	math: "\\vrectangleblack"
},
	"▯": {
	math: "\\Elzvrecto"
},
	"▰": {
	math: "\\parallelogramblack"
},
	"▲": {
	math: "\\bigblacktriangleup",
	text: "\\ding{115}"
},
	"△": {
	math: "\\bigtriangleup"
},
	"▴": {
	math: "\\blacktriangle"
},
	"▵": {
	math: "\\vartriangle"
},
	"▶": {
	math: "\\RHD"
},
	"▷": {
	math: "\\rhd"
},
	"▸": {
	math: "\\blacktriangleright"
},
	"▹": {
	math: "\\triangleright"
},
	"►": {
	math: "\\blackpointerright"
},
	"▻": {
	math: "\\whitepointerright"
},
	"▼": {
	math: "\\bigblacktriangledown",
	text: "\\ding{116}"
},
	"▽": {
	math: "\\bigtriangledown"
},
	"▾": {
	math: "\\blacktriangledown"
},
	"▿": {
	math: "\\triangledown"
},
	"◀": {
	math: "\\LHD"
},
	"◁": {
	math: "\\lhd"
},
	"◂": {
	math: "\\blacktriangleleft"
},
	"◃": {
	math: "\\triangleleft"
},
	"◄": {
	math: "\\blackpointerleft"
},
	"◅": {
	math: "\\whitepointerleft"
},
	"◆": {
	math: "\\Diamondblack",
	text: "\\ding{117}"
},
	"◇": {
	math: "\\Diamond"
},
	"◈": {
	math: "\\blackinwhitediamond"
},
	"◉": {
	math: "\\fisheye"
},
	"◊": {
	math: "\\lozenge"
},
	"○": {
	math: "\\bigcirc"
},
	"◌": {
	math: "\\dottedcircle"
},
	"◍": {
	math: "\\circlevertfill"
},
	"◎": {
	math: "\\bullseye"
},
	"●": {
	math: "\\CIRCLE",
	text: "\\ding{108}"
},
	"◐": {
	math: "\\Elzcirfl"
},
	"◑": {
	math: "\\Elzcirfr"
},
	"◒": {
	math: "\\Elzcirfb"
},
	"◓": {
	math: "\\circletophalfblack"
},
	"◔": {
	math: "\\circleurquadblack"
},
	"◕": {
	math: "\\blackcircleulquadwhite"
},
	"◖": {
	math: "\\LEFTCIRCLE"
},
	"◗": {
	math: "\\RIGHTCIRCLE",
	text: "\\ding{119}"
},
	"◘": {
	math: "\\Elzrvbull"
},
	"◙": {
	math: "\\inversewhitecircle"
},
	"◚": {
	math: "\\invwhiteupperhalfcircle"
},
	"◛": {
	math: "\\invwhitelowerhalfcircle"
},
	"◜": {
	math: "\\ularc"
},
	"◝": {
	math: "\\urarc"
},
	"◞": {
	math: "\\lrarc"
},
	"◟": {
	math: "\\llarc"
},
	"◠": {
	math: "\\topsemicircle"
},
	"◡": {
	math: "\\botsemicircle"
},
	"◢": {
	math: "\\lrblacktriangle"
},
	"◣": {
	math: "\\llblacktriangle"
},
	"◤": {
	math: "\\ulblacktriangle"
},
	"◥": {
	math: "\\urblacktriangle"
},
	"◦": {
	math: "\\smwhtcircle"
},
	"◧": {
	math: "\\Elzsqfl"
},
	"◨": {
	math: "\\Elzsqfr"
},
	"◩": {
	math: "\\squareulblack"
},
	"◪": {
	math: "\\Elzsqfse"
},
	"◫": {
	math: "\\boxbar"
},
	"◬": {
	math: "\\trianglecdot"
},
	"◭": {
	math: "\\triangleleftblack"
},
	"◮": {
	math: "\\trianglerightblack"
},
	"◯": {
	math: "\\bigcirc"
},
	"◰": {
	math: "\\squareulquad"
},
	"◱": {
	math: "\\squarellquad"
},
	"◲": {
	math: "\\squarelrquad"
},
	"◳": {
	math: "\\squareurquad"
},
	"◴": {
	math: "\\circleulquad"
},
	"◵": {
	math: "\\circlellquad"
},
	"◶": {
	math: "\\circlelrquad"
},
	"◷": {
	math: "\\circleurquad"
},
	"◸": {
	math: "\\ultriangle"
},
	"◹": {
	math: "\\urtriangle"
},
	"◺": {
	math: "\\lltriangle"
},
	"◻": {
	math: "\\square"
},
	"◼": {
	math: "\\blacksquare"
},
	"◽": {
	math: "\\mdsmwhtsquare"
},
	"◾": {
	math: "\\mdsmblksquare"
},
	"◿": {
	math: "\\lrtriangle"
},
	"★": {
	math: "\\bigstar",
	text: "\\ding{72}"
},
	"☆": {
	math: "\\bigwhitestar",
	text: "\\ding{73}"
},
	"☉": {
	math: "\\Sun"
},
	"☎": {
	text: "\\ding{37}"
},
	"☐": {
	math: "\\Square"
},
	"☑": {
	math: "\\CheckedBox"
},
	"☒": {
	math: "\\XBox"
},
	"☓": {
	text: "X"
},
	"☕": {
	math: "\\steaming"
},
	"☛": {
	text: "\\ding{42}"
},
	"☞": {
	math: "\\pointright",
	text: "\\ding{43}"
},
	"☠": {
	math: "\\skull"
},
	"☡": {
	math: "\\danger"
},
	"☢": {
	math: "\\radiation"
},
	"☣": {
	math: "\\biohazard"
},
	"☯": {
	math: "\\yinyang"
},
	"☹": {
	math: "\\frownie"
},
	"☺": {
	math: "\\smiley"
},
	"☻": {
	math: "\\blacksmiley"
},
	"☼": {
	math: "\\sun"
},
	"☽": {
	text: "\\rightmoon",
	commandspacer: true,
	textpackages: [
		"wasysym"
	]
},
	"☾": {
	text: "\\leftmoon",
	commandspacer: true,
	textpackages: [
		"wasysym"
	]
},
	"☿": {
	math: "\\mercury",
	text: "\\mercury",
	commandspacer: true
},
	"♀": {
	math: "\\female",
	text: "\\venus",
	commandspacer: true
},
	"♁": {
	math: "\\earth"
},
	"♂": {
	math: "\\male",
	text: "\\male",
	commandspacer: true
},
	"♃": {
	math: "\\jupiter",
	text: "\\jupiter",
	commandspacer: true
},
	"♄": {
	math: "\\saturn",
	text: "\\saturn",
	commandspacer: true
},
	"♅": {
	math: "\\uranus",
	text: "\\uranus",
	commandspacer: true
},
	"♆": {
	math: "\\neptune",
	text: "\\neptune",
	commandspacer: true
},
	"♇": {
	math: "\\pluto",
	text: "\\pluto",
	commandspacer: true
},
	"♈": {
	math: "\\aries",
	text: "\\aries",
	commandspacer: true
},
	"♉": {
	math: "\\taurus",
	text: "\\taurus",
	commandspacer: true
},
	"♊": {
	math: "\\gemini",
	text: "\\gemini",
	commandspacer: true
},
	"♋": {
	math: "\\cancer",
	text: "\\cancer",
	commandspacer: true
},
	"♌": {
	math: "\\leo",
	text: "\\leo",
	commandspacer: true
},
	"♍": {
	math: "\\virgo",
	text: "\\virgo",
	commandspacer: true
},
	"♎": {
	math: "\\libra",
	text: "\\libra",
	commandspacer: true
},
	"♏": {
	math: "\\scorpio",
	text: "\\scorpio",
	commandspacer: true
},
	"♐": {
	math: "\\sagittarius",
	text: "\\sagittarius",
	commandspacer: true
},
	"♑": {
	math: "\\capricornus",
	text: "\\capricornus",
	commandspacer: true
},
	"♒": {
	math: "\\aquarius",
	text: "\\aquarius",
	commandspacer: true
},
	"♓": {
	math: "\\pisces",
	text: "\\pisces",
	commandspacer: true
},
	"♠": {
	math: "\\spadesuit",
	text: "\\ding{171}"
},
	"♡": {
	math: "\\heartsuit"
},
	"♢": {
	math: "\\diamond"
},
	"♣": {
	math: "\\clubsuit",
	text: "\\ding{168}"
},
	"♤": {
	math: "\\varspadesuit"
},
	"♥": {
	math: "\\varheartsuit",
	text: "\\ding{170}"
},
	"♦": {
	math: "\\vardiamondsuit",
	text: "\\ding{169}"
},
	"♧": {
	math: "\\varclubsuit"
},
	"♩": {
	math: "\\quarternote",
	text: "\\quarternote",
	commandspacer: true
},
	"♪": {
	math: "\\eighthnote",
	text: "\\eighthnote",
	commandspacer: true
},
	"♫": {
	math: "\\twonotes"
},
	"♬": {
	math: "\\sixteenthnote"
},
	"♭": {
	math: "\\flat"
},
	"♮": {
	math: "\\natural"
},
	"♯": {
	math: "\\sharp"
},
	"♻": {
	math: "\\recycle"
},
	"♾": {
	math: "\\acidfree"
},
	"⚀": {
	math: "\\dicei"
},
	"⚁": {
	math: "\\diceii"
},
	"⚂": {
	math: "\\diceiii"
},
	"⚃": {
	math: "\\diceiv"
},
	"⚄": {
	math: "\\dicev"
},
	"⚅": {
	math: "\\dicevi"
},
	"⚆": {
	math: "\\circledrightdot"
},
	"⚇": {
	math: "\\circledtwodots"
},
	"⚈": {
	math: "\\blackcircledrightdot"
},
	"⚉": {
	math: "\\blackcircledtwodots"
},
	"⚓": {
	math: "\\anchor"
},
	"⚔": {
	math: "\\swords"
},
	"⚠": {
	math: "\\warning"
},
	"⚥": {
	math: "\\Hermaphrodite"
},
	"⚪": {
	math: "\\medcirc"
},
	"⚫": {
	math: "\\medbullet"
},
	"⚬": {
	math: "\\mdsmwhtcircle"
},
	"⚲": {
	math: "\\neuter"
},
	"✁": {
	text: "\\ding{33}"
},
	"✂": {
	text: "\\ding{34}"
},
	"✃": {
	text: "\\ding{35}"
},
	"✄": {
	text: "\\ding{36}"
},
	"✆": {
	text: "\\ding{38}"
},
	"✇": {
	text: "\\ding{39}"
},
	"✈": {
	text: "\\ding{40}"
},
	"✉": {
	text: "\\ding{41}"
},
	"✌": {
	text: "\\ding{44}"
},
	"✍": {
	text: "\\ding{45}"
},
	"✎": {
	math: "\\pencil",
	text: "\\ding{46}"
},
	"✏": {
	text: "\\ding{47}"
},
	"✐": {
	text: "\\ding{48}"
},
	"✑": {
	text: "\\ding{49}"
},
	"✒": {
	text: "\\ding{50}"
},
	"✓": {
	math: "\\checkmark",
	text: "\\ding{51}"
},
	"✔": {
	text: "\\ding{52}"
},
	"✕": {
	text: "\\ding{53}"
},
	"✖": {
	text: "\\ding{54}"
},
	"✗": {
	math: "\\ballotx",
	text: "\\ding{55}"
},
	"✘": {
	text: "\\ding{56}"
},
	"✙": {
	text: "\\ding{57}"
},
	"✚": {
	text: "\\ding{58}"
},
	"✛": {
	text: "\\ding{59}"
},
	"✜": {
	text: "\\ding{60}"
},
	"✝": {
	text: "\\ding{61}"
},
	"✞": {
	text: "\\ding{62}"
},
	"✟": {
	text: "\\ding{63}"
},
	"✠": {
	math: "\\maltese",
	text: "\\ding{64}"
},
	"✡": {
	text: "\\ding{65}"
},
	"✢": {
	text: "\\ding{66}"
},
	"✣": {
	text: "\\ding{67}"
},
	"✤": {
	text: "\\ding{68}"
},
	"✥": {
	text: "\\ding{69}"
},
	"✦": {
	text: "\\ding{70}"
},
	"✧": {
	text: "\\ding{71}"
},
	"✩": {
	text: "\\ding{73}"
},
	"✪": {
	math: "\\circledstar",
	text: "\\ding{74}"
},
	"✫": {
	text: "\\ding{75}"
},
	"✬": {
	text: "\\ding{76}"
},
	"✭": {
	text: "\\ding{77}"
},
	"✮": {
	text: "\\ding{78}"
},
	"✯": {
	text: "\\ding{79}"
},
	"✰": {
	text: "\\ding{80}"
},
	"✱": {
	text: "\\ding{81}"
},
	"✲": {
	text: "\\ding{82}"
},
	"✳": {
	text: "\\ding{83}"
},
	"✴": {
	text: "\\ding{84}"
},
	"✵": {
	text: "\\ding{85}"
},
	"✶": {
	math: "\\varstar",
	text: "\\ding{86}"
},
	"✷": {
	text: "\\ding{87}"
},
	"✸": {
	text: "\\ding{88}"
},
	"✹": {
	text: "\\ding{89}"
},
	"✺": {
	text: "\\ding{90}"
},
	"✻": {
	text: "\\ding{91}"
},
	"✼": {
	text: "\\ding{92}"
},
	"✽": {
	math: "\\dingasterisk",
	text: "\\ding{93}"
},
	"✾": {
	text: "\\ding{94}"
},
	"✿": {
	text: "\\ding{95}"
},
	"❀": {
	text: "\\ding{96}"
},
	"❁": {
	text: "\\ding{97}"
},
	"❂": {
	text: "\\ding{98}"
},
	"❃": {
	text: "\\ding{99}"
},
	"❄": {
	text: "\\ding{100}"
},
	"❅": {
	text: "\\ding{101}"
},
	"❆": {
	text: "\\ding{102}"
},
	"❇": {
	text: "\\ding{103}"
},
	"❈": {
	text: "\\ding{104}"
},
	"❉": {
	text: "\\ding{105}"
},
	"❊": {
	text: "\\ding{106}"
},
	"❋": {
	text: "\\ding{107}"
},
	"❍": {
	text: "\\ding{109}"
},
	"❏": {
	text: "\\ding{111}"
},
	"❐": {
	text: "\\ding{112}"
},
	"❑": {
	text: "\\ding{113}"
},
	"❒": {
	text: "\\ding{114}"
},
	"❖": {
	text: "\\ding{118}"
},
	"❘": {
	text: "\\ding{120}"
},
	"❙": {
	text: "\\ding{121}"
},
	"❚": {
	text: "\\ding{122}"
},
	"❛": {
	text: "\\ding{123}"
},
	"❜": {
	text: "\\ding{124}"
},
	"❝": {
	text: "\\ding{125}"
},
	"❞": {
	text: "\\ding{126}"
},
	"❡": {
	text: "\\ding{161}"
},
	"❢": {
	text: "\\ding{162}"
},
	"❣": {
	text: "\\ding{163}"
},
	"❤": {
	text: "\\ding{164}"
},
	"❥": {
	text: "\\ding{165}"
},
	"❦": {
	text: "\\ding{166}"
},
	"❧": {
	text: "\\ding{167}"
},
	"❲": {
	math: "\\lbrbrak"
},
	"❳": {
	math: "\\rbrbrak"
},
	"❶": {
	text: "\\ding{182}"
},
	"❷": {
	text: "\\ding{183}"
},
	"❸": {
	text: "\\ding{184}"
},
	"❹": {
	text: "\\ding{185}"
},
	"❺": {
	text: "\\ding{186}"
},
	"❻": {
	text: "\\ding{187}"
},
	"❼": {
	text: "\\ding{188}"
},
	"❽": {
	text: "\\ding{189}"
},
	"❾": {
	text: "\\ding{190}"
},
	"❿": {
	text: "\\ding{191}"
},
	"➀": {
	text: "\\ding{192}"
},
	"➁": {
	text: "\\ding{193}"
},
	"➂": {
	text: "\\ding{194}"
},
	"➃": {
	text: "\\ding{195}"
},
	"➄": {
	text: "\\ding{196}"
},
	"➅": {
	text: "\\ding{197}"
},
	"➆": {
	text: "\\ding{198}"
},
	"➇": {
	text: "\\ding{199}"
},
	"➈": {
	text: "\\ding{200}"
},
	"➉": {
	text: "\\ding{201}"
},
	"➊": {
	text: "\\ding{202}"
},
	"➋": {
	text: "\\ding{203}"
},
	"➌": {
	text: "\\ding{204}"
},
	"➍": {
	text: "\\ding{205}"
},
	"➎": {
	text: "\\ding{206}"
},
	"➏": {
	text: "\\ding{207}"
},
	"➐": {
	text: "\\ding{208}"
},
	"➑": {
	text: "\\ding{209}"
},
	"➒": {
	text: "\\ding{210}"
},
	"➓": {
	text: "\\ding{211}"
},
	"➔": {
	text: "\\ding{212}"
},
	"➘": {
	text: "\\ding{216}"
},
	"➙": {
	text: "\\ding{217}"
},
	"➚": {
	text: "\\ding{218}"
},
	"➛": {
	math: "\\draftingarrow",
	text: "\\ding{219}"
},
	"➜": {
	text: "\\ding{220}"
},
	"➝": {
	text: "\\ding{221}"
},
	"➞": {
	text: "\\ding{222}"
},
	"➟": {
	text: "\\ding{223}"
},
	"➠": {
	text: "\\ding{224}"
},
	"➡": {
	text: "\\ding{225}"
},
	"➢": {
	math: "\\arrowbullet",
	text: "\\ding{226}"
},
	"➣": {
	text: "\\ding{227}"
},
	"➤": {
	text: "\\ding{228}"
},
	"➥": {
	text: "\\ding{229}"
},
	"➦": {
	text: "\\ding{230}"
},
	"➧": {
	text: "\\ding{231}"
},
	"➨": {
	text: "\\ding{232}"
},
	"➩": {
	text: "\\ding{233}"
},
	"➪": {
	text: "\\ding{234}"
},
	"➫": {
	text: "\\ding{235}"
},
	"➬": {
	text: "\\ding{236}"
},
	"➭": {
	text: "\\ding{237}"
},
	"➮": {
	text: "\\ding{238}"
},
	"➯": {
	text: "\\ding{239}"
},
	"➱": {
	text: "\\ding{241}"
},
	"➲": {
	text: "\\ding{242}"
},
	"➳": {
	text: "\\ding{243}"
},
	"➴": {
	text: "\\ding{244}"
},
	"➵": {
	text: "\\ding{245}"
},
	"➶": {
	text: "\\ding{246}"
},
	"➷": {
	text: "\\ding{247}"
},
	"➸": {
	text: "\\ding{248}"
},
	"➹": {
	text: "\\ding{249}"
},
	"➺": {
	text: "\\ding{250}"
},
	"➻": {
	text: "\\ding{251}"
},
	"➼": {
	text: "\\ding{252}"
},
	"➽": {
	text: "\\ding{253}"
},
	"➾": {
	text: "\\ding{254}"
},
	"⟀": {
	math: "\\threedangle"
},
	"⟁": {
	math: "\\whiteinwhitetriangle"
},
	"⟂": {
	math: "\\perp"
},
	"⟃": {
	math: "\\subsetcirc"
},
	"⟄": {
	math: "\\supsetcirc"
},
	"⟅": {
	math: "\\Lbag"
},
	"⟆": {
	math: "\\Rbag"
},
	"⟇": {
	math: "\\veedot"
},
	"⟈": {
	math: "\\bsolhsub"
},
	"⟉": {
	math: "\\suphsol"
},
	"⟌": {
	math: "\\longdivision"
},
	"⟐": {
	math: "\\Diamonddot"
},
	"⟑": {
	math: "\\wedgedot"
},
	"⟒": {
	math: "\\upin"
},
	"⟓": {
	math: "\\pullback"
},
	"⟔": {
	math: "\\pushout"
},
	"⟕": {
	math: "\\leftouterjoin"
},
	"⟖": {
	math: "\\rightouterjoin"
},
	"⟗": {
	math: "\\fullouterjoin"
},
	"⟘": {
	math: "\\bigbot"
},
	"⟙": {
	math: "\\bigtop"
},
	"⟚": {
	math: "\\DashVDash"
},
	"⟛": {
	math: "\\dashVdash"
},
	"⟜": {
	math: "\\multimapinv"
},
	"⟝": {
	math: "\\vlongdash"
},
	"⟞": {
	math: "\\longdashv"
},
	"⟟": {
	math: "\\cirbot"
},
	"⟠": {
	math: "\\lozengeminus"
},
	"⟡": {
	math: "\\concavediamond"
},
	"⟢": {
	math: "\\concavediamondtickleft"
},
	"⟣": {
	math: "\\concavediamondtickright"
},
	"⟤": {
	math: "\\whitesquaretickleft"
},
	"⟥": {
	math: "\\whitesquaretickright"
},
	"⟦": {
	math: "\\llbracket"
},
	"⟧": {
	math: "\\rrbracket"
},
	"⟨": {
	math: "\\langle"
},
	"⟩": {
	math: "\\rangle"
},
	"⟪": {
	math: "\\lang"
},
	"⟫": {
	math: "\\rang"
},
	"⟬": {
	math: "\\Lbrbrak"
},
	"⟭": {
	math: "\\Rbrbrak"
},
	"⟮": {
	math: "\\lgroup"
},
	"⟯": {
	math: "\\rgroup"
},
	"⟰": {
	math: "\\UUparrow"
},
	"⟱": {
	math: "\\DDownarrow"
},
	"⟲": {
	math: "\\acwgapcirclearrow"
},
	"⟳": {
	math: "\\cwgapcirclearrow"
},
	"⟴": {
	math: "\\rightarrowonoplus"
},
	"⟵": {
	math: "\\longleftarrow"
},
	"⟶": {
	math: "\\longrightarrow"
},
	"⟷": {
	math: "\\longleftrightarrow"
},
	"⟸": {
	math: "\\Longleftarrow"
},
	"⟹": {
	math: "\\Longrightarrow"
},
	"⟺": {
	math: "\\Longleftrightarrow"
},
	"⟻": {
	math: "\\longmapsfrom"
},
	"⟼": {
	math: "\\longmapsto"
},
	"⟽": {
	math: "\\Longmapsfrom"
},
	"⟾": {
	math: "\\Longmapsto"
},
	"⟿": {
	math: "\\sim\\joinrel\\leadsto"
},
	"⤀": {
	math: "\\psur"
},
	"⤁": {
	math: "\\nVtwoheadrightarrow"
},
	"⤂": {
	math: "\\nvLeftarrow"
},
	"⤃": {
	math: "\\nvRightarrow"
},
	"⤄": {
	math: "\\nvLeftrightarrow"
},
	"⤆": {
	math: "\\Mapsfrom"
},
	"⤇": {
	math: "\\Mapsto"
},
	"⤈": {
	math: "\\downarrowbarred"
},
	"⤉": {
	math: "\\uparrowbarred"
},
	"⤊": {
	math: "\\Uuparrow"
},
	"⤋": {
	math: "\\Ddownarrow"
},
	"⤌": {
	math: "\\leftbkarrow"
},
	"⤍": {
	math: "\\rightbkarrow"
},
	"⤎": {
	math: "\\leftdbkarrow"
},
	"⤏": {
	math: "\\dbkarow"
},
	"⤐": {
	math: "\\drbkarow"
},
	"⤑": {
	math: "\\rightdotarrow"
},
	"⤒": {
	math: "\\UpArrowBar"
},
	"⤓": {
	math: "\\DownArrowBar"
},
	"⤔": {
	math: "\\pinj"
},
	"⤕": {
	math: "\\finj"
},
	"⤖": {
	math: "\\bij"
},
	"⤗": {
	math: "\\nvtwoheadrightarrowtail"
},
	"⤘": {
	math: "\\nVtwoheadrightarrowtail"
},
	"⤙": {
	math: "\\lefttail"
},
	"⤚": {
	math: "\\righttail"
},
	"⤛": {
	math: "\\leftdbltail"
},
	"⤜": {
	math: "\\rightdbltail"
},
	"⤝": {
	math: "\\diamondleftarrow"
},
	"⤞": {
	math: "\\rightarrowdiamond"
},
	"⤟": {
	math: "\\diamondleftarrowbar"
},
	"⤠": {
	math: "\\barrightarrowdiamond"
},
	"⤡": {
	math: "\\nwsearrow"
},
	"⤢": {
	math: "\\neswarrow"
},
	"⤫": {
	math: "\\rdiagovfdiag"
},
	"⤬": {
	math: "\\fdiagovrdiag"
},
	"⤭": {
	math: "\\seovnearrow"
},
	"⤮": {
	math: "\\neovsearrow"
},
	"⤯": {
	math: "\\fdiagovnearrow"
},
	"⤰": {
	math: "\\rdiagovsearrow"
},
	"⤱": {
	math: "\\neovnwarrow"
},
	"⤲": {
	math: "\\nwovnearrow"
},
	"⤴": {
	math: "\\uprightcurvearrow"
},
	"⤵": {
	math: "\\downrightcurvedarrow"
},
	"⤸": {
	math: "\\cwrightarcarrow"
},
	"⤹": {
	math: "\\acwleftarcarrow"
},
	"⤺": {
	math: "\\acwoverarcarrow"
},
	"⤻": {
	math: "\\acwunderarcarrow"
},
	"⤼": {
	math: "\\curvearrowrightminus"
},
	"⤽": {
	math: "\\curvearrowleftplus"
},
	"⤾": {
	math: "\\cwundercurvearrow"
},
	"⤿": {
	math: "\\ccwundercurvearrow"
},
	"⥀": {
	math: "\\Elolarr"
},
	"⥁": {
	math: "\\Elorarr"
},
	"⥂": {
	math: "\\ElzRlarr"
},
	"⥃": {
	math: "\\leftarrowshortrightarrow"
},
	"⥄": {
	math: "\\ElzrLarr"
},
	"⥅": {
	math: "\\rightarrowplus"
},
	"⥆": {
	math: "\\leftarrowplus"
},
	"⥇": {
	math: "\\Elzrarrx"
},
	"⥈": {
	math: "\\leftrightarrowcircle"
},
	"⥉": {
	math: "\\twoheaduparrowcircle"
},
	"⥊": {
	math: "\\leftrightharpoon"
},
	"⥋": {
	math: "\\rightleftharpoon"
},
	"⥌": {
	math: "\\updownharpoonrightleft"
},
	"⥍": {
	math: "\\updownharpoonleftright"
},
	"⥎": {
	math: "\\LeftRightVector"
},
	"⥏": {
	math: "\\RightUpDownVector"
},
	"⥐": {
	math: "\\DownLeftRightVector"
},
	"⥑": {
	math: "\\LeftUpDownVector"
},
	"⥒": {
	math: "\\LeftVectorBar"
},
	"⥓": {
	math: "\\RightVectorBar"
},
	"⥔": {
	math: "\\RightUpVectorBar"
},
	"⥕": {
	math: "\\RightDownVectorBar"
},
	"⥖": {
	math: "\\DownLeftVectorBar"
},
	"⥗": {
	math: "\\DownRightVectorBar"
},
	"⥘": {
	math: "\\LeftUpVectorBar"
},
	"⥙": {
	math: "\\LeftDownVectorBar"
},
	"⥚": {
	math: "\\LeftTeeVector"
},
	"⥛": {
	math: "\\RightTeeVector"
},
	"⥜": {
	math: "\\RightUpTeeVector"
},
	"⥝": {
	math: "\\RightDownTeeVector"
},
	"⥞": {
	math: "\\DownLeftTeeVector"
},
	"⥟": {
	math: "\\DownRightTeeVector"
},
	"⥠": {
	math: "\\LeftUpTeeVector"
},
	"⥡": {
	math: "\\LeftDownTeeVector"
},
	"⥢": {
	math: "\\leftleftharpoons"
},
	"⥣": {
	math: "\\upupharpoons"
},
	"⥤": {
	math: "\\rightrightharpoons"
},
	"⥥": {
	math: "\\downdownharpoons"
},
	"⥦": {
	math: "\\leftrightharpoonsup"
},
	"⥧": {
	math: "\\leftrightharpoonsdown"
},
	"⥨": {
	math: "\\rightleftharpoonsup"
},
	"⥩": {
	math: "\\rightleftharpoonsdown"
},
	"⥪": {
	math: "\\leftbarharpoon"
},
	"⥫": {
	math: "\\barleftharpoon"
},
	"⥬": {
	math: "\\rightbarharpoon"
},
	"⥭": {
	math: "\\barrightharpoon"
},
	"⥮": {
	math: "\\UpEquilibrium"
},
	"⥯": {
	math: "\\ReverseUpEquilibrium"
},
	"⥰": {
	math: "\\RoundImplies"
},
	"⥱": {
	math: "\\equalrightarrow"
},
	"⥲": {
	math: "\\similarrightarrow"
},
	"⥳": {
	math: "\\leftarrowsimilar"
},
	"⥴": {
	math: "\\rightarrowsimilar"
},
	"⥵": {
	math: "\\rightarrowapprox"
},
	"⥶": {
	math: "\\ltlarr"
},
	"⥷": {
	math: "\\leftarrowless"
},
	"⥸": {
	math: "\\gtrarr"
},
	"⥹": {
	math: "\\subrarr"
},
	"⥺": {
	math: "\\leftarrowsubset"
},
	"⥻": {
	math: "\\suplarr"
},
	"⥾": {
	math: "\\upfishtail"
},
	"⥿": {
	math: "\\downfishtail"
},
	"⦀": {
	math: "\\Elztfnc"
},
	"⦁": {
	math: "\\spot"
},
	"⦂": {
	math: "\\typecolon"
},
	"⦃": {
	math: "\\lBrace"
},
	"⦄": {
	math: "\\rBrace"
},
	"⦆": {
	math: "\\Elroang"
},
	"⦇": {
	math: "\\limg"
},
	"⦈": {
	math: "\\rimg"
},
	"⦉": {
	math: "\\lblot"
},
	"⦊": {
	math: "\\rblot"
},
	"⦋": {
	math: "\\lbrackubar"
},
	"⦌": {
	math: "\\rbrackubar"
},
	"⦍": {
	math: "\\lbrackultick"
},
	"⦎": {
	math: "\\rbracklrtick"
},
	"⦏": {
	math: "\\lbracklltick"
},
	"⦐": {
	math: "\\rbrackurtick"
},
	"⦑": {
	math: "\\langledot"
},
	"⦒": {
	math: "\\rangledot"
},
	"⦓": {
	math: "<\\kern-0.58em("
},
	"⦕": {
	math: "\\Lparengtr"
},
	"⦖": {
	math: "\\Rparenless"
},
	"⦗": {
	math: "\\lblkbrbrak"
},
	"⦘": {
	math: "\\rblkbrbrak"
},
	"⦙": {
	math: "\\Elzddfnc"
},
	"⦚": {
	math: "\\vzigzag"
},
	"⦛": {
	math: "\\measuredangleleft"
},
	"⦜": {
	math: "\\Angle"
},
	"⦝": {
	math: "\\rightanglemdot"
},
	"⦞": {
	math: "\\angles"
},
	"⦟": {
	math: "\\angdnr"
},
	"⦠": {
	math: "\\Elzlpargt"
},
	"⦡": {
	math: "\\sphericalangleup"
},
	"⦢": {
	math: "\\turnangle"
},
	"⦣": {
	math: "\\revangle"
},
	"⦤": {
	math: "\\angleubar"
},
	"⦥": {
	math: "\\revangleubar"
},
	"⦦": {
	math: "\\wideangledown"
},
	"⦧": {
	math: "\\wideangleup"
},
	"⦨": {
	math: "\\measanglerutone"
},
	"⦩": {
	math: "\\measanglelutonw"
},
	"⦪": {
	math: "\\measanglerdtose"
},
	"⦫": {
	math: "\\measangleldtosw"
},
	"⦬": {
	math: "\\measangleurtone"
},
	"⦭": {
	math: "\\measangleultonw"
},
	"⦮": {
	math: "\\measangledrtose"
},
	"⦯": {
	math: "\\measangledltosw"
},
	"⦰": {
	math: "\\revemptyset"
},
	"⦱": {
	math: "\\emptysetobar"
},
	"⦲": {
	math: "\\emptysetocirc"
},
	"⦳": {
	math: "\\emptysetoarr"
},
	"⦴": {
	math: "\\emptysetoarrl"
},
	"⦷": {
	math: "\\circledparallel"
},
	"⦸": {
	math: "\\circledbslash"
},
	"⦹": {
	math: "\\operp"
},
	"⦺": {
	math: "\\obot"
},
	"⦻": {
	math: "\\olcross"
},
	"⦼": {
	math: "\\odotslashdot"
},
	"⦽": {
	math: "\\uparrowoncircle"
},
	"⦾": {
	math: "\\circledwhitebullet"
},
	"⦿": {
	math: "\\circledbullet"
},
	"⧀": {
	math: "\\circledless"
},
	"⧁": {
	math: "\\circledgtr"
},
	"⧂": {
	math: "\\cirscir"
},
	"⧃": {
	math: "\\cirE"
},
	"⧄": {
	math: "\\boxslash"
},
	"⧅": {
	math: "\\boxbslash"
},
	"⧆": {
	math: "\\boxast"
},
	"⧇": {
	math: "\\boxcircle"
},
	"⧈": {
	math: "\\boxbox"
},
	"⧉": {
	math: "\\boxonbox"
},
	"⧊": {
	math: "\\ElzLap"
},
	"⧋": {
	math: "\\Elzdefas"
},
	"⧌": {
	math: "\\triangles"
},
	"⧍": {
	math: "\\triangleserifs"
},
	"⧎": {
	math: "\\rtriltri"
},
	"⧏": {
	math: "\\LeftTriangleBar"
},
	"⧏̸": {
	math: "\\NotLeftTriangleBar"
},
	"⧐": {
	math: "\\RightTriangleBar"
},
	"⧐̸": {
	math: "\\NotRightTriangleBar"
},
	"⧑": {
	math: "\\lfbowtie"
},
	"⧒": {
	math: "\\rfbowtie"
},
	"⧓": {
	math: "\\fbowtie"
},
	"⧔": {
	math: "\\lftimes"
},
	"⧕": {
	math: "\\rftimes"
},
	"⧖": {
	math: "\\hourglass"
},
	"⧗": {
	math: "\\blackhourglass"
},
	"⧘": {
	math: "\\lvzigzag"
},
	"⧙": {
	math: "\\rvzigzag"
},
	"⧚": {
	math: "\\Lvzigzag"
},
	"⧛": {
	math: "\\Rvzigzag"
},
	"⧝": {
	math: "\\tieinfty"
},
	"⧞": {
	math: "\\nvinfty"
},
	"⧟": {
	math: "\\multimapboth"
},
	"⧠": {
	math: "\\laplac"
},
	"⧡": {
	math: "\\lrtriangleeq"
},
	"⧢": {
	math: "\\shuffle"
},
	"⧣": {
	math: "\\eparsl"
},
	"⧤": {
	math: "\\smeparsl"
},
	"⧥": {
	math: "\\eqvparsl"
},
	"⧦": {
	math: "\\gleichstark"
},
	"⧧": {
	math: "\\thermod"
},
	"⧨": {
	math: "\\downtriangleleftblack"
},
	"⧩": {
	math: "\\downtrianglerightblack"
},
	"⧪": {
	math: "\\blackdiamonddownarrow"
},
	"⧫": {
	math: "\\blacklozenge"
},
	"⧬": {
	math: "\\circledownarrow"
},
	"⧭": {
	math: "\\blackcircledownarrow"
},
	"⧮": {
	math: "\\errbarsquare"
},
	"⧯": {
	math: "\\errbarblacksquare"
},
	"⧰": {
	math: "\\errbardiamond"
},
	"⧱": {
	math: "\\errbarblackdiamond"
},
	"⧲": {
	math: "\\errbarcircle"
},
	"⧳": {
	math: "\\errbarblackcircle"
},
	"⧴": {
	math: "\\RuleDelayed"
},
	"⧵": {
	math: "\\setminus"
},
	"⧶": {
	math: "\\dsol"
},
	"⧷": {
	math: "\\rsolbar"
},
	"⧸": {
	math: "\\xsol"
},
	"⧹": {
	math: "\\zhide"
},
	"⧺": {
	math: "\\doubleplus"
},
	"⧻": {
	math: "\\tripleplus"
},
	"⧼": {
	math: "\\lcurvyangle"
},
	"⧽": {
	math: "\\rcurvyangle"
},
	"⧾": {
	math: "\\tplus"
},
	"⧿": {
	math: "\\tminus"
},
	"⨀": {
	math: "\\bigodot"
},
	"⨁": {
	math: "\\bigoplus"
},
	"⨂": {
	math: "\\bigotimes"
},
	"⨃": {
	math: "\\bigcupdot"
},
	"⨄": {
	math: "\\Elxuplus"
},
	"⨅": {
	math: "\\ElzThr"
},
	"⨆": {
	math: "\\Elxsqcup"
},
	"⨇": {
	math: "\\ElzInf"
},
	"⨈": {
	math: "\\ElzSup"
},
	"⨉": {
	math: "\\varprod"
},
	"⨊": {
	math: "\\modtwosum"
},
	"⨋": {
	math: "\\sumint"
},
	"⨌": {
	math: "\\iiiint"
},
	"⨍": {
	math: "\\ElzCint"
},
	"⨎": {
	math: "\\intBar"
},
	"⨏": {
	math: "\\clockoint"
},
	"⨑": {
	math: "\\awint"
},
	"⨒": {
	math: "\\rppolint"
},
	"⨓": {
	math: "\\scpolint"
},
	"⨔": {
	math: "\\npolint"
},
	"⨕": {
	math: "\\pointint"
},
	"⨖": {
	math: "\\sqrint"
},
	"⨗": {
	math: "\\intlarhk"
},
	"⨘": {
	math: "\\intx"
},
	"⨙": {
	math: "\\intcap"
},
	"⨚": {
	math: "\\intcup"
},
	"⨛": {
	math: "\\upint"
},
	"⨜": {
	math: "\\lowint"
},
	"⨝": {
	math: "\\Join"
},
	"⨞": {
	math: "\\bigtriangleleft"
},
	"⨟": {
	math: "\\zcmp"
},
	"⨠": {
	math: "\\zpipe"
},
	"⨡": {
	math: "\\zproject"
},
	"⨢": {
	math: "\\ringplus"
},
	"⨣": {
	math: "\\plushat"
},
	"⨤": {
	math: "\\simplus"
},
	"⨦": {
	math: "\\plussim"
},
	"⨧": {
	math: "\\plussubtwo"
},
	"⨨": {
	math: "\\plustrif"
},
	"⨩": {
	math: "\\commaminus"
},
	"⨫": {
	math: "\\minusfdots"
},
	"⨬": {
	math: "\\minusrdots"
},
	"⨯": {
	math: "\\ElzTimes"
},
	"⨰": {
	math: "\\dottimes"
},
	"⨱": {
	math: "\\timesbar"
},
	"⨲": {
	math: "\\btimes"
},
	"⨳": {
	math: "\\smashtimes"
},
	"⨶": {
	math: "\\otimeshat"
},
	"⨷": {
	math: "\\Otimes"
},
	"⨸": {
	math: "\\odiv"
},
	"⨹": {
	math: "\\triangleplus"
},
	"⨺": {
	math: "\\triangleminus"
},
	"⨻": {
	math: "\\triangletimes"
},
	"⨽": {
	math: "\\intprodr"
},
	"⨾": {
	math: "\\fcmp"
},
	"⨿": {
	math: "\\amalg"
},
	"⩀": {
	math: "\\capdot"
},
	"⩁": {
	math: "\\uminus"
},
	"⩂": {
	math: "\\barcup"
},
	"⩃": {
	math: "\\barcap"
},
	"⩄": {
	math: "\\capwedge"
},
	"⩅": {
	math: "\\cupvee"
},
	"⩆": {
	math: "\\cupovercap"
},
	"⩇": {
	math: "\\capovercup"
},
	"⩈": {
	math: "\\cupbarcap"
},
	"⩉": {
	math: "\\capbarcup"
},
	"⩊": {
	math: "\\twocups"
},
	"⩋": {
	math: "\\twocaps"
},
	"⩌": {
	math: "\\closedvarcup"
},
	"⩍": {
	math: "\\closedvarcap"
},
	"⩎": {
	math: "\\Sqcap"
},
	"⩏": {
	math: "\\Sqcup"
},
	"⩐": {
	math: "\\closedvarcupsmashprod"
},
	"⩑": {
	math: "\\wedgeodot"
},
	"⩒": {
	math: "\\veeodot"
},
	"⩓": {
	math: "\\ElzAnd"
},
	"⩔": {
	math: "\\ElzOr"
},
	"⩖": {
	math: "\\ElOr"
},
	"⩗": {
	math: "\\bigslopedvee"
},
	"⩘": {
	math: "\\bigslopedwedge"
},
	"⩙": {
	math: "\\veeonwedge"
},
	"⩚": {
	math: "\\wedgemidvert"
},
	"⩛": {
	math: "\\veemidvert"
},
	"⩜": {
	math: "\\midbarwedge"
},
	"⩝": {
	math: "\\midbarvee"
},
	"⩞": {
	math: "\\perspcorrespond"
},
	"⩟": {
	math: "\\Elzminhat"
},
	"⩠": {
	math: "\\wedgedoublebar"
},
	"⩡": {
	math: "\\varveebar"
},
	"⩢": {
	math: "\\doublebarvee"
},
	"⩤": {
	math: "\\dsub"
},
	"⩥": {
	math: "\\rsub"
},
	"⩦": {
	math: "\\eqdot"
},
	"⩧": {
	math: "\\dotequiv"
},
	"⩨": {
	math: "\\equivVert"
},
	"⩩": {
	math: "\\equivVvert"
},
	"⩪": {
	math: "\\dotsim"
},
	"⩫": {
	math: "\\simrdots"
},
	"⩬": {
	math: "\\simminussim"
},
	"⩭": {
	math: "\\congdot"
},
	"⩮": {
	math: "\\stackrel{*}{=}"
},
	"⩯": {
	math: "\\hatapprox"
},
	"⩰": {
	math: "\\approxeqq"
},
	"⩱": {
	math: "\\eqqplus"
},
	"⩲": {
	math: "\\pluseqq"
},
	"⩳": {
	math: "\\eqqsim"
},
	"⩴": {
	math: "\\Coloneqq"
},
	"⩵": {
	math: "\\Equal"
},
	"⩶": {
	math: "\\Same"
},
	"⩷": {
	math: "\\ddotseq"
},
	"⩸": {
	math: "\\equivDD"
},
	"⩹": {
	math: "\\ltcir"
},
	"⩺": {
	math: "\\gtcir"
},
	"⩻": {
	math: "\\ltquest"
},
	"⩼": {
	math: "\\gtquest"
},
	"⩽": {
	math: "\\leqslant",
	mathpackages: [
		"amssymb"
	]
},
	"⩽̸": {
	math: "\\nleqslant",
	mathpackages: [
		"amssymb"
	]
},
	"⩾": {
	math: "\\geqslant",
	mathpackages: [
		"amssymb"
	]
},
	"⩾̸": {
	math: "\\ngeqslant",
	mathpackages: [
		"amssymb"
	]
},
	"⩿": {
	math: "\\lesdot"
},
	"⪀": {
	math: "\\gesdot"
},
	"⪁": {
	math: "\\lesdoto"
},
	"⪂": {
	math: "\\gesdoto"
},
	"⪃": {
	math: "\\lesdotor"
},
	"⪄": {
	math: "\\gesdotol"
},
	"⪅": {
	math: "\\lessapprox"
},
	"⪆": {
	math: "\\gtrapprox"
},
	"⪇": {
	math: "\\lneq"
},
	"⪈": {
	math: "\\gneq"
},
	"⪉": {
	math: "\\lnapprox"
},
	"⪊": {
	math: "\\gnapprox"
},
	"⪋": {
	math: "\\lesseqqgtr"
},
	"⪌": {
	math: "\\gtreqqless"
},
	"⪍": {
	math: "\\lsime"
},
	"⪎": {
	math: "\\gsime"
},
	"⪏": {
	math: "\\lsimg"
},
	"⪐": {
	math: "\\gsiml"
},
	"⪑": {
	math: "\\lgE"
},
	"⪒": {
	math: "\\glE"
},
	"⪓": {
	math: "\\lesges"
},
	"⪔": {
	math: "\\gesles"
},
	"⪕": {
	math: "\\eqslantless"
},
	"⪖": {
	math: "\\eqslantgtr"
},
	"⪗": {
	math: "\\elsdot"
},
	"⪘": {
	math: "\\egsdot"
},
	"⪙": {
	math: "\\eqqless"
},
	"⪚": {
	math: "\\eqqgtr"
},
	"⪛": {
	math: "\\eqqslantless"
},
	"⪜": {
	math: "\\eqqslantgtr"
},
	"⪝": {
	math: "\\Pisymbol{ppi020}{117}"
},
	"⪞": {
	math: "\\Pisymbol{ppi020}{105}"
},
	"⪟": {
	math: "\\simlE"
},
	"⪠": {
	math: "\\simgE"
},
	"⪡": {
	math: "\\NestedLessLess"
},
	"⪡̸": {
	math: "\\NotNestedLessLess"
},
	"⪢": {
	math: "\\NestedGreaterGreater"
},
	"⪢̸": {
	math: "\\NotNestedGreaterGreater"
},
	"⪣": {
	math: "\\partialmeetcontraction"
},
	"⪤": {
	math: "\\glj"
},
	"⪥": {
	math: "\\gla"
},
	"⪦": {
	math: "\\leftslice"
},
	"⪧": {
	math: "\\rightslice"
},
	"⪨": {
	math: "\\lescc"
},
	"⪩": {
	math: "\\gescc"
},
	"⪪": {
	math: "\\smt"
},
	"⪫": {
	math: "\\lat"
},
	"⪬": {
	math: "\\smte"
},
	"⪭": {
	math: "\\late"
},
	"⪮": {
	math: "\\bumpeqq"
},
	"⪯": {
	math: "\\preceq"
},
	"⪯̸": {
	math: "\\not\\preceq"
},
	"⪰": {
	math: "\\succeq"
},
	"⪰̸": {
	math: "\\not\\succeq"
},
	"⪱": {
	math: "\\precneq"
},
	"⪲": {
	math: "\\succneq"
},
	"⪳": {
	math: "\\preceqq"
},
	"⪴": {
	math: "\\succeqq"
},
	"⪵": {
	math: "\\precneqq"
},
	"⪶": {
	math: "\\succneqq"
},
	"⪷": {
	math: "\\precapprox"
},
	"⪸": {
	math: "\\succapprox"
},
	"⪹": {
	math: "\\precnapprox"
},
	"⪺": {
	math: "\\succnapprox"
},
	"⪻": {
	math: "\\llcurly"
},
	"⪼": {
	math: "\\ggcurly"
},
	"⪽": {
	math: "\\subsetdot"
},
	"⪾": {
	math: "\\supsetdot"
},
	"⪿": {
	math: "\\subsetplus"
},
	"⫀": {
	math: "\\supsetplus"
},
	"⫁": {
	math: "\\submult"
},
	"⫂": {
	math: "\\supmult"
},
	"⫃": {
	math: "\\subedot"
},
	"⫄": {
	math: "\\supedot"
},
	"⫅": {
	math: "\\subseteqq"
},
	"⫅̸": {
	math: "\\nsubseteqq"
},
	"⫆": {
	math: "\\supseteqq"
},
	"⫆̸": {
	math: "\\nsupseteqq"
},
	"⫇": {
	math: "\\subsim"
},
	"⫈": {
	math: "\\supsim"
},
	"⫉": {
	math: "\\subsetapprox"
},
	"⫊": {
	math: "\\supsetapprox"
},
	"⫋": {
	math: "\\subsetneqq"
},
	"⫌": {
	math: "\\supsetneqq"
},
	"⫍": {
	math: "\\lsqhook"
},
	"⫎": {
	math: "\\rsqhook"
},
	"⫏": {
	math: "\\csub"
},
	"⫐": {
	math: "\\csup"
},
	"⫑": {
	math: "\\csube"
},
	"⫒": {
	math: "\\csupe"
},
	"⫓": {
	math: "\\subsup"
},
	"⫔": {
	math: "\\supsub"
},
	"⫕": {
	math: "\\subsub"
},
	"⫖": {
	math: "\\supsup"
},
	"⫗": {
	math: "\\suphsub"
},
	"⫘": {
	math: "\\supdsub"
},
	"⫙": {
	math: "\\forkv"
},
	"⫚": {
	math: "\\topfork"
},
	"⫛": {
	math: "\\mlcp"
},
	"⫝̸": {
	math: "\\forks"
},
	"⫝": {
	math: "\\forksnot"
},
	"⫝̸": {
	math: "\\forks"
},
	"⫞": {
	math: "\\shortlefttack"
},
	"⫟": {
	math: "\\shortdowntack"
},
	"⫠": {
	math: "\\shortuptack"
},
	"⫡": {
	math: "\\perps"
},
	"⫢": {
	math: "\\vDdash"
},
	"⫣": {
	math: "\\dashV"
},
	"⫤": {
	math: "\\Dashv"
},
	"⫥": {
	math: "\\DashV"
},
	"⫦": {
	math: "\\varVdash"
},
	"⫧": {
	math: "\\Barv"
},
	"⫨": {
	math: "\\vBar"
},
	"⫩": {
	math: "\\vBarv"
},
	"⫪": {
	math: "\\Top"
},
	"⫬": {
	math: "\\Not"
},
	"⫭": {
	math: "\\bNot"
},
	"⫮": {
	math: "\\revnmid"
},
	"⫯": {
	math: "\\cirmid"
},
	"⫰": {
	math: "\\midcir"
},
	"⫱": {
	math: "\\topcir"
},
	"⫲": {
	math: "\\nhpar"
},
	"⫳": {
	math: "\\parsim"
},
	"⫴": {
	math: "\\interleave"
},
	"⫵": {
	math: "\\nhVvert"
},
	"⫶": {
	math: "\\Elztdcol"
},
	"⫷": {
	math: "\\lllnest"
},
	"⫸": {
	math: "\\gggnest"
},
	"⫹": {
	math: "\\leqqslant"
},
	"⫺": {
	math: "\\geqqslant"
},
	"⫻": {
	math: "\\trslash"
},
	"⫼": {
	math: "\\biginterleave"
},
	"⫽": {
	math: "{{/}\\!\\!{/}}"
},
	"⫽⃥": {
	math: "{\\rlap{\\textbackslash}{{/}\\!\\!{/}}}"
},
	"⫾": {
	math: "\\talloblong"
},
	"⫿": {
	math: "\\bigtalloblong"
},
	"⬒": {
	math: "\\squaretopblack"
},
	"⬓": {
	math: "\\squarebotblack"
},
	"⬔": {
	math: "\\squareurblack"
},
	"⬕": {
	math: "\\squarellblack"
},
	"⬖": {
	math: "\\diamondleftblack"
},
	"⬗": {
	math: "\\diamondrightblack"
},
	"⬘": {
	math: "\\diamondtopblack"
},
	"⬙": {
	math: "\\diamondbotblack"
},
	"⬚": {
	math: "\\dottedsquare"
},
	"⬛": {
	math: "\\blacksquare"
},
	"⬜": {
	math: "\\square"
},
	"⬝": {
	math: "\\vysmblksquare"
},
	"⬞": {
	math: "\\vysmwhtsquare"
},
	"⬟": {
	math: "\\pentagonblack"
},
	"⬠": {
	math: "\\pentagon"
},
	"⬡": {
	math: "\\varhexagon"
},
	"⬢": {
	math: "\\varhexagonblack"
},
	"⬣": {
	math: "\\hexagonblack"
},
	"⬤": {
	math: "\\lgblkcircle"
},
	"⬥": {
	math: "\\mdblkdiamond"
},
	"⬦": {
	math: "\\mdwhtdiamond"
},
	"⬧": {
	math: "\\mdblklozenge"
},
	"⬨": {
	math: "\\mdwhtlozenge"
},
	"⬩": {
	math: "\\smblkdiamond"
},
	"⬪": {
	math: "\\smblklozenge"
},
	"⬫": {
	math: "\\smwhtlozenge"
},
	"⬬": {
	math: "\\blkhorzoval"
},
	"⬭": {
	math: "\\whthorzoval"
},
	"⬮": {
	math: "\\blkvertoval"
},
	"⬯": {
	math: "\\whtvertoval"
},
	"⬰": {
	math: "\\circleonleftarrow"
},
	"⬱": {
	math: "\\leftthreearrows"
},
	"⬲": {
	math: "\\leftarrowonoplus"
},
	"⬳": {
	math: "\\longleftsquigarrow"
},
	"⬴": {
	math: "\\nvtwoheadleftarrow"
},
	"⬵": {
	math: "\\nVtwoheadleftarrow"
},
	"⬶": {
	math: "\\twoheadmapsfrom"
},
	"⬷": {
	math: "\\twoheadleftdbkarrow"
},
	"⬸": {
	math: "\\leftdotarrow"
},
	"⬹": {
	math: "\\nvleftarrowtail"
},
	"⬺": {
	math: "\\nVleftarrowtail"
},
	"⬻": {
	math: "\\twoheadleftarrowtail"
},
	"⬼": {
	math: "\\nvtwoheadleftarrowtail"
},
	"⬽": {
	math: "\\nVtwoheadleftarrowtail"
},
	"⬾": {
	math: "\\leftarrowx"
},
	"⬿": {
	math: "\\leftcurvedarrow"
},
	"⭀": {
	math: "\\equalleftarrow"
},
	"⭁": {
	math: "\\bsimilarleftarrow"
},
	"⭂": {
	math: "\\leftarrowbackapprox"
},
	"⭃": {
	math: "\\rightarrowgtr"
},
	"⭄": {
	math: "\\rightarrowsupset"
},
	"⭅": {
	math: "\\LLeftarrow"
},
	"⭆": {
	math: "\\RRightarrow"
},
	"⭇": {
	math: "\\bsimilarrightarrow"
},
	"⭈": {
	math: "\\rightarrowbackapprox"
},
	"⭉": {
	math: "\\similarleftarrow"
},
	"⭊": {
	math: "\\leftarrowapprox"
},
	"⭋": {
	math: "\\leftarrowbsimilar"
},
	"⭌": {
	math: "\\rightarrowbsimilar"
},
	"⭐": {
	math: "\\medwhitestar"
},
	"⭑": {
	math: "\\medblackstar"
},
	"⭒": {
	math: "\\smwhitestar"
},
	"⭓": {
	math: "\\rightpentagonblack"
},
	"⭔": {
	math: "\\rightpentagon"
},
	"〈": {
	math: "\\langle"
},
	"〉": {
	math: "\\rangle"
},
	"〒": {
	math: "\\postalmark"
},
	"〔": {
	math: "\\lbrbrak"
},
	"〕": {
	math: "\\rbrbrak"
},
	"〚": {
	math: "\\openbracketleft"
},
	"〛": {
	math: "\\openbracketright"
},
	"〰": {
	math: "\\hzigzag"
},
	"ﬀ": {
	text: "ff"
},
	"ﬁ": {
	text: "fi"
},
	"ﬂ": {
	text: "fl"
},
	"ﬃ": {
	text: "ffi"
},
	"ﬄ": {
	text: "ffl"
},
	"ﬅ": {
	text: "st"
},
	"ﬆ": {
	text: "st"
},
	"�": {
	text: "\\dbend",
	commandspacer: true
},
	"𝐀": {
	math: "\\mathbf{A}"
},
	"𝐁": {
	math: "\\mathbf{B}"
},
	"𝐂": {
	math: "\\mathbf{C}"
},
	"𝐃": {
	math: "\\mathbf{D}"
},
	"𝐄": {
	math: "\\mathbf{E}"
},
	"𝐅": {
	math: "\\mathbf{F}"
},
	"𝐆": {
	math: "\\mathbf{G}"
},
	"𝐇": {
	math: "\\mathbf{H}"
},
	"𝐈": {
	math: "\\mathbf{I}"
},
	"𝐉": {
	math: "\\mathbf{J}"
},
	"𝐊": {
	math: "\\mathbf{K}"
},
	"𝐋": {
	math: "\\mathbf{L}"
},
	"𝐌": {
	math: "\\mathbf{M}"
},
	"𝐍": {
	math: "\\mathbf{N}"
},
	"𝐎": {
	math: "\\mathbf{O}"
},
	"𝐏": {
	math: "\\mathbf{P}"
},
	"𝐐": {
	math: "\\mathbf{Q}"
},
	"𝐑": {
	math: "\\mathbf{R}"
},
	"𝐒": {
	math: "\\mathbf{S}"
},
	"𝐓": {
	math: "\\mathbf{T}"
},
	"𝐔": {
	math: "\\mathbf{U}"
},
	"𝐕": {
	math: "\\mathbf{V}"
},
	"𝐖": {
	math: "\\mathbf{W}"
},
	"𝐗": {
	math: "\\mathbf{X}"
},
	"𝐘": {
	math: "\\mathbf{Y}"
},
	"𝐙": {
	math: "\\mathbf{Z}"
},
	"𝐚": {
	math: "\\mathbf{a}"
},
	"𝐛": {
	math: "\\mathbf{b}"
},
	"𝐜": {
	math: "\\mathbf{c}"
},
	"𝐝": {
	math: "\\mathbf{d}"
},
	"𝐞": {
	math: "\\mathbf{e}"
},
	"𝐟": {
	math: "\\mathbf{f}"
},
	"𝐠": {
	math: "\\mathbf{g}"
},
	"𝐡": {
	math: "\\mathbf{h}"
},
	"𝐢": {
	math: "\\mathbf{i}"
},
	"𝐣": {
	math: "\\mathbf{j}"
},
	"𝐤": {
	math: "\\mathbf{k}"
},
	"𝐥": {
	math: "\\mathbf{l}"
},
	"𝐦": {
	math: "\\mathbf{m}"
},
	"𝐧": {
	math: "\\mathbf{n}"
},
	"𝐨": {
	math: "\\mathbf{o}"
},
	"𝐩": {
	math: "\\mathbf{p}"
},
	"𝐪": {
	math: "\\mathbf{q}"
},
	"𝐫": {
	math: "\\mathbf{r}"
},
	"𝐬": {
	math: "\\mathbf{s}"
},
	"𝐭": {
	math: "\\mathbf{t}"
},
	"𝐮": {
	math: "\\mathbf{u}"
},
	"𝐯": {
	math: "\\mathbf{v}"
},
	"𝐰": {
	math: "\\mathbf{w}"
},
	"𝐱": {
	math: "\\mathbf{x}"
},
	"𝐲": {
	math: "\\mathbf{y}"
},
	"𝐳": {
	math: "\\mathbf{z}"
},
	"𝐴": {
	math: "\\mathsl{A}"
},
	"𝐵": {
	math: "\\mathsl{B}"
},
	"𝐶": {
	math: "\\mathsl{C}"
},
	"𝐷": {
	math: "\\mathsl{D}"
},
	"𝐸": {
	math: "\\mathsl{E}"
},
	"𝐹": {
	math: "\\mathsl{F}"
},
	"𝐺": {
	math: "\\mathsl{G}"
},
	"𝐻": {
	math: "\\mathsl{H}"
},
	"𝐼": {
	math: "\\mathsl{I}"
},
	"𝐽": {
	math: "\\mathsl{J}"
},
	"𝐾": {
	math: "\\mathsl{K}"
},
	"𝐿": {
	math: "\\mathsl{L}"
},
	"𝑀": {
	math: "\\mathsl{M}"
},
	"𝑁": {
	math: "\\mathsl{N}"
},
	"𝑂": {
	math: "\\mathsl{O}"
},
	"𝑃": {
	math: "\\mathsl{P}"
},
	"𝑄": {
	math: "\\mathsl{Q}"
},
	"𝑅": {
	math: "\\mathsl{R}"
},
	"𝑆": {
	math: "\\mathsl{S}"
},
	"𝑇": {
	math: "\\mathsl{T}"
},
	"𝑈": {
	math: "\\mathsl{U}"
},
	"𝑉": {
	math: "\\mathsl{V}"
},
	"𝑊": {
	math: "\\mathsl{W}"
},
	"𝑋": {
	math: "\\mathsl{X}"
},
	"𝑌": {
	math: "\\mathsl{Y}"
},
	"𝑍": {
	math: "\\mathsl{Z}"
},
	"𝑎": {
	math: "\\mathsl{a}"
},
	"𝑏": {
	math: "\\mathsl{b}"
},
	"𝑐": {
	math: "\\mathsl{c}"
},
	"𝑑": {
	math: "\\mathsl{d}"
},
	"𝑒": {
	math: "\\mathsl{e}"
},
	"𝑓": {
	math: "\\mathsl{f}"
},
	"𝑔": {
	math: "\\mathsl{g}"
},
	"𝑖": {
	math: "\\mathsl{i}"
},
	"𝑗": {
	math: "\\mathsl{j}"
},
	"𝑘": {
	math: "\\mathsl{k}"
},
	"𝑙": {
	math: "\\mathsl{l}"
},
	"𝑚": {
	math: "\\mathsl{m}"
},
	"𝑛": {
	math: "\\mathsl{n}"
},
	"𝑜": {
	math: "\\mathsl{o}"
},
	"𝑝": {
	math: "\\mathsl{p}"
},
	"𝑞": {
	math: "\\mathsl{q}"
},
	"𝑟": {
	math: "\\mathsl{r}"
},
	"𝑠": {
	math: "\\mathsl{s}"
},
	"𝑡": {
	math: "\\mathsl{t}"
},
	"𝑢": {
	math: "\\mathsl{u}"
},
	"𝑣": {
	math: "\\mathsl{v}"
},
	"𝑤": {
	math: "\\mathsl{w}"
},
	"𝑥": {
	math: "\\mathsl{x}"
},
	"𝑦": {
	math: "\\mathsl{y}"
},
	"𝑧": {
	math: "\\mathsl{z}"
},
	"𝑨": {
	math: "\\mathbit{A}"
},
	"𝑩": {
	math: "\\mathbit{B}"
},
	"𝑪": {
	math: "\\mathbit{C}"
},
	"𝑫": {
	math: "\\mathbit{D}"
},
	"𝑬": {
	math: "\\mathbit{E}"
},
	"𝑭": {
	math: "\\mathbit{F}"
},
	"𝑮": {
	math: "\\mathbit{G}"
},
	"𝑯": {
	math: "\\mathbit{H}"
},
	"𝑰": {
	math: "\\mathbit{I}"
},
	"𝑱": {
	math: "\\mathbit{J}"
},
	"𝑲": {
	math: "\\mathbit{K}"
},
	"𝑳": {
	math: "\\mathbit{L}"
},
	"𝑴": {
	math: "\\mathbit{M}"
},
	"𝑵": {
	math: "\\mathbit{N}"
},
	"𝑶": {
	math: "\\mathbit{O}"
},
	"𝑷": {
	math: "\\mathbit{P}"
},
	"𝑸": {
	math: "\\mathbit{Q}"
},
	"𝑹": {
	math: "\\mathbit{R}"
},
	"𝑺": {
	math: "\\mathbit{S}"
},
	"𝑻": {
	math: "\\mathbit{T}"
},
	"𝑼": {
	math: "\\mathbit{U}"
},
	"𝑽": {
	math: "\\mathbit{V}"
},
	"𝑾": {
	math: "\\mathbit{W}"
},
	"𝑿": {
	math: "\\mathbit{X}"
},
	"𝒀": {
	math: "\\mathbit{Y}"
},
	"𝒁": {
	math: "\\mathbit{Z}"
},
	"𝒂": {
	math: "\\mathbit{a}"
},
	"𝒃": {
	math: "\\mathbit{b}"
},
	"𝒄": {
	math: "\\mathbit{c}"
},
	"𝒅": {
	math: "\\mathbit{d}"
},
	"𝒆": {
	math: "\\mathbit{e}"
},
	"𝒇": {
	math: "\\mathbit{f}"
},
	"𝒈": {
	math: "\\mathbit{g}"
},
	"𝒉": {
	math: "\\mathbit{h}"
},
	"𝒊": {
	math: "\\mathbit{i}"
},
	"𝒋": {
	math: "\\mathbit{j}"
},
	"𝒌": {
	math: "\\mathbit{k}"
},
	"𝒍": {
	math: "\\mathbit{l}"
},
	"𝒎": {
	math: "\\mathbit{m}"
},
	"𝒏": {
	math: "\\mathbit{n}"
},
	"𝒐": {
	math: "\\mathbit{o}"
},
	"𝒑": {
	math: "\\mathbit{p}"
},
	"𝒒": {
	math: "\\mathbit{q}"
},
	"𝒓": {
	math: "\\mathbit{r}"
},
	"𝒔": {
	math: "\\mathbit{s}"
},
	"𝒕": {
	math: "\\mathbit{t}"
},
	"𝒖": {
	math: "\\mathbit{u}"
},
	"𝒗": {
	math: "\\mathbit{v}"
},
	"𝒘": {
	math: "\\mathbit{w}"
},
	"𝒙": {
	math: "\\mathbit{x}"
},
	"𝒚": {
	math: "\\mathbit{y}"
},
	"𝒛": {
	math: "\\mathbit{z}"
},
	"𝒜": {
	math: "\\mathscr{A}"
},
	"𝒞": {
	math: "\\mathscr{C}"
},
	"𝒟": {
	math: "\\mathscr{D}"
},
	"𝒢": {
	math: "\\mathscr{G}"
},
	"𝒥": {
	math: "\\mathscr{J}"
},
	"𝒦": {
	math: "\\mathscr{K}"
},
	"𝒩": {
	math: "\\mathscr{N}"
},
	"𝒪": {
	math: "\\mathscr{O}"
},
	"𝒫": {
	math: "\\mathscr{P}"
},
	"𝒬": {
	math: "\\mathscr{Q}"
},
	"𝒮": {
	math: "\\mathscr{S}"
},
	"𝒯": {
	math: "\\mathscr{T}"
},
	"𝒰": {
	math: "\\mathscr{U}"
},
	"𝒱": {
	math: "\\mathscr{V}"
},
	"𝒲": {
	math: "\\mathscr{W}"
},
	"𝒳": {
	math: "\\mathscr{X}"
},
	"𝒴": {
	math: "\\mathscr{Y}"
},
	"𝒵": {
	math: "\\mathscr{Z}"
},
	"𝒶": {
	math: "\\mathscr{a}"
},
	"𝒷": {
	math: "\\mathscr{b}"
},
	"𝒸": {
	math: "\\mathscr{c}"
},
	"𝒹": {
	math: "\\mathscr{d}"
},
	"𝒻": {
	math: "\\mathscr{f}"
},
	"𝒽": {
	math: "\\mathscr{h}"
},
	"𝒾": {
	math: "\\mathscr{i}"
},
	"𝒿": {
	math: "\\mathscr{j}"
},
	"𝓀": {
	math: "\\mathscr{k}"
},
	"𝓁": {
	math: "\\mathscr{l}"
},
	"𝓂": {
	math: "\\mathscr{m}"
},
	"𝓃": {
	math: "\\mathscr{n}"
},
	"𝓅": {
	math: "\\mathscr{p}"
},
	"𝓆": {
	math: "\\mathscr{q}"
},
	"𝓇": {
	math: "\\mathscr{r}"
},
	"𝓈": {
	math: "\\mathscr{s}"
},
	"𝓉": {
	math: "\\mathscr{t}"
},
	"𝓊": {
	math: "\\mathscr{u}"
},
	"𝓋": {
	math: "\\mathscr{v}"
},
	"𝓌": {
	math: "\\mathscr{w}"
},
	"𝓍": {
	math: "\\mathscr{x}"
},
	"𝓎": {
	math: "\\mathscr{y}"
},
	"𝓏": {
	math: "\\mathscr{z}"
},
	"𝓐": {
	math: "\\mathmit{A}"
},
	"𝓑": {
	math: "\\mathmit{B}"
},
	"𝓒": {
	math: "\\mathmit{C}"
},
	"𝓓": {
	math: "\\mathmit{D}"
},
	"𝓔": {
	math: "\\mathmit{E}"
},
	"𝓕": {
	math: "\\mathmit{F}"
},
	"𝓖": {
	math: "\\mathmit{G}"
},
	"𝓗": {
	math: "\\mathmit{H}"
},
	"𝓘": {
	math: "\\mathmit{I}"
},
	"𝓙": {
	math: "\\mathmit{J}"
},
	"𝓚": {
	math: "\\mathmit{K}"
},
	"𝓛": {
	math: "\\mathmit{L}"
},
	"𝓜": {
	math: "\\mathmit{M}"
},
	"𝓝": {
	math: "\\mathmit{N}"
},
	"𝓞": {
	math: "\\mathmit{O}"
},
	"𝓟": {
	math: "\\mathmit{P}"
},
	"𝓠": {
	math: "\\mathmit{Q}"
},
	"𝓡": {
	math: "\\mathmit{R}"
},
	"𝓢": {
	math: "\\mathmit{S}"
},
	"𝓣": {
	math: "\\mathmit{T}"
},
	"𝓤": {
	math: "\\mathmit{U}"
},
	"𝓥": {
	math: "\\mathmit{V}"
},
	"𝓦": {
	math: "\\mathmit{W}"
},
	"𝓧": {
	math: "\\mathmit{X}"
},
	"𝓨": {
	math: "\\mathmit{Y}"
},
	"𝓩": {
	math: "\\mathmit{Z}"
},
	"𝓪": {
	math: "\\mathmit{a}"
},
	"𝓫": {
	math: "\\mathmit{b}"
},
	"𝓬": {
	math: "\\mathmit{c}"
},
	"𝓭": {
	math: "\\mathmit{d}"
},
	"𝓮": {
	math: "\\mathmit{e}"
},
	"𝓯": {
	math: "\\mathmit{f}"
},
	"𝓰": {
	math: "\\mathmit{g}"
},
	"𝓱": {
	math: "\\mathmit{h}"
},
	"𝓲": {
	math: "\\mathmit{i}"
},
	"𝓳": {
	math: "\\mathmit{j}"
},
	"𝓴": {
	math: "\\mathmit{k}"
},
	"𝓵": {
	math: "\\mathmit{l}"
},
	"𝓶": {
	math: "\\mathmit{m}"
},
	"𝓷": {
	math: "\\mathmit{n}"
},
	"𝓸": {
	math: "\\mathmit{o}"
},
	"𝓹": {
	math: "\\mathmit{p}"
},
	"𝓺": {
	math: "\\mathmit{q}"
},
	"𝓻": {
	math: "\\mathmit{r}"
},
	"𝓼": {
	math: "\\mathmit{s}"
},
	"𝓽": {
	math: "\\mathmit{t}"
},
	"𝓾": {
	math: "\\mathmit{u}"
},
	"𝓿": {
	math: "\\mathmit{v}"
},
	"𝔀": {
	math: "\\mathmit{w}"
},
	"𝔁": {
	math: "\\mathmit{x}"
},
	"𝔂": {
	math: "\\mathmit{y}"
},
	"𝔃": {
	math: "\\mathmit{z}"
},
	"𝔄": {
	math: "\\mathfrak{A}"
},
	"𝔅": {
	math: "\\mathfrak{B}"
},
	"𝔇": {
	math: "\\mathfrak{D}"
},
	"𝔈": {
	math: "\\mathfrak{E}"
},
	"𝔉": {
	math: "\\mathfrak{F}"
},
	"𝔊": {
	math: "\\mathfrak{G}"
},
	"𝔍": {
	math: "\\mathfrak{J}"
},
	"𝔎": {
	math: "\\mathfrak{K}"
},
	"𝔏": {
	math: "\\mathfrak{L}"
},
	"𝔐": {
	math: "\\mathfrak{M}"
},
	"𝔑": {
	math: "\\mathfrak{N}"
},
	"𝔒": {
	math: "\\mathfrak{O}"
},
	"𝔓": {
	math: "\\mathfrak{P}"
},
	"𝔔": {
	math: "\\mathfrak{Q}"
},
	"𝔖": {
	math: "\\mathfrak{S}"
},
	"𝔗": {
	math: "\\mathfrak{T}"
},
	"𝔘": {
	math: "\\mathfrak{U}"
},
	"𝔙": {
	math: "\\mathfrak{V}"
},
	"𝔚": {
	math: "\\mathfrak{W}"
},
	"𝔛": {
	math: "\\mathfrak{X}"
},
	"𝔜": {
	math: "\\mathfrak{Y}"
},
	"𝔞": {
	math: "\\mathfrak{a}"
},
	"𝔟": {
	math: "\\mathfrak{b}"
},
	"𝔠": {
	math: "\\mathfrak{c}"
},
	"𝔡": {
	math: "\\mathfrak{d}"
},
	"𝔢": {
	math: "\\mathfrak{e}"
},
	"𝔣": {
	math: "\\mathfrak{f}"
},
	"𝔤": {
	math: "\\mathfrak{g}"
},
	"𝔥": {
	math: "\\mathfrak{h}"
},
	"𝔦": {
	math: "\\mathfrak{i}"
},
	"𝔧": {
	math: "\\mathfrak{j}"
},
	"𝔨": {
	math: "\\mathfrak{k}"
},
	"𝔩": {
	math: "\\mathfrak{l}"
},
	"𝔪": {
	math: "\\mathfrak{m}"
},
	"𝔫": {
	math: "\\mathfrak{n}"
},
	"𝔬": {
	math: "\\mathfrak{o}"
},
	"𝔭": {
	math: "\\mathfrak{p}"
},
	"𝔮": {
	math: "\\mathfrak{q}"
},
	"𝔯": {
	math: "\\mathfrak{r}"
},
	"𝔰": {
	math: "\\mathfrak{s}"
},
	"𝔱": {
	math: "\\mathfrak{t}"
},
	"𝔲": {
	math: "\\mathfrak{u}"
},
	"𝔳": {
	math: "\\mathfrak{v}"
},
	"𝔴": {
	math: "\\mathfrak{w}"
},
	"𝔵": {
	math: "\\mathfrak{x}"
},
	"𝔶": {
	math: "\\mathfrak{y}"
},
	"𝔷": {
	math: "\\mathfrak{z}"
},
	"𝔸": {
	math: "\\mathbb{A}"
},
	"𝔹": {
	math: "\\mathbb{B}"
},
	"𝔻": {
	math: "\\mathbb{D}"
},
	"𝔼": {
	math: "\\mathbb{E}"
},
	"𝔽": {
	math: "\\mathbb{F}"
},
	"𝔾": {
	math: "\\mathbb{G}"
},
	"𝕀": {
	math: "\\mathbb{I}"
},
	"𝕁": {
	math: "\\mathbb{J}"
},
	"𝕂": {
	math: "\\mathbb{K}"
},
	"𝕃": {
	math: "\\mathbb{L}"
},
	"𝕄": {
	math: "\\mathbb{M}"
},
	"𝕆": {
	math: "\\mathbb{O}"
},
	"𝕊": {
	math: "\\mathbb{S}"
},
	"𝕋": {
	math: "\\mathbb{T}"
},
	"𝕌": {
	math: "\\mathbb{U}"
},
	"𝕍": {
	math: "\\mathbb{V}"
},
	"𝕎": {
	math: "\\mathbb{W}"
},
	"𝕏": {
	math: "\\mathbb{X}"
},
	"𝕐": {
	math: "\\mathbb{Y}"
},
	"𝕒": {
	math: "\\mathbb{a}"
},
	"𝕓": {
	math: "\\mathbb{b}"
},
	"𝕔": {
	math: "\\mathbb{c}"
},
	"𝕕": {
	math: "\\mathbb{d}"
},
	"𝕖": {
	math: "\\mathbb{e}"
},
	"𝕗": {
	math: "\\mathbb{f}"
},
	"𝕘": {
	math: "\\mathbb{g}"
},
	"𝕙": {
	math: "\\mathbb{h}"
},
	"𝕚": {
	math: "\\mathbb{i}"
},
	"𝕛": {
	math: "\\mathbb{j}"
},
	"𝕜": {
	math: "\\mathbb{k}"
},
	"𝕝": {
	math: "\\mathbb{l}"
},
	"𝕞": {
	math: "\\mathbb{m}"
},
	"𝕟": {
	math: "\\mathbb{n}"
},
	"𝕠": {
	math: "\\mathbb{o}"
},
	"𝕡": {
	math: "\\mathbb{p}"
},
	"𝕢": {
	math: "\\mathbb{q}"
},
	"𝕣": {
	math: "\\mathbb{r}"
},
	"𝕤": {
	math: "\\mathbb{s}"
},
	"𝕥": {
	math: "\\mathbb{t}"
},
	"𝕦": {
	math: "\\mathbb{u}"
},
	"𝕧": {
	math: "\\mathbb{v}"
},
	"𝕨": {
	math: "\\mathbb{w}"
},
	"𝕩": {
	math: "\\mathbb{x}"
},
	"𝕪": {
	math: "\\mathbb{y}"
},
	"𝕫": {
	math: "\\mathbb{z}"
},
	"𝕬": {
	math: "\\mathslbb{A}"
},
	"𝕭": {
	math: "\\mathslbb{B}"
},
	"𝕮": {
	math: "\\mathslbb{C}"
},
	"𝕯": {
	math: "\\mathslbb{D}"
},
	"𝕰": {
	math: "\\mathslbb{E}"
},
	"𝕱": {
	math: "\\mathslbb{F}"
},
	"𝕲": {
	math: "\\mathslbb{G}"
},
	"𝕳": {
	math: "\\mathslbb{H}"
},
	"𝕴": {
	math: "\\mathslbb{I}"
},
	"𝕵": {
	math: "\\mathslbb{J}"
},
	"𝕶": {
	math: "\\mathslbb{K}"
},
	"𝕷": {
	math: "\\mathslbb{L}"
},
	"𝕸": {
	math: "\\mathslbb{M}"
},
	"𝕹": {
	math: "\\mathslbb{N}"
},
	"𝕺": {
	math: "\\mathslbb{O}"
},
	"𝕻": {
	math: "\\mathslbb{P}"
},
	"𝕼": {
	math: "\\mathslbb{Q}"
},
	"𝕽": {
	math: "\\mathslbb{R}"
},
	"𝕾": {
	math: "\\mathslbb{S}"
},
	"𝕿": {
	math: "\\mathslbb{T}"
},
	"𝖀": {
	math: "\\mathslbb{U}"
},
	"𝖁": {
	math: "\\mathslbb{V}"
},
	"𝖂": {
	math: "\\mathslbb{W}"
},
	"𝖃": {
	math: "\\mathslbb{X}"
},
	"𝖄": {
	math: "\\mathslbb{Y}"
},
	"𝖅": {
	math: "\\mathslbb{Z}"
},
	"𝖆": {
	math: "\\mathslbb{a}"
},
	"𝖇": {
	math: "\\mathslbb{b}"
},
	"𝖈": {
	math: "\\mathslbb{c}"
},
	"𝖉": {
	math: "\\mathslbb{d}"
},
	"𝖊": {
	math: "\\mathslbb{e}"
},
	"𝖋": {
	math: "\\mathslbb{f}"
},
	"𝖌": {
	math: "\\mathslbb{g}"
},
	"𝖍": {
	math: "\\mathslbb{h}"
},
	"𝖎": {
	math: "\\mathslbb{i}"
},
	"𝖏": {
	math: "\\mathslbb{j}"
},
	"𝖐": {
	math: "\\mathslbb{k}"
},
	"𝖑": {
	math: "\\mathslbb{l}"
},
	"𝖒": {
	math: "\\mathslbb{m}"
},
	"𝖓": {
	math: "\\mathslbb{n}"
},
	"𝖔": {
	math: "\\mathslbb{o}"
},
	"𝖕": {
	math: "\\mathslbb{p}"
},
	"𝖖": {
	math: "\\mathslbb{q}"
},
	"𝖗": {
	math: "\\mathslbb{r}"
},
	"𝖘": {
	math: "\\mathslbb{s}"
},
	"𝖙": {
	math: "\\mathslbb{t}"
},
	"𝖚": {
	math: "\\mathslbb{u}"
},
	"𝖛": {
	math: "\\mathslbb{v}"
},
	"𝖜": {
	math: "\\mathslbb{w}"
},
	"𝖝": {
	math: "\\mathslbb{x}"
},
	"𝖞": {
	math: "\\mathslbb{y}"
},
	"𝖟": {
	math: "\\mathslbb{z}"
},
	"𝖠": {
	math: "\\mathsf{A}"
},
	"𝖡": {
	math: "\\mathsf{B}"
},
	"𝖢": {
	math: "\\mathsf{C}"
},
	"𝖣": {
	math: "\\mathsf{D}"
},
	"𝖤": {
	math: "\\mathsf{E}"
},
	"𝖥": {
	math: "\\mathsf{F}"
},
	"𝖦": {
	math: "\\mathsf{G}"
},
	"𝖧": {
	math: "\\mathsf{H}"
},
	"𝖨": {
	math: "\\mathsf{I}"
},
	"𝖩": {
	math: "\\mathsf{J}"
},
	"𝖪": {
	math: "\\mathsf{K}"
},
	"𝖫": {
	math: "\\mathsf{L}"
},
	"𝖬": {
	math: "\\mathsf{M}"
},
	"𝖭": {
	math: "\\mathsf{N}"
},
	"𝖮": {
	math: "\\mathsf{O}"
},
	"𝖯": {
	math: "\\mathsf{P}"
},
	"𝖰": {
	math: "\\mathsf{Q}"
},
	"𝖱": {
	math: "\\mathsf{R}"
},
	"𝖲": {
	math: "\\mathsf{S}"
},
	"𝖳": {
	math: "\\mathsf{T}"
},
	"𝖴": {
	math: "\\mathsf{U}"
},
	"𝖵": {
	math: "\\mathsf{V}"
},
	"𝖶": {
	math: "\\mathsf{W}"
},
	"𝖷": {
	math: "\\mathsf{X}"
},
	"𝖸": {
	math: "\\mathsf{Y}"
},
	"𝖹": {
	math: "\\mathsf{Z}"
},
	"𝖺": {
	math: "\\mathsf{a}"
},
	"𝖻": {
	math: "\\mathsf{b}"
},
	"𝖼": {
	math: "\\mathsf{c}"
},
	"𝖽": {
	math: "\\mathsf{d}"
},
	"𝖾": {
	math: "\\mathsf{e}"
},
	"𝖿": {
	math: "\\mathsf{f}"
},
	"𝗀": {
	math: "\\mathsf{g}"
},
	"𝗁": {
	math: "\\mathsf{h}"
},
	"𝗂": {
	math: "\\mathsf{i}"
},
	"𝗃": {
	math: "\\mathsf{j}"
},
	"𝗄": {
	math: "\\mathsf{k}"
},
	"𝗅": {
	math: "\\mathsf{l}"
},
	"𝗆": {
	math: "\\mathsf{m}"
},
	"𝗇": {
	math: "\\mathsf{n}"
},
	"𝗈": {
	math: "\\mathsf{o}"
},
	"𝗉": {
	math: "\\mathsf{p}"
},
	"𝗊": {
	math: "\\mathsf{q}"
},
	"𝗋": {
	math: "\\mathsf{r}"
},
	"𝗌": {
	math: "\\mathsf{s}"
},
	"𝗍": {
	math: "\\mathsf{t}"
},
	"𝗎": {
	math: "\\mathsf{u}"
},
	"𝗏": {
	math: "\\mathsf{v}"
},
	"𝗐": {
	math: "\\mathsf{w}"
},
	"𝗑": {
	math: "\\mathsf{x}"
},
	"𝗒": {
	math: "\\mathsf{y}"
},
	"𝗓": {
	math: "\\mathsf{z}"
},
	"𝗔": {
	math: "\\mathsfbf{A}"
},
	"𝗕": {
	math: "\\mathsfbf{B}"
},
	"𝗖": {
	math: "\\mathsfbf{C}"
},
	"𝗗": {
	math: "\\mathsfbf{D}"
},
	"𝗘": {
	math: "\\mathsfbf{E}"
},
	"𝗙": {
	math: "\\mathsfbf{F}"
},
	"𝗚": {
	math: "\\mathsfbf{G}"
},
	"𝗛": {
	math: "\\mathsfbf{H}"
},
	"𝗜": {
	math: "\\mathsfbf{I}"
},
	"𝗝": {
	math: "\\mathsfbf{J}"
},
	"𝗞": {
	math: "\\mathsfbf{K}"
},
	"𝗟": {
	math: "\\mathsfbf{L}"
},
	"𝗠": {
	math: "\\mathsfbf{M}"
},
	"𝗡": {
	math: "\\mathsfbf{N}"
},
	"𝗢": {
	math: "\\mathsfbf{O}"
},
	"𝗣": {
	math: "\\mathsfbf{P}"
},
	"𝗤": {
	math: "\\mathsfbf{Q}"
},
	"𝗥": {
	math: "\\mathsfbf{R}"
},
	"𝗦": {
	math: "\\mathsfbf{S}"
},
	"𝗧": {
	math: "\\mathsfbf{T}"
},
	"𝗨": {
	math: "\\mathsfbf{U}"
},
	"𝗩": {
	math: "\\mathsfbf{V}"
},
	"𝗪": {
	math: "\\mathsfbf{W}"
},
	"𝗫": {
	math: "\\mathsfbf{X}"
},
	"𝗬": {
	math: "\\mathsfbf{Y}"
},
	"𝗭": {
	math: "\\mathsfbf{Z}"
},
	"𝗮": {
	math: "\\mathsfbf{a}"
},
	"𝗯": {
	math: "\\mathsfbf{b}"
},
	"𝗰": {
	math: "\\mathsfbf{c}"
},
	"𝗱": {
	math: "\\mathsfbf{d}"
},
	"𝗲": {
	math: "\\mathsfbf{e}"
},
	"𝗳": {
	math: "\\mathsfbf{f}"
},
	"𝗴": {
	math: "\\mathsfbf{g}"
},
	"𝗵": {
	math: "\\mathsfbf{h}"
},
	"𝗶": {
	math: "\\mathsfbf{i}"
},
	"𝗷": {
	math: "\\mathsfbf{j}"
},
	"𝗸": {
	math: "\\mathsfbf{k}"
},
	"𝗹": {
	math: "\\mathsfbf{l}"
},
	"𝗺": {
	math: "\\mathsfbf{m}"
},
	"𝗻": {
	math: "\\mathsfbf{n}"
},
	"𝗼": {
	math: "\\mathsfbf{o}"
},
	"𝗽": {
	math: "\\mathsfbf{p}"
},
	"𝗾": {
	math: "\\mathsfbf{q}"
},
	"𝗿": {
	math: "\\mathsfbf{r}"
},
	"𝘀": {
	math: "\\mathsfbf{s}"
},
	"𝘁": {
	math: "\\mathsfbf{t}"
},
	"𝘂": {
	math: "\\mathsfbf{u}"
},
	"𝘃": {
	math: "\\mathsfbf{v}"
},
	"𝘄": {
	math: "\\mathsfbf{w}"
},
	"𝘅": {
	math: "\\mathsfbf{x}"
},
	"𝘆": {
	math: "\\mathsfbf{y}"
},
	"𝘇": {
	math: "\\mathsfbf{z}"
},
	"𝘈": {
	math: "\\mathsfsl{A}"
},
	"𝘉": {
	math: "\\mathsfsl{B}"
},
	"𝘊": {
	math: "\\mathsfsl{C}"
},
	"𝘋": {
	math: "\\mathsfsl{D}"
},
	"𝘌": {
	math: "\\mathsfsl{E}"
},
	"𝘍": {
	math: "\\mathsfsl{F}"
},
	"𝘎": {
	math: "\\mathsfsl{G}"
},
	"𝘏": {
	math: "\\mathsfsl{H}"
},
	"𝘐": {
	math: "\\mathsfsl{I}"
},
	"𝘑": {
	math: "\\mathsfsl{J}"
},
	"𝘒": {
	math: "\\mathsfsl{K}"
},
	"𝘓": {
	math: "\\mathsfsl{L}"
},
	"𝘔": {
	math: "\\mathsfsl{M}"
},
	"𝘕": {
	math: "\\mathsfsl{N}"
},
	"𝘖": {
	math: "\\mathsfsl{O}"
},
	"𝘗": {
	math: "\\mathsfsl{P}"
},
	"𝘘": {
	math: "\\mathsfsl{Q}"
},
	"𝘙": {
	math: "\\mathsfsl{R}"
},
	"𝘚": {
	math: "\\mathsfsl{S}"
},
	"𝘛": {
	math: "\\mathsfsl{T}"
},
	"𝘜": {
	math: "\\mathsfsl{U}"
},
	"𝘝": {
	math: "\\mathsfsl{V}"
},
	"𝘞": {
	math: "\\mathsfsl{W}"
},
	"𝘟": {
	math: "\\mathsfsl{X}"
},
	"𝘠": {
	math: "\\mathsfsl{Y}"
},
	"𝘡": {
	math: "\\mathsfsl{Z}"
},
	"𝘢": {
	math: "\\mathsfsl{a}"
},
	"𝘣": {
	math: "\\mathsfsl{b}"
},
	"𝘤": {
	math: "\\mathsfsl{c}"
},
	"𝘥": {
	math: "\\mathsfsl{d}"
},
	"𝘦": {
	math: "\\mathsfsl{e}"
},
	"𝘧": {
	math: "\\mathsfsl{f}"
},
	"𝘨": {
	math: "\\mathsfsl{g}"
},
	"𝘩": {
	math: "\\mathsfsl{h}"
},
	"𝘪": {
	math: "\\mathsfsl{i}"
},
	"𝘫": {
	math: "\\mathsfsl{j}"
},
	"𝘬": {
	math: "\\mathsfsl{k}"
},
	"𝘭": {
	math: "\\mathsfsl{l}"
},
	"𝘮": {
	math: "\\mathsfsl{m}"
},
	"𝘯": {
	math: "\\mathsfsl{n}"
},
	"𝘰": {
	math: "\\mathsfsl{o}"
},
	"𝘱": {
	math: "\\mathsfsl{p}"
},
	"𝘲": {
	math: "\\mathsfsl{q}"
},
	"𝘳": {
	math: "\\mathsfsl{r}"
},
	"𝘴": {
	math: "\\mathsfsl{s}"
},
	"𝘵": {
	math: "\\mathsfsl{t}"
},
	"𝘶": {
	math: "\\mathsfsl{u}"
},
	"𝘷": {
	math: "\\mathsfsl{v}"
},
	"𝘸": {
	math: "\\mathsfsl{w}"
},
	"𝘹": {
	math: "\\mathsfsl{x}"
},
	"𝘺": {
	math: "\\mathsfsl{y}"
},
	"𝘻": {
	math: "\\mathsfsl{z}"
},
	"𝘼": {
	math: "\\mathsfbfsl{A}"
},
	"𝘽": {
	math: "\\mathsfbfsl{B}"
},
	"𝘾": {
	math: "\\mathsfbfsl{C}"
},
	"𝘿": {
	math: "\\mathsfbfsl{D}"
},
	"𝙀": {
	math: "\\mathsfbfsl{E}"
},
	"𝙁": {
	math: "\\mathsfbfsl{F}"
},
	"𝙂": {
	math: "\\mathsfbfsl{G}"
},
	"𝙃": {
	math: "\\mathsfbfsl{H}"
},
	"𝙄": {
	math: "\\mathsfbfsl{I}"
},
	"𝙅": {
	math: "\\mathsfbfsl{J}"
},
	"𝙆": {
	math: "\\mathsfbfsl{K}"
},
	"𝙇": {
	math: "\\mathsfbfsl{L}"
},
	"𝙈": {
	math: "\\mathsfbfsl{M}"
},
	"𝙉": {
	math: "\\mathsfbfsl{N}"
},
	"𝙊": {
	math: "\\mathsfbfsl{O}"
},
	"𝙋": {
	math: "\\mathsfbfsl{P}"
},
	"𝙌": {
	math: "\\mathsfbfsl{Q}"
},
	"𝙍": {
	math: "\\mathsfbfsl{R}"
},
	"𝙎": {
	math: "\\mathsfbfsl{S}"
},
	"𝙏": {
	math: "\\mathsfbfsl{T}"
},
	"𝙐": {
	math: "\\mathsfbfsl{U}"
},
	"𝙑": {
	math: "\\mathsfbfsl{V}"
},
	"𝙒": {
	math: "\\mathsfbfsl{W}"
},
	"𝙓": {
	math: "\\mathsfbfsl{X}"
},
	"𝙔": {
	math: "\\mathsfbfsl{Y}"
},
	"𝙕": {
	math: "\\mathsfbfsl{Z}"
},
	"𝙖": {
	math: "\\mathsfbfsl{a}"
},
	"𝙗": {
	math: "\\mathsfbfsl{b}"
},
	"𝙘": {
	math: "\\mathsfbfsl{c}"
},
	"𝙙": {
	math: "\\mathsfbfsl{d}"
},
	"𝙚": {
	math: "\\mathsfbfsl{e}"
},
	"𝙛": {
	math: "\\mathsfbfsl{f}"
},
	"𝙜": {
	math: "\\mathsfbfsl{g}"
},
	"𝙝": {
	math: "\\mathsfbfsl{h}"
},
	"𝙞": {
	math: "\\mathsfbfsl{i}"
},
	"𝙟": {
	math: "\\mathsfbfsl{j}"
},
	"𝙠": {
	math: "\\mathsfbfsl{k}"
},
	"𝙡": {
	math: "\\mathsfbfsl{l}"
},
	"𝙢": {
	math: "\\mathsfbfsl{m}"
},
	"𝙣": {
	math: "\\mathsfbfsl{n}"
},
	"𝙤": {
	math: "\\mathsfbfsl{o}"
},
	"𝙥": {
	math: "\\mathsfbfsl{p}"
},
	"𝙦": {
	math: "\\mathsfbfsl{q}"
},
	"𝙧": {
	math: "\\mathsfbfsl{r}"
},
	"𝙨": {
	math: "\\mathsfbfsl{s}"
},
	"𝙩": {
	math: "\\mathsfbfsl{t}"
},
	"𝙪": {
	math: "\\mathsfbfsl{u}"
},
	"𝙫": {
	math: "\\mathsfbfsl{v}"
},
	"𝙬": {
	math: "\\mathsfbfsl{w}"
},
	"𝙭": {
	math: "\\mathsfbfsl{x}"
},
	"𝙮": {
	math: "\\mathsfbfsl{y}"
},
	"𝙯": {
	math: "\\mathsfbfsl{z}"
},
	"𝙰": {
	math: "\\mathtt{A}"
},
	"𝙱": {
	math: "\\mathtt{B}"
},
	"𝙲": {
	math: "\\mathtt{C}"
},
	"𝙳": {
	math: "\\mathtt{D}"
},
	"𝙴": {
	math: "\\mathtt{E}"
},
	"𝙵": {
	math: "\\mathtt{F}"
},
	"𝙶": {
	math: "\\mathtt{G}"
},
	"𝙷": {
	math: "\\mathtt{H}"
},
	"𝙸": {
	math: "\\mathtt{I}"
},
	"𝙹": {
	math: "\\mathtt{J}"
},
	"𝙺": {
	math: "\\mathtt{K}"
},
	"𝙻": {
	math: "\\mathtt{L}"
},
	"𝙼": {
	math: "\\mathtt{M}"
},
	"𝙽": {
	math: "\\mathtt{N}"
},
	"𝙾": {
	math: "\\mathtt{O}"
},
	"𝙿": {
	math: "\\mathtt{P}"
},
	"𝚀": {
	math: "\\mathtt{Q}"
},
	"𝚁": {
	math: "\\mathtt{R}"
},
	"𝚂": {
	math: "\\mathtt{S}"
},
	"𝚃": {
	math: "\\mathtt{T}"
},
	"𝚄": {
	math: "\\mathtt{U}"
},
	"𝚅": {
	math: "\\mathtt{V}"
},
	"𝚆": {
	math: "\\mathtt{W}"
},
	"𝚇": {
	math: "\\mathtt{X}"
},
	"𝚈": {
	math: "\\mathtt{Y}"
},
	"𝚉": {
	math: "\\mathtt{Z}"
},
	"𝚊": {
	math: "\\mathtt{a}"
},
	"𝚋": {
	math: "\\mathtt{b}"
},
	"𝚌": {
	math: "\\mathtt{c}"
},
	"𝚍": {
	math: "\\mathtt{d}"
},
	"𝚎": {
	math: "\\mathtt{e}"
},
	"𝚏": {
	math: "\\mathtt{f}"
},
	"𝚐": {
	math: "\\mathtt{g}"
},
	"𝚑": {
	math: "\\mathtt{h}"
},
	"𝚒": {
	math: "\\mathtt{i}"
},
	"𝚓": {
	math: "\\mathtt{j}"
},
	"𝚔": {
	math: "\\mathtt{k}"
},
	"𝚕": {
	math: "\\mathtt{l}"
},
	"𝚖": {
	math: "\\mathtt{m}"
},
	"𝚗": {
	math: "\\mathtt{n}"
},
	"𝚘": {
	math: "\\mathtt{o}"
},
	"𝚙": {
	math: "\\mathtt{p}"
},
	"𝚚": {
	math: "\\mathtt{q}"
},
	"𝚛": {
	math: "\\mathtt{r}"
},
	"𝚜": {
	math: "\\mathtt{s}"
},
	"𝚝": {
	math: "\\mathtt{t}"
},
	"𝚞": {
	math: "\\mathtt{u}"
},
	"𝚟": {
	math: "\\mathtt{v}"
},
	"𝚠": {
	math: "\\mathtt{w}"
},
	"𝚡": {
	math: "\\mathtt{x}"
},
	"𝚢": {
	math: "\\mathtt{y}"
},
	"𝚣": {
	math: "\\mathtt{z}"
},
	"𝚤": {
	math: "\\imath"
},
	"𝚥": {
	math: "\\jmath"
},
	"𝚨": {
	math: "\\mathbf{A}"
},
	"𝚩": {
	math: "\\mathbf{B}"
},
	"𝚪": {
	math: "\\mathbf{\\Gamma}"
},
	"𝚫": {
	math: "\\mathbf{\\Delta}"
},
	"𝚬": {
	math: "\\mathbf{E}"
},
	"𝚭": {
	math: "\\mathbf{Z}"
},
	"𝚮": {
	math: "\\mathbf{H}"
},
	"𝚯": {
	math: "\\mathbf{\\Theta}"
},
	"𝚰": {
	math: "\\mathbf{I}"
},
	"𝚱": {
	math: "\\mathbf{K}"
},
	"𝚲": {
	math: "\\mathbf{\\Lambda}"
},
	"𝚳": {
	math: "M"
},
	"𝚴": {
	math: "N"
},
	"𝚵": {
	math: "\\mathbf{\\Xi}"
},
	"𝚶": {
	math: "O"
},
	"𝚷": {
	math: "\\mathbf{\\Pi}"
},
	"𝚸": {
	math: "\\mathbf{P}"
},
	"𝚹": {
	math: "\\mathbf{\\vartheta}"
},
	"𝚺": {
	math: "\\mathbf{\\Sigma}"
},
	"𝚻": {
	math: "\\mathbf{T}"
},
	"𝚼": {
	math: "\\mathbf{\\Upsilon}"
},
	"𝚽": {
	math: "\\mathbf{\\Phi}"
},
	"𝚾": {
	math: "\\mathbf{X}"
},
	"𝚿": {
	math: "\\mathbf{\\Psi}"
},
	"𝛀": {
	math: "\\mathbf{\\Omega}"
},
	"𝛁": {
	math: "\\mathbf{\\nabla}"
},
	"𝛂": {
	math: "\\mathbf{\\alpha}"
},
	"𝛃": {
	math: "\\mathbf{\\beta}"
},
	"𝛄": {
	math: "\\mathbf{\\gamma}"
},
	"𝛅": {
	math: "\\mathbf{\\delta}"
},
	"𝛆": {
	math: "\\mathbf{\\epsilon}"
},
	"𝛇": {
	math: "\\mathbf{\\zeta}"
},
	"𝛈": {
	math: "\\mathbf{\\eta}"
},
	"𝛉": {
	math: "\\mathbf{\\theta}"
},
	"𝛊": {
	math: "\\mathbf{I}"
},
	"𝛋": {
	math: "\\mathbf{K}"
},
	"𝛌": {
	math: "\\mathbf{\\lambda}"
},
	"𝛍": {
	math: "M"
},
	"𝛎": {
	math: "N"
},
	"𝛏": {
	math: "\\mathbf{\\xi}"
},
	"𝛐": {
	math: "O"
},
	"𝛑": {
	math: "\\mathbf{\\pi}"
},
	"𝛒": {
	math: "\\mathbf{P}"
},
	"𝛓": {
	math: "\\mathbf{\\varsigma}"
},
	"𝛔": {
	math: "\\mathbf{\\sigma}"
},
	"𝛕": {
	math: "\\mathbf{T}"
},
	"𝛖": {
	math: "\\mathbf{\\upsilon}"
},
	"𝛗": {
	math: "\\mathbf{\\phi}"
},
	"𝛘": {
	math: "\\mathbf{X}"
},
	"𝛙": {
	math: "\\mathbf{\\psi}"
},
	"𝛚": {
	math: "\\mathbf{\\omega}"
},
	"𝛛": {
	math: "\\partial"
},
	"𝛜": {
	math: "\\in"
},
	"𝛝": {
	math: "\\mathbf{\\vartheta}"
},
	"𝛞": {
	math: "\\mathbf{\\varkappa}"
},
	"𝛟": {
	math: "\\mathbf{\\phi}"
},
	"𝛠": {
	math: "\\mathbf{\\varrho}"
},
	"𝛡": {
	math: "\\mathbf{\\varpi}"
},
	"𝛢": {
	math: "\\mathsl{A}"
},
	"𝛣": {
	math: "\\mathsl{B}"
},
	"𝛤": {
	math: "\\mathsl{\\Gamma}"
},
	"𝛥": {
	math: "\\mathsl{\\Delta}"
},
	"𝛦": {
	math: "\\mathsl{E}"
},
	"𝛧": {
	math: "\\mathsl{Z}"
},
	"𝛨": {
	math: "\\mathsl{H}"
},
	"𝛩": {
	math: "\\mathsl{\\Theta}"
},
	"𝛪": {
	math: "\\mathsl{I}"
},
	"𝛫": {
	math: "\\mathsl{K}"
},
	"𝛬": {
	math: "\\mathsl{\\Lambda}"
},
	"𝛭": {
	math: "M"
},
	"𝛮": {
	math: "N"
},
	"𝛯": {
	math: "\\mathsl{\\Xi}"
},
	"𝛰": {
	math: "O"
},
	"𝛱": {
	math: "\\mathsl{\\Pi}"
},
	"𝛲": {
	math: "\\mathsl{P}"
},
	"𝛳": {
	math: "\\mathsl{\\Theta}"
},
	"𝛴": {
	math: "\\mathsl{\\Sigma}"
},
	"𝛵": {
	math: "\\mathsl{T}"
},
	"𝛶": {
	math: "\\mathsl{\\Upsilon}"
},
	"𝛷": {
	math: "\\mathsl{\\Phi}"
},
	"𝛸": {
	math: "\\mathsl{X}"
},
	"𝛹": {
	math: "\\mathsl{\\Psi}"
},
	"𝛺": {
	math: "\\mathsl{\\Omega}"
},
	"𝛻": {
	math: "\\mathsl{\\nabla}"
},
	"𝛼": {
	math: "\\mathsl{A}"
},
	"𝛽": {
	math: "\\mathsl{B}"
},
	"𝛾": {
	math: "\\mathsl{\\gamma}"
},
	"𝛿": {
	math: "\\mathsl{\\delta}"
},
	"𝜀": {
	math: "\\mathsl{E}"
},
	"𝜁": {
	math: "\\mathsl{Z}"
},
	"𝜂": {
	math: "\\mathsl{H}"
},
	"𝜃": {
	math: "\\mathsl{\\theta}"
},
	"𝜄": {
	math: "\\mathsl{I}"
},
	"𝜅": {
	math: "\\mathsl{K}"
},
	"𝜆": {
	math: "\\mathsl{\\lambda}"
},
	"𝜇": {
	math: "\\mu"
},
	"𝜈": {
	math: "\\nu"
},
	"𝜉": {
	math: "\\mathsl{\\xi}"
},
	"𝜊": {
	math: "o"
},
	"𝜋": {
	math: "\\mathsl{\\pi}"
},
	"𝜌": {
	math: "\\mathsl{P}"
},
	"𝜍": {
	math: "\\mathsl{\\varsigma}"
},
	"𝜎": {
	math: "\\mathsl{\\sigma}"
},
	"𝜏": {
	math: "\\mathsl{T}"
},
	"𝜐": {
	math: "\\mathsl{\\upsilon}"
},
	"𝜑": {
	math: "\\mathsl{\\varphi}"
},
	"𝜒": {
	math: "\\mathsl{X}"
},
	"𝜓": {
	math: "\\mathsl{\\psi}"
},
	"𝜔": {
	math: "\\mathsl{\\omega}"
},
	"𝜕": {
	math: "\\partial"
},
	"𝜖": {
	math: "\\in"
},
	"𝜗": {
	math: "\\mathsl{\\vartheta}"
},
	"𝜘": {
	math: "\\mathsl{\\varkappa}"
},
	"𝜙": {
	math: "\\mathsl{\\phi}"
},
	"𝜚": {
	math: "\\mathsl{\\varrho}"
},
	"𝜛": {
	math: "\\mathsl{\\varpi}"
},
	"𝜜": {
	math: "\\mathbit{A}"
},
	"𝜝": {
	math: "\\mathbit{B}"
},
	"𝜞": {
	math: "\\mathbit{\\Gamma}"
},
	"𝜟": {
	math: "\\mathbit{\\Delta}"
},
	"𝜠": {
	math: "\\mathbit{E}"
},
	"𝜡": {
	math: "\\mathbit{Z}"
},
	"𝜢": {
	math: "\\mathbit{H}"
},
	"𝜣": {
	math: "\\mathbit{\\Theta}"
},
	"𝜤": {
	math: "\\mathbit{I}"
},
	"𝜥": {
	math: "\\mathbit{K}"
},
	"𝜦": {
	math: "\\mathbit{\\Lambda}"
},
	"𝜧": {
	math: "M"
},
	"𝜨": {
	math: "N"
},
	"𝜩": {
	math: "\\mathbit{\\Xi}"
},
	"𝜪": {
	math: "O"
},
	"𝜫": {
	math: "\\mathbit{\\Pi}"
},
	"𝜬": {
	math: "\\mathbit{P}"
},
	"𝜭": {
	math: "\\mathbit{O}"
},
	"𝜮": {
	math: "\\mathbit{\\Sigma}"
},
	"𝜯": {
	math: "\\mathbit{T}"
},
	"𝜰": {
	math: "\\mathbit{\\Upsilon}"
},
	"𝜱": {
	math: "\\mathbit{\\Phi}"
},
	"𝜲": {
	math: "\\mathbit{X}"
},
	"𝜳": {
	math: "\\mathbit{\\Psi}"
},
	"𝜴": {
	math: "\\mathbit{\\Omega}"
},
	"𝜵": {
	math: "\\mathbit{\\nabla}"
},
	"𝜶": {
	math: "\\mathbit{\\alpha}"
},
	"𝜷": {
	math: "\\mathbit{\\beta}"
},
	"𝜸": {
	math: "\\mathbit{\\gamma}"
},
	"𝜹": {
	math: "\\mathbit{\\delta}"
},
	"𝜺": {
	math: "\\mathbit{\\epsilon}"
},
	"𝜻": {
	math: "\\mathbit{\\zeta}"
},
	"𝜼": {
	math: "\\mathbit{\\eta}"
},
	"𝜽": {
	math: "\\mathbit{\\theta}"
},
	"𝜾": {
	math: "\\mathbit{\\imath}"
},
	"𝜿": {
	math: "\\mathbit{\\kappa}"
},
	"𝝀": {
	math: "\\mathbit{\\lambda}"
},
	"𝝁": {
	math: "\\mu"
},
	"𝝂": {
	math: "N"
},
	"𝝃": {
	math: "\\mathbit{\\xi}"
},
	"𝝄": {
	math: "O"
},
	"𝝅": {
	math: "\\mathbit{\\pi}"
},
	"𝝆": {
	math: "\\mathbit{\\rho}"
},
	"𝝇": {
	math: "\\mathbit{\\varsigma}"
},
	"𝝈": {
	math: "\\mathbit{\\sigma}"
},
	"𝝉": {
	math: "\\mathbit{\\tau}"
},
	"𝝊": {
	math: "\\mathbit{\\upsilon}"
},
	"𝝋": {
	math: "\\mathbit{\\varphi}"
},
	"𝝌": {
	math: "\\mathbit{\\chi}"
},
	"𝝍": {
	math: "\\mathbit{\\psi}"
},
	"𝝎": {
	math: "\\mathbit{\\omega}"
},
	"𝝏": {
	math: "\\partial"
},
	"𝝐": {
	math: "\\in"
},
	"𝝑": {
	math: "\\mathbit{\\vartheta}"
},
	"𝝒": {
	math: "\\mathbit{\\varkappa}"
},
	"𝝓": {
	math: "\\mathbit{\\phi}"
},
	"𝝔": {
	math: "\\mathbit{\\varrho}"
},
	"𝝕": {
	math: "\\mathbit{\\varpi}"
},
	"𝝖": {
	math: "\\mathsfbf{A}"
},
	"𝝗": {
	math: "\\mathsfbf{B}"
},
	"𝝘": {
	math: "\\mathsfbf{\\Gamma}"
},
	"𝝙": {
	math: "\\mathsfbf{\\Delta}"
},
	"𝝚": {
	math: "\\mathsfbf{E}"
},
	"𝝛": {
	math: "\\mathsfbf{Z}"
},
	"𝝜": {
	math: "\\mathsfbf{H}"
},
	"𝝝": {
	math: "\\mathsfbf{\\Theta}"
},
	"𝝞": {
	math: "\\mathsfbf{I}"
},
	"𝝟": {
	math: "\\mathsfbf{K}"
},
	"𝝠": {
	math: "\\mathsfbf{\\Lambda}"
},
	"𝝡": {
	math: "M"
},
	"𝝢": {
	math: "N"
},
	"𝝣": {
	math: "\\mathsfbf{\\Xi}"
},
	"𝝤": {
	math: "O"
},
	"𝝥": {
	math: "\\mathsfbf{\\Pi}"
},
	"𝝦": {
	math: "\\mathsfbf{P}"
},
	"𝝧": {
	math: "\\mathsfbf{\\Theta}"
},
	"𝝨": {
	math: "\\mathsfbf{\\Sigma}"
},
	"𝝩": {
	math: "\\mathsfbf{T}"
},
	"𝝪": {
	math: "\\mathsfbf{\\Upsilon}"
},
	"𝝫": {
	math: "\\mathsfbf{\\Phi}"
},
	"𝝬": {
	math: "\\mathsfbf{X}"
},
	"𝝭": {
	math: "\\mathsfbf{\\Psi}"
},
	"𝝮": {
	math: "\\mathsfbf{\\Omega}"
},
	"𝝯": {
	math: "\\mathsfbf{\\nabla}"
},
	"𝝰": {
	math: "\\mathsfbf{\\alpha}"
},
	"𝝱": {
	math: "\\mathsfbf{\\beta}"
},
	"𝝲": {
	math: "\\mathsfbf{\\gamma}"
},
	"𝝳": {
	math: "\\mathsfbf{\\delta}"
},
	"𝝴": {
	math: "\\mathsfbf{\\varepsilon}"
},
	"𝝵": {
	math: "\\mathsfbf{\\zeta}"
},
	"𝝶": {
	math: "\\mathsfbf{\\eta}"
},
	"𝝷": {
	math: "\\mathsfbf{\\theta}"
},
	"𝝸": {
	math: "\\mathsfbf{\\imath}"
},
	"𝝹": {
	math: "\\mathsfbf{\\kappa}"
},
	"𝝺": {
	math: "\\mathsfbf{\\lambda}"
},
	"𝝻": {
	math: "\\mu"
},
	"𝝼": {
	math: "\\nu"
},
	"𝝽": {
	math: "\\mathsfbf{\\xi}"
},
	"𝝾": {
	math: "o"
},
	"𝝿": {
	math: "\\mathsfbf{\\pi}"
},
	"𝞀": {
	math: "\\mathsfbf{\\rho}"
},
	"𝞁": {
	math: "\\mathsfbf{\\varsigma}"
},
	"𝞂": {
	math: "\\mathsfbf{\\sigma}"
},
	"𝞃": {
	math: "\\mathsfbf{\\tau}"
},
	"𝞄": {
	math: "\\mathsfbf{\\upsilon}"
},
	"𝞅": {
	math: "\\mathsfbf{\\varphi}"
},
	"𝞆": {
	math: "\\mathsfbf{\\chi}"
},
	"𝞇": {
	math: "\\mathsfbf{\\psi}"
},
	"𝞈": {
	math: "\\mathsfbf{\\omega}"
},
	"𝞉": {
	math: "\\partial"
},
	"𝞊": {
	math: "\\in"
},
	"𝞋": {
	math: "\\mathsfbf{\\vartheta}"
},
	"𝞌": {
	math: "\\mathsfbf{\\varkappa}"
},
	"𝞍": {
	math: "\\mathsfbf{\\phi}"
},
	"𝞎": {
	math: "\\mathsfbf{\\varrho}"
},
	"𝞏": {
	math: "\\mathsfbf{\\varpi}"
},
	"𝞐": {
	math: "\\mathsfbfsl{A}"
},
	"𝞑": {
	math: "\\mathsfbfsl{B}"
},
	"𝞒": {
	math: "\\mathsfbfsl{\\Gamma}"
},
	"𝞓": {
	math: "\\mathsfbfsl{\\Delta}"
},
	"𝞔": {
	math: "\\mathsfbfsl{E}"
},
	"𝞕": {
	math: "\\mathsfbfsl{Z}"
},
	"𝞖": {
	math: "\\mathsfbfsl{H}"
},
	"𝞗": {
	math: "\\mathsfbfsl{\\Theta}"
},
	"𝞘": {
	math: "\\mathsfbfsl{I}"
},
	"𝞙": {
	math: "\\mathsfbfsl{K}"
},
	"𝞚": {
	math: "\\mathsfbfsl{\\Lambda}"
},
	"𝞛": {
	math: "\\mathsfbfsl{M}"
},
	"𝞜": {
	math: "\\mathsfbfsl{N}"
},
	"𝞝": {
	math: "\\mathsfbfsl{\\Xi}"
},
	"𝞞": {
	math: "\\mathsfbfsl{O}"
},
	"𝞟": {
	math: "\\mathsfbfsl{\\Pi}"
},
	"𝞠": {
	math: "\\mathsfbfsl{P}"
},
	"𝞡": {
	math: "\\mathsfbfsl{\\Theta}"
},
	"𝞢": {
	math: "\\mathsfbfsl{\\Sigma}"
},
	"𝞣": {
	math: "\\mathsfbfsl{T}"
},
	"𝞤": {
	math: "\\mathsfbfsl{\\Upsilon}"
},
	"𝞥": {
	math: "\\mathsfbfsl{\\Phi}"
},
	"𝞦": {
	math: "\\mathsfbfsl{X}"
},
	"𝞧": {
	math: "\\mathsfbfsl{\\Psi}"
},
	"𝞨": {
	math: "\\mathsfbfsl{\\Omega}"
},
	"𝞩": {
	math: "\\mathsfbfsl{\\nabla}"
},
	"𝞪": {
	math: "\\mathsfbfsl{\\alpha}"
},
	"𝞫": {
	math: "\\mathsfbfsl{\\beta}"
},
	"𝞬": {
	math: "\\mathsfbfsl{\\gamma}"
},
	"𝞭": {
	math: "\\mathsfbfsl{\\delta}"
},
	"𝞮": {
	math: "\\mathsfbfsl{\\varepsilon}"
},
	"𝞯": {
	math: "\\mathsfbfsl{\\zeta}"
},
	"𝞰": {
	math: "\\mathsfbfsl{\\eta}"
},
	"𝞱": {
	math: "\\mathsfbfsl{\\theta}"
},
	"𝞲": {
	math: "\\mathsfbfsl{\\imath}"
},
	"𝞳": {
	math: "\\mathsfbfsl{\\kappa}"
},
	"𝞴": {
	math: "\\mathsfbfsl{\\lambda}"
},
	"𝞵": {
	math: "\\mu"
},
	"𝞶": {
	math: "\\nu"
},
	"𝞷": {
	math: "\\mathsfbfsl{\\xi}"
},
	"𝞸": {
	math: "o"
},
	"𝞹": {
	math: "\\mathsfbfsl{\\pi}"
},
	"𝞺": {
	math: "\\mathsfbfsl{\\rho}"
},
	"𝞻": {
	math: "\\mathsfbfsl{\\varsigma}"
},
	"𝞼": {
	math: "\\mathsfbfsl{\\sigma}"
},
	"𝞽": {
	math: "\\mathsfbfsl{\\tau}"
},
	"𝞾": {
	math: "\\mathsfbfsl{\\upsilon}"
},
	"𝞿": {
	math: "\\mathsfbfsl{\\varphi}"
},
	"𝟀": {
	math: "\\mathsfbfsl{\\chi}"
},
	"𝟁": {
	math: "\\mathsfbfsl{\\psi}"
},
	"𝟂": {
	math: "\\mathsfbfsl{\\omega}"
},
	"𝟃": {
	math: "\\partial"
},
	"𝟄": {
	math: "\\in"
},
	"𝟅": {
	math: "\\mathsfbfsl{\\vartheta}"
},
	"𝟆": {
	math: "\\mathsfbfsl{\\varkappa}"
},
	"𝟇": {
	math: "\\mathsfbfsl{\\phi}"
},
	"𝟈": {
	math: "\\mathsfbfsl{\\varrho}"
},
	"𝟉": {
	math: "\\mathsfbfsl{\\varpi}"
},
	"𝟊": {
	math: "\\mbfDigamma"
},
	"𝟋": {
	math: "\\mbfdigamma"
},
	"𝟎": {
	math: "\\mathbf{0}"
},
	"𝟏": {
	math: "\\mathbf{1}"
},
	"𝟐": {
	math: "\\mathbf{2}"
},
	"𝟑": {
	math: "\\mathbf{3}"
},
	"𝟒": {
	math: "\\mathbf{4}"
},
	"𝟓": {
	math: "\\mathbf{5}"
},
	"𝟔": {
	math: "\\mathbf{6}"
},
	"𝟕": {
	math: "\\mathbf{7}"
},
	"𝟖": {
	math: "\\mathbf{8}"
},
	"𝟗": {
	math: "\\mathbf{9}"
},
	"𝟘": {
	math: "\\mathbb{0}"
},
	"𝟙": {
	math: "\\mathbb{1}"
},
	"𝟚": {
	math: "\\mathbb{2}"
},
	"𝟛": {
	math: "\\mathbb{3}"
},
	"𝟜": {
	math: "\\mathbb{4}"
},
	"𝟝": {
	math: "\\mathbb{5}"
},
	"𝟞": {
	math: "\\mathbb{6}"
},
	"𝟟": {
	math: "\\mathbb{7}"
},
	"𝟠": {
	math: "\\mathbb{8}"
},
	"𝟡": {
	math: "\\mathbb{9}"
},
	"𝟢": {
	math: "\\mathsf{0}"
},
	"𝟣": {
	math: "\\mathsf{1}"
},
	"𝟤": {
	math: "\\mathsf{2}"
},
	"𝟥": {
	math: "\\mathsf{3}"
},
	"𝟦": {
	math: "\\mathsf{4}"
},
	"𝟧": {
	math: "\\mathsf{5}"
},
	"𝟨": {
	math: "\\mathsf{6}"
},
	"𝟩": {
	math: "\\mathsf{7}"
},
	"𝟪": {
	math: "\\mathsf{8}"
},
	"𝟫": {
	math: "\\mathsf{9}"
},
	"𝟬": {
	math: "\\mathsfbf{0}"
},
	"𝟭": {
	math: "\\mathsfbf{1}"
},
	"𝟮": {
	math: "\\mathsfbf{2}"
},
	"𝟯": {
	math: "\\mathsfbf{3}"
},
	"𝟰": {
	math: "\\mathsfbf{4}"
},
	"𝟱": {
	math: "\\mathsfbf{5}"
},
	"𝟲": {
	math: "\\mathsfbf{6}"
},
	"𝟳": {
	math: "\\mathsfbf{7}"
},
	"𝟴": {
	math: "\\mathsfbf{8}"
},
	"𝟵": {
	math: "\\mathsfbf{9}"
},
	"𝟶": {
	math: "\\mathtt{0}"
},
	"𝟷": {
	math: "\\mathtt{1}"
},
	"𝟸": {
	math: "\\mathtt{2}"
},
	"𝟹": {
	math: "\\mathtt{3}"
},
	"𝟺": {
	math: "\\mathtt{4}"
},
	"𝟻": {
	math: "\\mathtt{5}"
},
	"𝟼": {
	math: "\\mathtt{6}"
},
	"𝟽": {
	math: "\\mathtt{7}"
},
	"𝟾": {
	math: "\\mathtt{8}"
},
	"𝟿": {
	math: "\\mathtt{9}"
}
};

var $$1 = {
	math: "\\$",
	text: "\\$"
};
var _$1 = {
	math: "\\_",
	text: "\\_"
};
var require$$1 = {
	"#": {
	math: "\\#",
	text: "\\#"
},
	$: $$1,
	"%": {
	math: "\\%",
	text: "\\%"
},
	"&": {
	math: "\\&",
	text: "\\&"
},
	"/​": {
	text: "{\\slash}"
},
	"<": {
	math: "<"
},
	">": {
	math: ">"
},
	"\\": {
	math: "\\backslash",
	text: "{\\textbackslash}"
},
	"^": {
	math: "\\sphat",
	text: "\\^"
},
	_: _$1,
	"i︠a︡": {
	text: "\\t{ia}"
},
	"{": {
	math: "\\lbrace",
	text: "\\{"
},
	"}": {
	math: "\\rbrace",
	text: "\\}"
},
	"~": {
	math: "\\sptilde",
	text: "{\\textasciitilde}"
},
	" ": {
	math: "~",
	space: true,
	text: "~"
},
	"¡": {
	text: "{\\textexclamdown}"
},
	"¢": {
	math: "\\cent",
	text: "{\\textcent}",
	textpackages: [
		"textcomp"
	]
},
	"£": {
	math: "\\pounds",
	text: "{\\textsterling}",
	textpackages: [
		"textcomp"
	]
},
	"¤": {
	text: "{\\textcurrency}",
	textpackages: [
		"textcomp"
	]
},
	"¥": {
	math: "\\yen",
	text: "{\\textyen}",
	textpackages: [
		"textcomp"
	]
},
	"¦": {
	text: "{\\textbrokenbar}",
	textpackages: [
		"textcomp"
	]
},
	"§": {
	text: "{\\textsection}",
	textpackages: [
		"textcomp"
	]
},
	"¨": {
	math: "\\spddot",
	text: "{\\textasciidieresis}"
},
	"©": {
	text: "{\\textcopyright}",
	textpackages: [
		"textcomp"
	]
},
	"ª": {
	text: "{\\textordfeminine}",
	textpackages: [
		"textcomp"
	]
},
	"«": {
	text: "{\\guillemotleft}"
},
	"¬": {
	math: "\\lnot"
},
	"­": {
	math: "\\-",
	text: "\\-"
},
	"®": {
	math: "\\circledR",
	text: "{\\textregistered}",
	textpackages: [
		"textcomp"
	]
},
	"¯": {
	text: "{\\textasciimacron}"
},
	"°": {
	math: "^\\circ",
	text: "{\\textdegree}",
	textpackages: [
		"textcomp"
	]
},
	"±": {
	math: "\\pm"
},
	"²": {
	math: "^{2}"
},
	"³": {
	math: "^{3}"
},
	"´": {
	text: "{\\textasciiacute}"
},
	"µ": {
	text: "{\\textmu}"
},
	"¶": {
	text: "{\\textparagraph}",
	textpackages: [
		"textcomp"
	]
},
	"·": {
	math: "\\cdot"
},
	"¸": {
	text: "{\\c}"
},
	"¹": {
	math: "^{1}"
},
	"º": {
	text: "{\\textordmasculine}",
	textpackages: [
		"textcomp"
	]
},
	"»": {
	text: "{\\guillemotright}"
},
	"¼": {
	math: "\\frac{1}{4}"
},
	"½": {
	math: "\\frac{1}{2}"
},
	"¾": {
	math: "\\frac{3}{4}"
},
	"¿": {
	text: "{\\textquestiondown}"
},
	"À": {
	text: "{\\`A}"
},
	"Á": {
	text: "{\\'A}"
},
	"Â": {
	text: "{\\^A}"
},
	"Ã": {
	text: "{\\~A}"
},
	"Ä": {
	text: "{\\\"A}"
},
	"Å": {
	text: "{\\AA}"
},
	"Æ": {
	text: "{\\AE}"
},
	"Ç": {
	text: "{\\c C}"
},
	"È": {
	text: "{\\`E}"
},
	"É": {
	text: "{\\'E}"
},
	"Ê": {
	text: "{\\^E}"
},
	"Ë": {
	text: "{\\\"E}"
},
	"Ì": {
	text: "{\\`I}"
},
	"Í": {
	text: "{\\'I}"
},
	"Î": {
	text: "{\\^I}"
},
	"Ï": {
	text: "{\\\"I}"
},
	"Ð": {
	text: "{\\DH}"
},
	"Ñ": {
	text: "{\\~N}"
},
	"Ò": {
	text: "{\\`O}"
},
	"Ó": {
	text: "{\\'O}"
},
	"Ô": {
	text: "{\\^O}"
},
	"Õ": {
	text: "{\\~O}"
},
	"Ö": {
	text: "{\\\"O}"
},
	"×": {
	math: "\\times",
	text: "{\\texttimes}"
},
	"Ø": {
	text: "{\\O}"
},
	"Ù": {
	text: "{\\`U}"
},
	"Ú": {
	text: "{\\'U}"
},
	"Û": {
	text: "{\\^U}"
},
	"Ü": {
	text: "{\\\"U}"
},
	"Ý": {
	text: "{\\'Y}"
},
	"Þ": {
	text: "{\\TH}"
},
	"ß": {
	text: "{\\ss}"
},
	"à": {
	text: "{\\`a}"
},
	"á": {
	text: "{\\'a}"
},
	"â": {
	text: "{\\^a}"
},
	"ã": {
	text: "{\\~a}"
},
	"ä": {
	text: "{\\\"a}"
},
	"å": {
	text: "{\\aa}"
},
	"æ": {
	text: "{\\ae}"
},
	"ç": {
	text: "{\\c c}"
},
	"è": {
	text: "{\\`e}"
},
	"é": {
	text: "{\\'e}"
},
	"ê": {
	text: "{\\^e}"
},
	"ë": {
	text: "{\\\"e}"
},
	"ì": {
	text: "{\\`i}"
},
	"í": {
	text: "{\\'i}"
},
	"î": {
	text: "{\\^i}"
},
	"ï": {
	text: "{\\\"i}"
},
	"ð": {
	math: "\\eth",
	mathpackages: [
		"amssymb",
		"arevmath"
	],
	text: "{\\dh}"
},
	"ñ": {
	text: "{\\~n}"
},
	"ò": {
	text: "{\\`o}"
},
	"ó": {
	text: "{\\'o}"
},
	"ô": {
	text: "{\\^o}"
},
	"õ": {
	text: "{\\~o}"
},
	"ö": {
	text: "{\\\"o}"
},
	"÷": {
	math: "\\div"
},
	"ø": {
	text: "{\\o}"
},
	"ù": {
	text: "{\\`u}"
},
	"ú": {
	text: "{\\'u}"
},
	"û": {
	text: "{\\^u}"
},
	"ü": {
	text: "{\\\"u}"
},
	"ý": {
	text: "{\\'y}"
},
	"þ": {
	text: "{\\th}"
},
	"ÿ": {
	text: "{\\\"y}"
},
	"Ā": {
	text: "{\\=A}"
},
	"ā": {
	text: "{\\=a}"
},
	"Ă": {
	text: "{\\u A}"
},
	"ă": {
	text: "{\\u a}"
},
	"Ą": {
	text: "{\\k{A}}"
},
	"ą": {
	text: "{\\k{a}}"
},
	"Ć": {
	text: "{\\'C}"
},
	"ć": {
	text: "{\\'c}"
},
	"Ĉ": {
	text: "{\\^C}"
},
	"ĉ": {
	text: "{\\^c}"
},
	"Ċ": {
	text: "{\\.C}"
},
	"ċ": {
	text: "{\\.c}"
},
	"Č": {
	text: "{\\v C}"
},
	"č": {
	text: "{\\v c}"
},
	"Ď": {
	text: "{\\v D}"
},
	"ď": {
	text: "{\\v d}"
},
	"Đ": {
	text: "{\\DJ}"
},
	"đ": {
	text: "{\\dj}"
},
	"Ē": {
	text: "{\\=E}"
},
	"ē": {
	text: "{\\=e}"
},
	"Ĕ": {
	text: "{\\u E}"
},
	"ĕ": {
	text: "{\\u e}"
},
	"Ė": {
	text: "{\\.E}"
},
	"ė": {
	text: "{\\.e}"
},
	"Ę": {
	text: "{\\k{E}}"
},
	"ę": {
	text: "{\\k{e}}"
},
	"Ě": {
	text: "{\\v E}"
},
	"ě": {
	text: "{\\v e}"
},
	"Ĝ": {
	text: "{\\^G}"
},
	"ĝ": {
	text: "{\\^g}"
},
	"Ğ": {
	text: "{\\u G}"
},
	"ğ": {
	text: "{\\u g}"
},
	"Ġ": {
	text: "{\\.G}"
},
	"ġ": {
	text: "{\\.g}"
},
	"Ģ": {
	text: "{\\c G}"
},
	"ģ": {
	text: "{\\c g}"
},
	"Ĥ": {
	text: "{\\^H}"
},
	"ĥ": {
	text: "{\\^h}"
},
	"Ħ": {
	text: "{\\fontencoding{LELA}\\selectfont\\char40}"
},
	"ħ": {
	math: "\\Elzxh"
},
	"Ĩ": {
	text: "{\\~I}"
},
	"ĩ": {
	text: "{\\~i}"
},
	"Ī": {
	text: "{\\=I}"
},
	"ī": {
	text: "{\\=i}"
},
	"Ĭ": {
	text: "{\\u I}"
},
	"ĭ": {
	text: "{\\u \\i}"
},
	"Į": {
	text: "{\\k{I}}"
},
	"į": {
	text: "{\\k{i}}"
},
	"İ": {
	text: "{\\.I}"
},
	"ı": {
	math: "\\imath",
	text: "{\\i}"
},
	"Ĳ": {
	text: "IJ"
},
	"ĳ": {
	text: "ij"
},
	"Ĵ": {
	text: "{\\^J}"
},
	"ĵ": {
	text: "{\\^\\j}"
},
	"Ķ": {
	text: "{\\c K}"
},
	"ķ": {
	text: "{\\c k}"
},
	"ĸ": {
	text: "{\\fontencoding{LELA}\\selectfont\\char91}"
},
	"Ĺ": {
	text: "{\\'L}"
},
	"ĺ": {
	text: "{\\'l}"
},
	"Ļ": {
	text: "{\\c L}"
},
	"ļ": {
	text: "{\\c l}"
},
	"Ľ": {
	text: "{\\v L}"
},
	"ľ": {
	text: "{\\v l}"
},
	"Ŀ": {
	text: "{\\fontencoding{LELA}\\selectfont\\char201}"
},
	"ŀ": {
	text: "{\\fontencoding{LELA}\\selectfont\\char202}"
},
	"Ł": {
	text: "{\\L}"
},
	"ł": {
	text: "{\\l}"
},
	"Ń": {
	text: "{\\'N}"
},
	"ń": {
	text: "{\\'n}"
},
	"Ņ": {
	text: "{\\c N}"
},
	"ņ": {
	text: "{\\c n}"
},
	"Ň": {
	text: "{\\v N}"
},
	"ň": {
	text: "{\\v n}"
},
	"ŉ": {
	text: "'n"
},
	"Ŋ": {
	text: "{\\NG}"
},
	"ŋ": {
	text: "{\\ng}"
},
	"Ō": {
	text: "{\\=O}"
},
	"ō": {
	text: "{\\=o}"
},
	"Ŏ": {
	text: "{\\u O}"
},
	"ŏ": {
	text: "{\\u o}"
},
	"Ő": {
	text: "{\\H O}"
},
	"ő": {
	text: "{\\H o}"
},
	"Œ": {
	text: "{\\OE}"
},
	"œ": {
	text: "{\\oe}"
},
	"Ŕ": {
	text: "{\\'R}"
},
	"ŕ": {
	text: "{\\'r}"
},
	"Ŗ": {
	text: "{\\c R}"
},
	"ŗ": {
	text: "{\\c r}"
},
	"Ř": {
	text: "{\\v R}"
},
	"ř": {
	text: "{\\v r}"
},
	"Ś": {
	text: "{\\'S}"
},
	"ś": {
	text: "{\\'s}"
},
	"Ŝ": {
	text: "{\\^S}"
},
	"ŝ": {
	text: "{\\^s}"
},
	"Ş": {
	text: "{\\c S}"
},
	"ş": {
	text: "{\\c s}"
},
	"Š": {
	text: "{\\v S}"
},
	"š": {
	text: "{\\v s}"
},
	"Ţ": {
	text: "{\\c T}"
},
	"ţ": {
	text: "{\\c t}"
},
	"Ť": {
	text: "{\\v T}"
},
	"ť": {
	text: "{\\v t}"
},
	"Ŧ": {
	text: "{\\fontencoding{LELA}\\selectfont\\char47}"
},
	"ŧ": {
	text: "{\\fontencoding{LELA}\\selectfont\\char63}"
},
	"Ũ": {
	text: "{\\~U}"
},
	"ũ": {
	text: "{\\~u}"
},
	"Ū": {
	text: "{\\=U}"
},
	"ū": {
	text: "{\\=u}"
},
	"Ŭ": {
	text: "{\\u U}"
},
	"ŭ": {
	text: "{\\u u}"
},
	"Ů": {
	text: "{\\r{U}}"
},
	"ů": {
	text: "{\\r{u}}"
},
	"Ű": {
	text: "{\\H U}"
},
	"ű": {
	text: "{\\H u}"
},
	"Ų": {
	text: "{\\k{U}}"
},
	"ų": {
	text: "{\\k{u}}"
},
	"Ŵ": {
	text: "{\\^W}"
},
	"ŵ": {
	text: "{\\^w}"
},
	"Ŷ": {
	text: "{\\^Y}"
},
	"ŷ": {
	text: "{\\^y}"
},
	"Ÿ": {
	text: "{\\\"Y}"
},
	"Ź": {
	text: "{\\'Z}"
},
	"ź": {
	text: "{\\'z}"
},
	"Ż": {
	text: "{\\.Z}"
},
	"ż": {
	text: "{\\.z}"
},
	"Ž": {
	text: "{\\v Z}"
},
	"ž": {
	text: "{\\v z}"
},
	"ſ": {
	text: "s"
},
	"ƒ": {
	math: "f"
},
	"ƕ": {
	text: "{\\texthvlig}"
},
	"ƞ": {
	text: "{\\textnrleg}"
},
	"ƪ": {
	text: "{\\textesh}"
},
	"Ƶ": {
	math: "\\Zbar"
},
	"ƺ": {
	text: "{\\fontencoding{LELA}\\selectfont\\char195}"
},
	"ǂ": {
	text: "{\\textdoublepipe}"
},
	"Ǎ": {
	text: "{\\v A}"
},
	"ǎ": {
	text: "{\\v a}"
},
	"Ǐ": {
	text: "{\\v I}"
},
	"ǐ": {
	text: "{\\v i}"
},
	"Ǒ": {
	text: "{\\v O}"
},
	"ǒ": {
	text: "{\\v o}"
},
	"Ǔ": {
	text: "{\\v U}"
},
	"ǔ": {
	text: "{\\v u}"
},
	"Ǧ": {
	text: "{\\v G}"
},
	"ǧ": {
	text: "{\\v g}"
},
	"Ǩ": {
	text: "{\\v K}"
},
	"ǩ": {
	text: "{\\v k}"
},
	"Ǫ": {
	text: "{\\k{O}}"
},
	"ǫ": {
	text: "{\\k{o}}"
},
	"ǰ": {
	text: "{\\v j}"
},
	"Ǵ": {
	text: "{\\'G}"
},
	"ǵ": {
	text: "{\\'g}"
},
	"Ȩ": {
	text: "{\\c E}"
},
	"ȩ": {
	text: "{\\c e}"
},
	"ȷ": {
	math: "\\jmath"
},
	"ɐ": {
	math: "\\Elztrna"
},
	"ɒ": {
	math: "\\Elztrnsa"
},
	"ɔ": {
	math: "\\Elzopeno"
},
	"ɖ": {
	math: "\\Elzrtld"
},
	"ɘ": {
	text: "{\\fontencoding{LEIP}\\selectfont\\char61}"
},
	"ə": {
	math: "\\Elzschwa"
},
	"ɛ": {
	math: "\\varepsilon"
},
	"ɡ": {
	text: "g"
},
	"ɣ": {
	math: "\\Elzpgamma"
},
	"ɤ": {
	math: "\\Elzpbgam"
},
	"ɥ": {
	math: "\\Elztrnh"
},
	"ɬ": {
	math: "\\Elzbtdl"
},
	"ɭ": {
	math: "\\Elzrtll"
},
	"ɯ": {
	math: "\\Elztrnm"
},
	"ɰ": {
	math: "\\Elztrnmlr"
},
	"ɱ": {
	math: "\\Elzltlmr"
},
	"ɲ": {
	text: "{\\Elzltln}"
},
	"ɳ": {
	math: "\\Elzrtln"
},
	"ɷ": {
	math: "\\Elzclomeg"
},
	"ɸ": {
	text: "{\\textphi}"
},
	"ɹ": {
	math: "\\Elztrnr"
},
	"ɺ": {
	math: "\\Elztrnrl"
},
	"ɻ": {
	math: "\\Elzrttrnr"
},
	"ɼ": {
	math: "\\Elzrl"
},
	"ɽ": {
	math: "\\Elzrtlr"
},
	"ɾ": {
	math: "\\Elzfhr"
},
	"ɿ": {
	text: "{\\fontencoding{LEIP}\\selectfont\\char202}"
},
	"ʂ": {
	math: "\\Elzrtls"
},
	"ʃ": {
	math: "\\Elzesh"
},
	"ʇ": {
	math: "\\Elztrnt"
},
	"ʈ": {
	math: "\\Elzrtlt"
},
	"ʊ": {
	math: "\\Elzpupsil"
},
	"ʋ": {
	math: "\\Elzpscrv"
},
	"ʌ": {
	math: "\\Elzinvv"
},
	"ʍ": {
	math: "\\Elzinvw"
},
	"ʎ": {
	math: "\\Elztrny"
},
	"ʐ": {
	math: "\\Elzrtlz"
},
	"ʒ": {
	math: "\\Elzyogh"
},
	"ʔ": {
	math: "\\Elzglst"
},
	"ʕ": {
	math: "\\Elzreglst"
},
	"ʖ": {
	math: "\\Elzinglst"
},
	"ʞ": {
	text: "{\\textturnk}"
},
	"ʤ": {
	math: "\\Elzdyogh"
},
	"ʧ": {
	math: "\\Elztesh"
},
	"ʰ": {
	math: "^{h}",
	text: "\\textsuperscript{h}"
},
	"ʲ": {
	math: "^{j}",
	text: "\\textsuperscript{j}"
},
	"ʳ": {
	math: "^{r}",
	text: "\\textsuperscript{r}"
},
	"ʷ": {
	math: "^{w}",
	text: "\\textsuperscript{w}"
},
	"ʸ": {
	math: "^{y}",
	text: "\\textsuperscript{y}"
},
	"ʹ": {
	text: "'"
},
	"ʻ": {
	text: "'"
},
	"ʼ": {
	text: "'"
},
	"ʽ": {
	text: "'"
},
	"ʿ": {
	text: "{\\lasp}",
	textpackages: [
		"mathscinet"
	]
},
	"ˆ": {
	text: "{\\textasciicircum}"
},
	"ˇ": {
	text: "{\\textasciicaron}"
},
	"ˈ": {
	math: "\\Elzverts"
},
	"ˉ": {
	text: "-"
},
	"ˌ": {
	math: "\\Elzverti"
},
	"ː": {
	math: "\\Elzlmrk"
},
	"ˑ": {
	math: "\\Elzhlmrk"
},
	"˒": {
	math: "\\Elzsbrhr"
},
	"˓": {
	math: "\\Elzsblhr"
},
	"˔": {
	math: "\\Elzrais"
},
	"˕": {
	math: "\\Elzlow"
},
	"˘": {
	text: "{\\textasciibreve}"
},
	"˙": {
	text: "{\\textperiodcentered}",
	textpackages: [
		"textcomp"
	]
},
	"˚": {
	text: "{\\r{}}"
},
	"˛": {
	text: "{\\k{}}"
},
	"˜": {
	text: "{\\texttildelow}"
},
	"˝": {
	text: "{\\H{}}"
},
	"ˡ": {
	math: "^{l}",
	text: "\\textsuperscript{l}"
},
	"ˢ": {
	math: "^{s}",
	text: "\\textsuperscript{s}"
},
	"ˣ": {
	math: "^{x}",
	text: "\\textsuperscript{x}"
},
	"˥": {
	text: "\\tone{55}"
},
	"˦": {
	text: "\\tone{44}"
},
	"˧": {
	text: "\\tone{33}"
},
	"˨": {
	text: "\\tone{22}"
},
	"˩": {
	text: "\\tone{11}"
},
	"̀": {
	math: "\\grave",
	combiningdiacritic: true,
	text: "\\`"
},
	"̀̄": {
	text: "{\\textgravemacron}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̄̀": {
	text: "{\\textgravemacron}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̀̇": {
	text: "{\\textgravedot}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̇̀": {
	text: "{\\textgravedot}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"́": {
	math: "\\acute",
	combiningdiacritic: true,
	text: "\\'"
},
	"́̄": {
	text: "{\\textacutemacron}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̄́": {
	text: "{\\textacutemacron}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"́̌": {
	text: "{\\textacutewedge}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̌́": {
	text: "{\\textacutewedge}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̂": {
	math: "\\hat",
	combiningdiacritic: true,
	text: "\\^"
},
	"̂̇": {
	text: "{\\textcircumdot}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̇̂": {
	text: "{\\textcircumdot}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̃": {
	math: "\\tilde",
	combiningdiacritic: true,
	text: "\\~"
},
	"̃̇": {
	text: "{\\texttildedot}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̇̃": {
	text: "{\\texttildedot}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̄": {
	math: "\\bar",
	combiningdiacritic: true,
	text: "\\="
},
	"̅": {
	math: "\\overline",
	combiningdiacritic: true
},
	"̆": {
	math: "\\breve",
	combiningdiacritic: true,
	text: "{\\u}"
},
	"̆̄": {
	text: "{\\textbrevemacron}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̄̆": {
	text: "{\\textbrevemacron}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̇": {
	math: "\\dot",
	combiningdiacritic: true,
	text: "\\."
},
	"̇́": {
	text: "{\\textdotacute}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"́̇": {
	text: "{\\textdotacute}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̇̆": {
	text: "{\\textdotbreve}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̆̇": {
	text: "{\\textdotbreve}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̈": {
	math: "\\ddot",
	combiningdiacritic: true,
	text: "\\\""
},
	"̉": {
	math: "\\ovhook"
},
	"̊": {
	math: "\\mathring",
	combiningdiacritic: true,
	text: "{\\r}"
},
	"̊̄": {
	text: "{\\textringmacron}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̄̊": {
	text: "{\\textringmacron}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̋": {
	text: "{\\H}",
	combiningdiacritic: true
},
	"̌": {
	math: "\\check",
	text: "{\\v}",
	combiningdiacritic: true
},
	"̍": {
	text: "{\\textvbaraccent}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̎": {
	text: "{\\textdoublevbaraccent}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̏": {
	text: "{\\textdoublegrave}",
	combiningdiacritic: true
},
	"̐": {
	text: "{\\textdotbreve}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̑": {
	text: "{\\fontencoding{LECO}\\selectfont\\char177}"
},
	"̒": {
	math: "\\oturnedcomma"
},
	"̕": {
	math: "\\ocommatopright"
},
	"̖": {
	text: "{\\textsubgrave}",
	combiningdiacritic: true
},
	"̘": {
	text: "{\\textadvancing}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̙": {
	text: "{\\textretracting}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̚": {
	math: "\\droang",
	text: "{\\textcorner}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̜": {
	text: "{\\textsublhalfring}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̝": {
	text: "{\\textraising}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̞": {
	text: "{\\textlowering}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̟": {
	text: "{\\textsubplus}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̡": {
	math: "\\Elzpalh"
},
	"̢": {
	text: "{\\Elzrh}"
},
	"̣": {
	text: "{\\d}",
	combiningdiacritic: true
},
	"̤": {
	text: "{\\textsubumlaut}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̥": {
	text: "{\\textsubring}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̧": {
	text: "{\\c}",
	combiningdiacritic: true
},
	"̨": {
	text: "{\\k}",
	combiningdiacritic: true
},
	"̩": {
	text: "{\\textsyllabic}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̪": {
	math: "\\Elzsbbrg",
	text: "{\\textsubbridge}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̫": {
	text: "{\\fontencoding{LECO}\\selectfont\\char203}"
},
	"̬": {
	text: "{\\textsubwedge}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̯": {
	text: "{\\textsubarch}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̰": {
	math: "\\utilde",
	text: "{\\textsubtilde}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̱": {
	math: "\\underbar",
	combiningdiacritic: true,
	text: "{\\textsubbar}",
	textpackages: [
		"tipa"
	]
},
	"̲": {
	math: "\\underline"
},
	"̴": {
	text: "{\\textsuperimposetilde}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̵": {
	text: "{\\Elzxl}"
},
	"̶": {
	text: "{\\Elzbar}"
},
	"̷": {
	text: "{\\fontencoding{LECO}\\selectfont\\char215}"
},
	"̸": {
	math: "\\not"
},
	"̹": {
	text: "{\\textsubrhalfring}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̺": {
	text: "{\\textinvsubbridge}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̻": {
	text: "{\\textsubsquare}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̼": {
	text: "{\\textseagull}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"̽": {
	text: "{\\textovercross}",
	combiningdiacritic: true,
	textpackages: [
		"tipa"
	]
},
	"͡": {
	text: "{\\fontencoding{LECO}\\selectfont\\char225}"
},
	"ʹ": {
	text: "'"
},
	"͵": {
	text: ","
},
	";": {
	text: ";"
},
	"Ά": {
	text: "{\\'A}"
},
	"Έ": {
	text: "{\\'E}"
},
	"Ή": {
	text: "{\\'H}"
},
	"Ί": {
	text: "{\\'{}I}"
},
	"Ό": {
	text: "{\\'{}O}"
},
	"Ύ": {
	math: "\\mathrm{'Y}"
},
	"Ώ": {
	math: "\\mathrm{'\\Omega}"
},
	"ΐ": {
	math: "\\acute{\\ddot{\\iota}}"
},
	"Α": {
	math: "A"
},
	"Β": {
	math: "B"
},
	"Γ": {
	math: "\\Gamma"
},
	"Δ": {
	math: "\\Delta"
},
	"Ε": {
	math: "E"
},
	"Ζ": {
	math: "Z"
},
	"Η": {
	math: "H"
},
	"Θ": {
	math: "\\Theta"
},
	"Ι": {
	math: "I"
},
	"Κ": {
	math: "K"
},
	"Λ": {
	math: "\\Lambda"
},
	"Μ": {
	math: "M"
},
	"Ν": {
	math: "N"
},
	"Ξ": {
	math: "\\Xi"
},
	"Ο": {
	math: "O"
},
	"Π": {
	math: "\\Pi"
},
	"Ρ": {
	math: "P"
},
	"Σ": {
	math: "\\Sigma"
},
	"Τ": {
	math: "T"
},
	"Υ": {
	math: "\\Upsilon"
},
	"Φ": {
	math: "\\Phi"
},
	"Χ": {
	math: "X"
},
	"Ψ": {
	math: "\\Psi"
},
	"Ω": {
	math: "\\Omega"
},
	"Ϊ": {
	math: "\\mathrm{\\ddot{I}}"
},
	"Ϋ": {
	math: "\\mathrm{\\ddot{Y}}"
},
	"ά": {
	text: "{\\'$\\alpha$}"
},
	"έ": {
	math: "\\acute{\\epsilon}"
},
	"ή": {
	math: "\\acute{\\eta}"
},
	"ί": {
	math: "\\acute{\\iota}"
},
	"ΰ": {
	math: "\\acute{\\ddot{\\upsilon}}"
},
	"α": {
	math: "\\alpha"
},
	"β": {
	math: "\\beta"
},
	"γ": {
	math: "\\gamma"
},
	"δ": {
	math: "\\delta"
},
	"ε": {
	math: "\\epsilon"
},
	"ζ": {
	math: "\\zeta"
},
	"η": {
	math: "\\eta"
},
	"θ": {
	math: "\\theta",
	text: "{\\texttheta}"
},
	"ι": {
	math: "\\iota"
},
	"κ": {
	math: "\\kappa"
},
	"λ": {
	math: "\\lambda"
},
	"μ": {
	math: "\\mu"
},
	"ν": {
	math: "\\nu"
},
	"ξ": {
	math: "\\xi"
},
	"ο": {
	math: "o"
},
	"π": {
	math: "\\pi"
},
	"ρ": {
	math: "\\rho"
},
	"ς": {
	math: "\\varsigma"
},
	"σ": {
	math: "\\sigma"
},
	"τ": {
	math: "\\tau"
},
	"υ": {
	math: "\\upsilon"
},
	"φ": {
	math: "\\varphi"
},
	"χ": {
	math: "\\chi"
},
	"ψ": {
	math: "\\psi"
},
	"ω": {
	math: "\\omega"
},
	"ϊ": {
	math: "\\ddot{\\iota}"
},
	"ϋ": {
	math: "\\ddot{\\upsilon}"
},
	"ό": {
	text: "{\\'o}"
},
	"ύ": {
	math: "\\acute{\\upsilon}"
},
	"ώ": {
	math: "\\acute{\\omega}"
},
	"ϐ": {
	math: "\\varbeta",
	text: "\\Pisymbol{ppi022}{87}"
},
	"ϑ": {
	math: "\\vartheta",
	text: "{\\textvartheta}"
},
	"ϒ": {
	math: "\\Upsilon"
},
	"ϕ": {
	math: "\\phi"
},
	"ϖ": {
	math: "\\varpi"
},
	"Ϙ": {
	math: "\\Qoppa"
},
	"ϙ": {
	math: "\\qoppa"
},
	"Ϛ": {
	math: "\\Stigma"
},
	"ϛ": {
	math: "\\stigma"
},
	"Ϝ": {
	math: "\\Digamma"
},
	"ϝ": {
	math: "\\digamma"
},
	"Ϟ": {
	math: "\\Koppa"
},
	"ϟ": {
	math: "\\koppa"
},
	"Ϡ": {
	math: "\\Sampi"
},
	"ϡ": {
	math: "\\sampi"
},
	"ϰ": {
	math: "\\varkappa"
},
	"ϱ": {
	math: "\\varrho"
},
	"ϴ": {
	math: "\\upvarTheta",
	text: "{\\textTheta}"
},
	"ϵ": {
	math: "\\epsilon"
},
	"϶": {
	math: "\\backepsilon"
},
	"Ё": {
	text: "{\\cyrchar\\CYRYO}"
},
	"Ђ": {
	text: "{\\cyrchar\\CYRDJE}"
},
	"Ѓ": {
	text: "{\\cyrchar{\\'\\CYRG}}"
},
	"Є": {
	text: "{\\cyrchar\\CYRIE}"
},
	"Ѕ": {
	text: "{\\cyrchar\\CYRDZE}"
},
	"І": {
	text: "{\\cyrchar\\CYRII}"
},
	"Ї": {
	text: "{\\cyrchar\\CYRYI}"
},
	"Ј": {
	text: "{\\cyrchar\\CYRJE}"
},
	"Љ": {
	text: "{\\cyrchar\\CYRLJE}"
},
	"Њ": {
	text: "{\\cyrchar\\CYRNJE}"
},
	"Ћ": {
	text: "{\\cyrchar\\CYRTSHE}"
},
	"Ќ": {
	text: "{\\cyrchar{\\'\\CYRK}}"
},
	"Ў": {
	text: "{\\cyrchar\\CYRUSHRT}"
},
	"Џ": {
	text: "{\\cyrchar\\CYRDZHE}"
},
	"А": {
	text: "{\\cyrchar\\CYRA}"
},
	"Б": {
	text: "{\\cyrchar\\CYRB}"
},
	"В": {
	text: "{\\cyrchar\\CYRV}"
},
	"Г": {
	text: "{\\cyrchar\\CYRG}"
},
	"Д": {
	text: "{\\cyrchar\\CYRD}"
},
	"Е": {
	text: "{\\cyrchar\\CYRE}"
},
	"Ж": {
	text: "{\\cyrchar\\CYRZH}"
},
	"З": {
	text: "{\\cyrchar\\CYRZ}"
},
	"И": {
	text: "{\\cyrchar\\CYRI}"
},
	"Й": {
	text: "{\\cyrchar\\CYRISHRT}"
},
	"К": {
	text: "{\\cyrchar\\CYRK}"
},
	"Л": {
	text: "{\\cyrchar\\CYRL}"
},
	"М": {
	text: "{\\cyrchar\\CYRM}"
},
	"Н": {
	text: "{\\cyrchar\\CYRN}"
},
	"О": {
	text: "{\\cyrchar\\CYRO}"
},
	"П": {
	text: "{\\cyrchar\\CYRP}"
},
	"Р": {
	text: "{\\cyrchar\\CYRR}"
},
	"С": {
	text: "{\\cyrchar\\CYRS}"
},
	"Т": {
	text: "{\\cyrchar\\CYRT}"
},
	"У": {
	text: "{\\cyrchar\\CYRU}"
},
	"Ф": {
	text: "{\\cyrchar\\CYRF}"
},
	"Х": {
	text: "{\\cyrchar\\CYRH}"
},
	"Ц": {
	text: "{\\cyrchar\\CYRC}"
},
	"Ч": {
	text: "{\\cyrchar\\CYRCH}"
},
	"Ш": {
	text: "{\\cyrchar\\CYRSH}"
},
	"Щ": {
	text: "{\\cyrchar\\CYRSHCH}"
},
	"Ъ": {
	text: "{\\cyrchar\\CYRHRDSN}"
},
	"Ы": {
	text: "{\\cyrchar\\CYRERY}"
},
	"Ь": {
	text: "{\\cyrchar\\CYRSFTSN}"
},
	"Э": {
	text: "{\\cyrchar\\CYREREV}"
},
	"Ю": {
	text: "{\\cyrchar\\CYRYU}"
},
	"Я": {
	text: "{\\cyrchar\\CYRYA}"
},
	"а": {
	text: "{\\cyrchar\\cyra}"
},
	"б": {
	text: "{\\cyrchar\\cyrb}"
},
	"в": {
	text: "{\\cyrchar\\cyrv}"
},
	"г": {
	text: "{\\cyrchar\\cyrg}"
},
	"д": {
	text: "{\\cyrchar\\cyrd}"
},
	"е": {
	text: "{\\cyrchar\\cyre}"
},
	"ж": {
	text: "{\\cyrchar\\cyrzh}"
},
	"з": {
	text: "{\\cyrchar\\cyrz}"
},
	"и": {
	text: "{\\cyrchar\\cyri}"
},
	"й": {
	text: "{\\cyrchar\\cyrishrt}"
},
	"к": {
	text: "{\\cyrchar\\cyrk}"
},
	"л": {
	text: "{\\cyrchar\\cyrl}"
},
	"м": {
	text: "{\\cyrchar\\cyrm}"
},
	"н": {
	text: "{\\cyrchar\\cyrn}"
},
	"о": {
	text: "{\\cyrchar\\cyro}"
},
	"п": {
	text: "{\\cyrchar\\cyrp}"
},
	"р": {
	text: "{\\cyrchar\\cyrr}"
},
	"с": {
	text: "{\\cyrchar\\cyrs}"
},
	"т": {
	text: "{\\cyrchar\\cyrt}"
},
	"у": {
	text: "{\\cyrchar\\cyru}"
},
	"ф": {
	text: "{\\cyrchar\\cyrf}"
},
	"х": {
	text: "{\\cyrchar\\cyrh}"
},
	"ц": {
	text: "{\\cyrchar\\cyrc}"
},
	"ч": {
	text: "{\\cyrchar\\cyrch}"
},
	"ш": {
	text: "{\\cyrchar\\cyrsh}"
},
	"щ": {
	text: "{\\cyrchar\\cyrshch}"
},
	"ъ": {
	text: "{\\cyrchar\\cyrhrdsn}"
},
	"ы": {
	text: "{\\cyrchar\\cyrery}"
},
	"ь": {
	text: "{\\cyrchar\\cyrsftsn}"
},
	"э": {
	text: "{\\cyrchar\\cyrerev}"
},
	"ю": {
	text: "{\\cyrchar\\cyryu}"
},
	"я": {
	text: "{\\cyrchar\\cyrya}"
},
	"ё": {
	text: "{\\cyrchar\\cyryo}"
},
	"ђ": {
	text: "{\\cyrchar\\cyrdje}"
},
	"ѓ": {
	text: "{\\cyrchar{\\'\\cyrg}}"
},
	"є": {
	text: "{\\cyrchar\\cyrie}"
},
	"ѕ": {
	text: "{\\cyrchar\\cyrdze}"
},
	"і": {
	text: "{\\cyrchar\\cyrii}"
},
	"ї": {
	text: "{\\cyrchar\\cyryi}"
},
	"ј": {
	text: "{\\cyrchar\\cyrje}"
},
	"љ": {
	text: "{\\cyrchar\\cyrlje}"
},
	"њ": {
	text: "{\\cyrchar\\cyrnje}"
},
	"ћ": {
	text: "{\\cyrchar\\cyrtshe}"
},
	"ќ": {
	text: "{\\cyrchar{\\'\\cyrk}}"
},
	"ў": {
	text: "{\\cyrchar\\cyrushrt}"
},
	"џ": {
	text: "{\\cyrchar\\cyrdzhe}"
},
	"Ѡ": {
	text: "{\\cyrchar\\CYROMEGA}"
},
	"ѡ": {
	text: "{\\cyrchar\\cyromega}"
},
	"Ѣ": {
	text: "{\\cyrchar\\CYRYAT}"
},
	"Ѥ": {
	text: "{\\cyrchar\\CYRIOTE}"
},
	"ѥ": {
	text: "{\\cyrchar\\cyriote}"
},
	"Ѧ": {
	text: "{\\cyrchar\\CYRLYUS}"
},
	"ѧ": {
	text: "{\\cyrchar\\cyrlyus}"
},
	"Ѩ": {
	text: "{\\cyrchar\\CYRIOTLYUS}"
},
	"ѩ": {
	text: "{\\cyrchar\\cyriotlyus}"
},
	"Ѫ": {
	text: "{\\cyrchar\\CYRBYUS}"
},
	"Ѭ": {
	text: "{\\cyrchar\\CYRIOTBYUS}"
},
	"ѭ": {
	text: "{\\cyrchar\\cyriotbyus}"
},
	"Ѯ": {
	text: "{\\cyrchar\\CYRKSI}"
},
	"ѯ": {
	text: "{\\cyrchar\\cyrksi}"
},
	"Ѱ": {
	text: "{\\cyrchar\\CYRPSI}"
},
	"ѱ": {
	text: "{\\cyrchar\\cyrpsi}"
},
	"Ѳ": {
	text: "{\\cyrchar\\CYRFITA}"
},
	"Ѵ": {
	text: "{\\cyrchar\\CYRIZH}"
},
	"Ѹ": {
	text: "{\\cyrchar\\CYRUK}"
},
	"ѹ": {
	text: "{\\cyrchar\\cyruk}"
},
	"Ѻ": {
	text: "{\\cyrchar\\CYROMEGARND}"
},
	"ѻ": {
	text: "{\\cyrchar\\cyromegarnd}"
},
	"Ѽ": {
	text: "{\\cyrchar\\CYROMEGATITLO}"
},
	"ѽ": {
	text: "{\\cyrchar\\cyromegatitlo}"
},
	"Ѿ": {
	text: "{\\cyrchar\\CYROT}"
},
	"ѿ": {
	text: "{\\cyrchar\\cyrot}"
},
	"Ҁ": {
	text: "{\\cyrchar\\CYRKOPPA}"
},
	"ҁ": {
	text: "{\\cyrchar\\cyrkoppa}"
},
	"҂": {
	text: "{\\cyrchar\\cyrthousands}"
},
	"҈": {
	text: "{\\cyrchar\\cyrhundredthousands}"
},
	"҉": {
	text: "{\\cyrchar\\cyrmillions}"
},
	"Ҍ": {
	text: "{\\cyrchar\\CYRSEMISFTSN}"
},
	"ҍ": {
	text: "{\\cyrchar\\cyrsemisftsn}"
},
	"Ҏ": {
	text: "{\\cyrchar\\CYRRTICK}"
},
	"ҏ": {
	text: "{\\cyrchar\\cyrrtick}"
},
	"Ґ": {
	text: "{\\cyrchar\\CYRGUP}"
},
	"ґ": {
	text: "{\\cyrchar\\cyrgup}"
},
	"Ғ": {
	text: "{\\cyrchar\\CYRGHCRS}"
},
	"ғ": {
	text: "{\\cyrchar\\cyrghcrs}"
},
	"Ҕ": {
	text: "{\\cyrchar\\CYRGHK}"
},
	"ҕ": {
	text: "{\\cyrchar\\cyrghk}"
},
	"Җ": {
	text: "{\\cyrchar\\CYRZHDSC}"
},
	"җ": {
	text: "{\\cyrchar\\cyrzhdsc}"
},
	"Ҙ": {
	text: "{\\cyrchar\\CYRZDSC}"
},
	"ҙ": {
	text: "{\\cyrchar\\cyrzdsc}"
},
	"Қ": {
	text: "{\\cyrchar\\CYRKDSC}"
},
	"қ": {
	text: "{\\cyrchar\\cyrkdsc}"
},
	"Ҝ": {
	text: "{\\cyrchar\\CYRKVCRS}"
},
	"ҝ": {
	text: "{\\cyrchar\\cyrkvcrs}"
},
	"Ҟ": {
	text: "{\\cyrchar\\CYRKHCRS}"
},
	"ҟ": {
	text: "{\\cyrchar\\cyrkhcrs}"
},
	"Ҡ": {
	text: "{\\cyrchar\\CYRKBEAK}"
},
	"ҡ": {
	text: "{\\cyrchar\\cyrkbeak}"
},
	"Ң": {
	text: "{\\cyrchar\\CYRNDSC}"
},
	"ң": {
	text: "{\\cyrchar\\cyrndsc}"
},
	"Ҥ": {
	text: "{\\cyrchar\\CYRNG}"
},
	"ҥ": {
	text: "{\\cyrchar\\cyrng}"
},
	"Ҧ": {
	text: "{\\cyrchar\\CYRPHK}"
},
	"ҧ": {
	text: "{\\cyrchar\\cyrphk}"
},
	"Ҩ": {
	text: "{\\cyrchar\\CYRABHHA}"
},
	"ҩ": {
	text: "{\\cyrchar\\cyrabhha}"
},
	"Ҫ": {
	text: "{\\cyrchar\\CYRSDSC}"
},
	"ҫ": {
	text: "{\\cyrchar\\cyrsdsc}"
},
	"Ҭ": {
	text: "{\\cyrchar\\CYRTDSC}"
},
	"ҭ": {
	text: "{\\cyrchar\\cyrtdsc}"
},
	"Ү": {
	text: "{\\cyrchar\\CYRY}"
},
	"ү": {
	text: "{\\cyrchar\\cyry}"
},
	"Ұ": {
	text: "{\\cyrchar\\CYRYHCRS}"
},
	"ұ": {
	text: "{\\cyrchar\\cyryhcrs}"
},
	"Ҳ": {
	text: "{\\cyrchar\\CYRHDSC}"
},
	"ҳ": {
	text: "{\\cyrchar\\cyrhdsc}"
},
	"Ҵ": {
	text: "{\\cyrchar\\CYRTETSE}"
},
	"ҵ": {
	text: "{\\cyrchar\\cyrtetse}"
},
	"Ҷ": {
	text: "{\\cyrchar\\CYRCHRDSC}"
},
	"ҷ": {
	text: "{\\cyrchar\\cyrchrdsc}"
},
	"Ҹ": {
	text: "{\\cyrchar\\CYRCHVCRS}"
},
	"ҹ": {
	text: "{\\cyrchar\\cyrchvcrs}"
},
	"Һ": {
	text: "{\\cyrchar\\CYRSHHA}"
},
	"һ": {
	text: "{\\cyrchar\\cyrshha}"
},
	"Ҽ": {
	text: "{\\cyrchar\\CYRABHCH}"
},
	"ҽ": {
	text: "{\\cyrchar\\cyrabhch}"
},
	"Ҿ": {
	text: "{\\cyrchar\\CYRABHCHDSC}"
},
	"ҿ": {
	text: "{\\cyrchar\\cyrabhchdsc}"
},
	"Ӏ": {
	text: "{\\cyrchar\\CYRpalochka}"
},
	"Ӄ": {
	text: "{\\cyrchar\\CYRKHK}"
},
	"ӄ": {
	text: "{\\cyrchar\\cyrkhk}"
},
	"Ӈ": {
	text: "{\\cyrchar\\CYRNHK}"
},
	"ӈ": {
	text: "{\\cyrchar\\cyrnhk}"
},
	"Ӌ": {
	text: "{\\cyrchar\\CYRCHLDSC}"
},
	"ӌ": {
	text: "{\\cyrchar\\cyrchldsc}"
},
	"Ӕ": {
	text: "{\\cyrchar\\CYRAE}"
},
	"ӕ": {
	text: "{\\cyrchar\\cyrae}"
},
	"Ә": {
	text: "{\\cyrchar\\CYRSCHWA}"
},
	"ә": {
	text: "{\\cyrchar\\cyrschwa}"
},
	"Ӡ": {
	text: "{\\cyrchar\\CYRABHDZE}"
},
	"ӡ": {
	text: "{\\cyrchar\\cyrabhdze}"
},
	"Ө": {
	text: "{\\cyrchar\\CYROTLD}"
},
	"ө": {
	text: "{\\cyrchar\\cyrotld}"
},
	"ࡱ": {
	math: "\\\\backslash"
},
	"ᵃ": {
	math: "^{a}",
	text: "\\textsuperscript{a}"
},
	"ᵇ": {
	math: "^{b}",
	text: "\\textsuperscript{b}"
},
	"ᵈ": {
	math: "^{d}",
	text: "\\textsuperscript{d}"
},
	"ᵉ": {
	math: "^{e}",
	text: "\\textsuperscript{e}"
},
	"ᵍ": {
	math: "^{g}",
	text: "\\textsuperscript{g}"
},
	"ᵏ": {
	math: "^{k}",
	text: "\\textsuperscript{k}"
},
	"ᵐ": {
	math: "^{m}",
	text: "\\textsuperscript{m}"
},
	"ᵒ": {
	math: "^{o}",
	text: "\\textsuperscript{o}"
},
	"ᵖ": {
	math: "^{p}",
	text: "\\textsuperscript{p}"
},
	"ᵗ": {
	math: "^{t}",
	text: "\\textsuperscript{t}"
},
	"ᵘ": {
	math: "^{u}",
	text: "\\textsuperscript{u}"
},
	"ᵛ": {
	math: "^{v}",
	text: "\\textsuperscript{v}"
},
	"ᶜ": {
	math: "^{c}",
	text: "\\textsuperscript{c}"
},
	"ᶠ": {
	math: "^{f}",
	text: "\\textsuperscript{f}"
},
	"ᶻ": {
	math: "^{z}",
	text: "\\textsuperscript{z}"
},
	"Ḃ": {
	text: "{\\.B}"
},
	"ḃ": {
	text: "{\\.b}"
},
	"Ḅ": {
	text: "{\\d B}"
},
	"ḅ": {
	text: "{\\d b}"
},
	"Ḇ": {
	text: "{\\b B}"
},
	"ḇ": {
	text: "{\\b b}"
},
	"Ḋ": {
	text: "{\\.D}"
},
	"ḋ": {
	text: "{\\.d}"
},
	"Ḍ": {
	text: "{\\d D}"
},
	"ḍ": {
	text: "{\\d d}"
},
	"Ḏ": {
	text: "{\\b D}"
},
	"ḏ": {
	text: "{\\b d}"
},
	"Ḑ": {
	text: "{\\c D}"
},
	"ḑ": {
	text: "{\\c d}"
},
	"Ḝ": {
	text: "{\\c{\\u{E}}}"
},
	"ḝ": {
	text: "{\\c{\\u{e}}}"
},
	"Ḟ": {
	text: "{\\.F}"
},
	"ḟ": {
	text: "{\\.f}"
},
	"Ḡ": {
	text: "{\\=G}"
},
	"ḡ": {
	text: "{\\=g}"
},
	"Ḣ": {
	text: "{\\.H}"
},
	"ḣ": {
	text: "{\\.h}"
},
	"Ḥ": {
	text: "{\\d H}"
},
	"ḥ": {
	text: "{\\d h}"
},
	"Ḧ": {
	text: "{\\\"H}"
},
	"ḧ": {
	text: "{\\\"h}"
},
	"Ḩ": {
	text: "{\\c H}"
},
	"ḩ": {
	text: "{\\c h}"
},
	"Ḱ": {
	text: "{\\'K}"
},
	"ḱ": {
	text: "{\\'k}"
},
	"Ḳ": {
	text: "{\\d K}"
},
	"ḳ": {
	text: "{\\d k}"
},
	"Ḵ": {
	text: "{\\b K}"
},
	"ḵ": {
	text: "{\\b k}"
},
	"Ḷ": {
	text: "{\\d L}"
},
	"ḷ": {
	text: "{\\d l}"
},
	"Ḻ": {
	text: "{\\b L}"
},
	"ḻ": {
	text: "{\\b l}"
},
	"Ḿ": {
	text: "{\\'M}"
},
	"ḿ": {
	text: "{\\'m}"
},
	"Ṁ": {
	text: "{\\.M}"
},
	"ṁ": {
	text: "{\\.m}"
},
	"Ṃ": {
	text: "{\\d M}"
},
	"ṃ": {
	text: "{\\d m}"
},
	"Ṅ": {
	text: "{\\.N}"
},
	"ṅ": {
	text: "{\\.n}"
},
	"Ṇ": {
	text: "{\\d N}"
},
	"ṇ": {
	text: "{\\d n}"
},
	"Ṉ": {
	text: "{\\b N}"
},
	"ṉ": {
	text: "{\\b n}"
},
	"Ṕ": {
	text: "{\\'P}"
},
	"ṕ": {
	text: "{\\'p}"
},
	"Ṗ": {
	text: "{\\.P}"
},
	"ṗ": {
	text: "{\\.p}"
},
	"Ṙ": {
	text: "{\\.R}"
},
	"ṙ": {
	text: "{\\.r}"
},
	"Ṛ": {
	text: "{\\d R}"
},
	"ṛ": {
	text: "{\\d r}"
},
	"Ṟ": {
	text: "{\\b R}"
},
	"ṟ": {
	text: "{\\b r}"
},
	"Ṡ": {
	text: "{\\.S}"
},
	"ṡ": {
	text: "{\\.s}"
},
	"Ṣ": {
	text: "{\\d S}"
},
	"ṣ": {
	text: "{\\d s}"
},
	"Ṫ": {
	text: "{\\.T}"
},
	"ṫ": {
	text: "{\\.t}"
},
	"Ṭ": {
	text: "{\\d T}"
},
	"ṭ": {
	text: "{\\d t}"
},
	"Ṯ": {
	text: "{\\b T}"
},
	"ṯ": {
	text: "{\\b t}"
},
	"Ṽ": {
	text: "{\\~V}"
},
	"ṽ": {
	text: "{\\~v}"
},
	"Ṿ": {
	text: "{\\d V}"
},
	"ṿ": {
	text: "{\\d v}"
},
	"Ẁ": {
	text: "{\\`W}"
},
	"ẁ": {
	text: "{\\`w}"
},
	"Ẃ": {
	text: "{\\'W}"
},
	"ẃ": {
	text: "{\\'w}"
},
	"Ẅ": {
	text: "{\\\"W}"
},
	"ẅ": {
	text: "{\\\"w}"
},
	"Ẇ": {
	text: "{\\.W}"
},
	"ẇ": {
	text: "{\\.w}"
},
	"Ẉ": {
	text: "{\\d W}"
},
	"ẉ": {
	text: "{\\d w}"
},
	"Ẋ": {
	text: "{\\.X}"
},
	"ẋ": {
	text: "{\\.x}"
},
	"Ẍ": {
	text: "{\\\"X}"
},
	"ẍ": {
	text: "{\\\"x}"
},
	"Ẏ": {
	text: "{\\.Y}"
},
	"ẏ": {
	text: "{\\.y}"
},
	"Ẑ": {
	text: "{\\^Z}"
},
	"ẑ": {
	text: "{\\^z}"
},
	"Ẓ": {
	text: "{\\d Z}"
},
	"ẓ": {
	text: "{\\d z}"
},
	"Ẕ": {
	text: "{\\b Z}"
},
	"ẕ": {
	text: "{\\b z}"
},
	"ẖ": {
	text: "{\\b h}"
},
	"ẗ": {
	text: "{\\\"t}"
},
	"ẘ": {
	text: "{\\r{w}}"
},
	"ẙ": {
	text: "{\\r{y}}"
},
	"Ạ": {
	text: "{\\d A}"
},
	"ạ": {
	text: "{\\d a}"
},
	"Ẹ": {
	text: "{\\d E}"
},
	"ẹ": {
	text: "{\\d e}"
},
	"Ẽ": {
	text: "{\\~E}"
},
	"ẽ": {
	text: "{\\~e}"
},
	"Ị": {
	text: "{\\d I}"
},
	"ị": {
	text: "{\\d i}"
},
	"Ọ": {
	text: "{\\d O}"
},
	"ọ": {
	text: "{\\d o}"
},
	"Ụ": {
	text: "{\\d U}"
},
	"ụ": {
	text: "{\\d u}"
},
	"Ỳ": {
	text: "{\\`Y}"
},
	"ỳ": {
	text: "{\\`y}"
},
	"Ỵ": {
	text: "{\\d Y}"
},
	"ỵ": {
	text: "{\\d y}"
},
	"Ỹ": {
	text: "{\\~Y}"
},
	"ỹ": {
	text: "{\\~y}"
},
	" ": {
	text: " ",
	space: true
},
	" ": {
	math: "\\quad",
	space: true
},
	" ": {
	text: "\\hspace{0.6em}",
	space: true
},
	" ": {
	math: "\\quad",
	space: true,
	text: "\\hspace{1em}"
},
	" ": {
	text: "\\;",
	space: true
},
	" ": {
	text: "\\hspace{0.25em}",
	space: true
},
	" ": {
	text: "\\hspace{0.166em}",
	space: true
},
	" ": {
	text: "\\hphantom{0}",
	space: true
},
	" ": {
	text: "\\hphantom{,}",
	space: true
},
	" ": {
	text: "\\,",
	space: true
},
	" ": {
	math: "\\mkern1mu",
	space: true
},
	"​": {
	text: "{\\mbox}",
	space: true
},
	"‌": {
	text: "{\\aftergroup\\ignorespaces}"
},
	"‐": {
	text: "-"
},
	"‑": {
	text: "-"
},
	"‒": {
	text: "-"
},
	"–": {
	text: "{\\textendash}"
},
	"—": {
	text: "{\\textemdash}"
},
	"―": {
	math: "\\horizbar",
	text: "\\rule{1em}{1pt}"
},
	"‖": {
	math: "\\Vert"
},
	"‗": {
	math: "\\twolowline"
},
	"‘": {
	text: "`"
},
	"’": {
	text: "'"
},
	"‚": {
	text: ","
},
	"‛": {
	math: "\\Elzreapos"
},
	"“": {
	text: "``"
},
	"”": {
	text: "''"
},
	"„": {
	text: ",,"
},
	"‟": {
	text: "{\\quotedblbase}"
},
	"†": {
	math: "\\dagger",
	text: "{\\textdagger}",
	textpackages: [
		"textcomp"
	]
},
	"‡": {
	math: "\\ddagger",
	text: "{\\textdaggerdbl}",
	textpackages: [
		"textcomp"
	]
},
	"•": {
	math: "\\bullet",
	text: "{\\textbullet}",
	textpackages: [
		"textcomp"
	]
},
	"‣": {
	text: ">"
},
	"․": {
	text: "."
},
	"‥": {
	math: "\\enleadertwodots",
	text: ".."
},
	"…": {
	math: "\\ldots",
	text: "{\\ldots}"
},
	"‧": {
	text: "-"
},
	" ": {
	text: " ",
	space: true
},
	"‰": {
	text: "{\\textperthousand}",
	textpackages: [
		"textcomp"
	]
},
	"‱": {
	text: "{\\textpertenthousand}",
	textpackages: [
		"textcomp"
	]
},
	"′": {
	math: "{'}"
},
	"″": {
	math: "{''}"
},
	"‴": {
	math: "{'''}"
},
	"‵": {
	math: "\\backprime"
},
	"‶": {
	math: "\\backdprime"
},
	"‷": {
	math: "\\backtrprime"
},
	"‸": {
	math: "\\caretinsert"
},
	"‹": {
	text: "{\\guilsinglleft}"
},
	"›": {
	text: "{\\guilsinglright}"
},
	"‼": {
	math: "\\Exclam"
},
	"‾": {
	text: "-"
},
	"⁃": {
	math: "\\hyphenbullet"
},
	"⁄": {
	math: "\\fracslash"
},
	"⁇": {
	math: "\\Question"
},
	"⁈": {
	text: "?!"
},
	"⁉": {
	text: "!?"
},
	"⁊": {
	text: "7"
},
	"⁐": {
	math: "\\closure"
},
	"⁗": {
	math: "''''"
},
	" ": {
	math: "\\:",
	space: true,
	text: "\\:"
},
	"⁠": {
	text: "{\\nolinebreak}"
},
	"⁰": {
	math: "^{0}"
},
	"ⁱ": {
	math: "^{i}",
	text: "\\textsuperscript{i}"
},
	"⁴": {
	math: "^{4}"
},
	"⁵": {
	math: "^{5}"
},
	"⁶": {
	math: "^{6}"
},
	"⁷": {
	math: "^{7}"
},
	"⁸": {
	math: "^{8}"
},
	"⁹": {
	math: "^{9}"
},
	"⁺": {
	math: "^{+}"
},
	"⁻": {
	math: "^{-}"
},
	"⁼": {
	math: "^{=}"
},
	"⁽": {
	math: "^{(}"
},
	"⁾": {
	math: "^{)}"
},
	"ⁿ": {
	math: "^{n}",
	text: "\\textsuperscript{n}"
},
	"₀": {
	math: "_{0}"
},
	"₁": {
	math: "_{1}"
},
	"₂": {
	math: "_{2}"
},
	"₃": {
	math: "_{3}"
},
	"₄": {
	math: "_{4}"
},
	"₅": {
	math: "_{5}"
},
	"₆": {
	math: "_{6}"
},
	"₇": {
	math: "_{7}"
},
	"₈": {
	math: "_{8}"
},
	"₉": {
	math: "_{9}"
},
	"₊": {
	math: "_{+}"
},
	"₋": {
	math: "_{-}"
},
	"₌": {
	math: "_{=}"
},
	"₍": {
	math: "_{(}"
},
	"₎": {
	math: "_{)}"
},
	"ₐ": {
	math: "_{a}",
	text: "\\textsubscript{a}"
},
	"ₑ": {
	math: "_{e}",
	text: "\\textsubscript{e}"
},
	"ₒ": {
	math: "_{o}",
	text: "\\textsubscript{o}"
},
	"ₓ": {
	math: "_{x}",
	text: "\\textsubscript{x}"
},
	"ₔ": {
	text: "\\textsubscript{\\textschwa}",
	textpackages: [
		"tipa"
	]
},
	"ₕ": {
	math: "_{h}",
	text: "\\textsubscript{h}"
},
	"ₖ": {
	math: "_{k}",
	text: "\\textsubscript{k}"
},
	"ₗ": {
	math: "_{l}",
	text: "\\textsubscript{l}"
},
	"ₘ": {
	math: "_{m}",
	text: "\\textsubscript{m}"
},
	"ₙ": {
	math: "_{n}",
	text: "\\textsubscript{n}"
},
	"ₚ": {
	math: "_{p}",
	text: "\\textsubscript{p}"
},
	"ₛ": {
	math: "_{s}",
	text: "\\textsubscript{s}"
},
	"ₜ": {
	math: "_{t}",
	text: "\\textsubscript{t}"
},
	"₧": {
	text: "\\ensuremath{\\Elzpes}"
},
	"€": {
	math: "\\euro",
	text: "{\\texteuro}"
},
	"⃐": {
	math: "\\lvec"
},
	"⃑": {
	math: "\\rightharpoonup",
	mathpackages: [
		"amsmath",
		"amssymb"
	]
},
	"⃒": {
	math: "\\vertoverlay"
},
	"⃖": {
	math: "\\LVec"
},
	"⃗": {
	math: "\\vec"
},
	"⃛": {
	math: "\\dddot"
},
	"⃜": {
	math: "\\ddddot"
},
	"⃝": {
	math: "\\enclosecircle"
},
	"⃞": {
	math: "\\enclosesquare"
},
	"⃟": {
	math: "\\enclosediamond"
},
	"⃡": {
	math: "\\overleftrightarrow"
},
	"⃤": {
	math: "\\enclosetriangle"
},
	"⃧": {
	math: "\\annuity"
},
	"⃨": {
	math: "\\threeunderdot"
},
	"⃩": {
	math: "\\widebridgeabove"
},
	"⃬": {
	math: "\\underrightharpoondown"
},
	"⃭": {
	math: "\\underleftharpoondown"
},
	"⃮": {
	math: "\\underleftarrow"
},
	"⃯": {
	math: "\\underrightarrow"
},
	"⃰": {
	math: "\\asteraccent"
},
	"℀": {
	text: "a/c"
},
	"℁": {
	text: "a/s"
},
	"ℂ": {
	math: "\\mathbb{C}"
},
	"℃": {
	text: "{\\textcelsius}"
},
	"℅": {
	text: "c/o"
},
	"℆": {
	text: "c/u"
},
	"ℇ": {
	math: "\\Euler"
},
	"℉": {
	text: "F"
},
	"ℊ": {
	math: "\\mathscr{g}"
},
	"ℋ": {
	math: "\\mathscr{H}"
},
	"ℌ": {
	math: "\\mathfrak{H}"
},
	"ℍ": {
	math: "\\mathbb{H}"
},
	"ℎ": {
	math: "\\Planckconst"
},
	"ℏ": {
	math: "\\hslash"
},
	"ℐ": {
	math: "\\mathscr{I}"
},
	"ℑ": {
	math: "\\mathfrak{I}"
},
	"ℒ": {
	math: "\\mathscr{L}"
},
	"ℓ": {
	math: "\\mathscr{l}"
},
	"ℕ": {
	math: "\\mathbb{N}"
},
	"№": {
	text: "{\\cyrchar\\textnumero}"
},
	"℗": {
	text: "{\\textcircledP}"
},
	"℘": {
	math: "\\wp"
},
	"ℙ": {
	math: "\\mathbb{P}"
},
	"ℚ": {
	math: "\\mathbb{Q}"
},
	"ℛ": {
	math: "\\mathscr{R}"
},
	"ℜ": {
	math: "\\mathfrak{R}"
},
	"ℝ": {
	math: "\\mathbb{R}"
},
	"℞": {
	math: "\\Elzxrat"
},
	"℠": {
	text: "{\\textservicemark}"
},
	"℡": {
	text: "TEL"
},
	"™": {
	text: "{\\texttrademark}",
	textpackages: [
		"textcomp"
	]
},
	"ℤ": {
	math: "\\mathbb{Z}"
},
	"Ω": {
	math: "\\Omega"
},
	"℧": {
	math: "\\mho"
},
	"ℨ": {
	math: "\\mathfrak{Z}"
},
	"℩": {
	text: "{\\textriota}"
},
	"K": {
	text: "K"
},
	"Å": {
	math: "\\Angstroem",
	text: "{\\AA}"
},
	"ℬ": {
	math: "\\mathscr{B}"
},
	"ℭ": {
	math: "\\mathfrak{C}"
},
	"℮": {
	text: "{\\textestimated}"
},
	"ℯ": {
	math: "\\mathscr{e}"
},
	"ℰ": {
	math: "\\mathscr{E}"
},
	"ℱ": {
	math: "\\mathscr{F}"
},
	"Ⅎ": {
	math: "\\Finv"
},
	"ℳ": {
	math: "\\mathscr{M}"
},
	"ℴ": {
	math: "\\mathscr{o}"
},
	"ℵ": {
	math: "\\aleph"
},
	"ℶ": {
	math: "\\beth"
},
	"ℷ": {
	math: "\\gimel"
},
	"ℸ": {
	math: "\\daleth"
},
	"ℼ": {
	math: "\\mathbb{\\pi}"
},
	"ℽ": {
	math: "\\mathbb{\\gamma}"
},
	"ℾ": {
	math: "\\mathbb{\\Gamma}"
},
	"ℿ": {
	math: "\\mathbb{\\Pi}"
},
	"⅀": {
	math: "\\mathbb{\\Sigma}"
},
	"⅁": {
	math: "\\Game"
},
	"⅂": {
	math: "\\sansLturned"
},
	"⅃": {
	math: "\\sansLmirrored"
},
	"⅄": {
	math: "\\Yup"
},
	"ⅅ": {
	math: "\\CapitalDifferentialD"
},
	"ⅆ": {
	math: "\\DifferentialD"
},
	"ⅇ": {
	math: "\\ExponetialE"
},
	"ⅈ": {
	math: "\\ComplexI"
},
	"ⅉ": {
	math: "\\ComplexJ"
},
	"⅊": {
	math: "\\PropertyLine"
},
	"⅋": {
	math: "\\invamp"
},
	"⅐": {
	math: "\\frac{1}{7}"
},
	"⅑": {
	math: "\\frac{1}{9}"
},
	"⅒": {
	math: "\\frac{1}{10}"
},
	"⅓": {
	math: "\\frac{1}{3}"
},
	"⅔": {
	math: "\\frac{2}{3}"
},
	"⅕": {
	math: "\\frac{1}{5}"
},
	"⅖": {
	math: "\\frac{2}{5}"
},
	"⅗": {
	math: "\\frac{3}{5}"
},
	"⅘": {
	math: "\\frac{4}{5}"
},
	"⅙": {
	math: "\\frac{1}{6}"
},
	"⅚": {
	math: "\\frac{5}{6}"
},
	"⅛": {
	math: "\\frac{1}{8}"
},
	"⅜": {
	math: "\\frac{3}{8}"
},
	"⅝": {
	math: "\\frac{5}{8}"
},
	"⅞": {
	math: "\\frac{7}{8}"
},
	"⅟": {
	math: "\\frac{1}"
},
	"Ⅰ": {
	text: "I"
},
	"Ⅱ": {
	text: "II"
},
	"Ⅲ": {
	text: "III"
},
	"Ⅳ": {
	text: "IV"
},
	"Ⅴ": {
	text: "V"
},
	"Ⅵ": {
	text: "VI"
},
	"Ⅶ": {
	text: "VII"
},
	"Ⅷ": {
	text: "VIII"
},
	"Ⅸ": {
	text: "IX"
},
	"Ⅹ": {
	text: "X"
},
	"Ⅺ": {
	text: "XI"
},
	"Ⅻ": {
	text: "XII"
},
	"Ⅼ": {
	text: "L"
},
	"Ⅽ": {
	text: "C"
},
	"Ⅾ": {
	text: "D"
},
	"Ⅿ": {
	text: "M"
},
	"ⅰ": {
	text: "i"
},
	"ⅱ": {
	text: "ii"
},
	"ⅲ": {
	text: "iii"
},
	"ⅳ": {
	text: "iv"
},
	"ⅴ": {
	text: "v"
},
	"ⅵ": {
	text: "vi"
},
	"ⅶ": {
	text: "vii"
},
	"ⅷ": {
	text: "viii"
},
	"ⅸ": {
	text: "ix"
},
	"ⅹ": {
	text: "x"
},
	"ⅺ": {
	text: "xi"
},
	"ⅻ": {
	text: "xii"
},
	"ⅼ": {
	text: "l"
},
	"ⅽ": {
	text: "c"
},
	"ⅾ": {
	text: "d"
},
	"ⅿ": {
	text: "m"
},
	"↉": {
	math: "\\frac{0}{3}"
},
	"←": {
	math: "\\leftarrow"
},
	"↑": {
	math: "\\uparrow"
},
	"→": {
	math: "\\rightarrow",
	text: "{\\textrightarrow}",
	textpackages: [
		"textcomp"
	]
},
	"↓": {
	math: "\\downarrow"
},
	"↔": {
	math: "\\leftrightarrow"
},
	"↕": {
	math: "\\updownarrow"
},
	"↖": {
	math: "\\nwarrow"
},
	"↗": {
	math: "\\nearrow"
},
	"↘": {
	math: "\\searrow"
},
	"↙": {
	math: "\\swarrow"
},
	"↚": {
	math: "\\nleftarrow"
},
	"↛": {
	math: "\\nrightarrow"
},
	"↜": {
	math: "\\arrowwaveleft"
},
	"↝": {
	math: "\\arrowwaveright"
},
	"↞": {
	math: "\\twoheadleftarrow"
},
	"↟": {
	math: "\\twoheaduparrow"
},
	"↠": {
	math: "\\twoheadrightarrow"
},
	"↡": {
	math: "\\twoheaddownarrow"
},
	"↢": {
	math: "\\leftarrowtail"
},
	"↣": {
	math: "\\rightarrowtail"
},
	"↤": {
	math: "\\mapsfrom"
},
	"↥": {
	math: "\\MapsUp"
},
	"↦": {
	math: "\\mapsto"
},
	"↧": {
	math: "\\MapsDown"
},
	"↨": {
	math: "\\updownarrowbar"
},
	"↩": {
	math: "\\hookleftarrow"
},
	"↪": {
	math: "\\hookrightarrow"
},
	"↫": {
	math: "\\looparrowleft"
},
	"↬": {
	math: "\\looparrowright"
},
	"↭": {
	math: "\\leftrightsquigarrow"
},
	"↮": {
	math: "\\nleftrightarrow"
},
	"↯": {
	math: "\\lightning"
},
	"↰": {
	math: "\\Lsh"
},
	"↱": {
	math: "\\Rsh"
},
	"↲": {
	math: "\\dlsh"
},
	"↳": {
	text: "\\reflectbox{\\carriagereturn}",
	textpackages: [
		"graphics",
		"unicode-math"
	]
},
	"↴": {
	math: "\\linefeed"
},
	"↵": {
	math: "\\carriagereturn"
},
	"↶": {
	math: "\\curvearrowleft"
},
	"↷": {
	math: "\\curvearrowright"
},
	"↸": {
	math: "\\barovernorthwestarrow"
},
	"↹": {
	math: "\\barleftarrowrightarrowba"
},
	"↺": {
	math: "\\circlearrowleft"
},
	"↻": {
	math: "\\circlearrowright"
},
	"↼": {
	math: "\\leftharpoonup"
},
	"↽": {
	math: "\\leftharpoondown"
},
	"↾": {
	math: "\\upharpoonright"
},
	"↿": {
	math: "\\upharpoonleft"
},
	"⇀": {
	math: "\\rightharpoonup",
	mathpackages: [
		"amsmath",
		"amssymb"
	]
},
	"⇁": {
	math: "\\rightharpoondown"
},
	"⇂": {
	math: "\\downharpoonright"
},
	"⇃": {
	math: "\\downharpoonleft"
},
	"⇄": {
	math: "\\rightleftarrows"
},
	"⇅": {
	math: "\\dblarrowupdown"
},
	"⇆": {
	math: "\\leftrightarrows"
},
	"⇇": {
	math: "\\leftleftarrows"
},
	"⇈": {
	math: "\\upuparrows"
},
	"⇉": {
	math: "\\rightrightarrows"
},
	"⇊": {
	math: "\\downdownarrows"
},
	"⇋": {
	math: "\\leftrightharpoons"
},
	"⇌": {
	math: "\\rightleftharpoons"
},
	"⇍": {
	math: "\\nLeftarrow"
},
	"⇎": {
	math: "\\nLeftrightarrow"
},
	"⇏": {
	math: "\\nRightarrow"
},
	"⇐": {
	math: "\\Leftarrow"
},
	"⇑": {
	math: "\\Uparrow"
},
	"⇒": {
	math: "\\Rightarrow"
},
	"⇓": {
	math: "\\Downarrow"
},
	"⇔": {
	math: "\\Leftrightarrow"
},
	"⇕": {
	math: "\\Updownarrow"
},
	"⇖": {
	math: "\\Nwarrow"
},
	"⇗": {
	math: "\\Nearrow"
},
	"⇘": {
	math: "\\Searrow"
},
	"⇙": {
	math: "\\Swarrow"
},
	"⇚": {
	math: "\\Lleftarrow"
},
	"⇛": {
	math: "\\Rrightarrow"
},
	"⇜": {
	math: "\\leftsquigarrow"
},
	"⇝": {
	math: "\\rightsquigarrow"
},
	"⇞": {
	math: "\\nHuparrow"
},
	"⇟": {
	math: "\\nHdownarrow"
},
	"⇠": {
	math: "\\dashleftarrow"
},
	"⇡": {
	math: "\\updasharrow"
},
	"⇢": {
	math: "\\dashrightarrow"
},
	"⇣": {
	math: "\\downdasharrow"
},
	"⇤": {
	math: "\\LeftArrowBar"
},
	"⇥": {
	math: "\\RightArrowBar"
},
	"⇦": {
	math: "\\leftwhitearrow"
},
	"⇧": {
	math: "\\upwhitearrow"
},
	"⇨": {
	math: "\\rightwhitearrow"
},
	"⇩": {
	math: "\\downwhitearrow"
},
	"⇪": {
	math: "\\whitearrowupfrombar"
},
	"⇴": {
	math: "\\circleonrightarrow"
},
	"⇵": {
	math: "\\DownArrowUpArrow"
},
	"⇶": {
	math: "\\rightthreearrows"
},
	"⇷": {
	math: "\\nvleftarrow"
},
	"⇸": {
	math: "\\pfun"
},
	"⇹": {
	math: "\\nvleftrightarrow"
},
	"⇺": {
	math: "\\nVleftarrow"
},
	"⇻": {
	math: "\\ffun"
},
	"⇼": {
	math: "\\nVleftrightarrow"
},
	"⇽": {
	math: "\\leftarrowtriangle"
},
	"⇾": {
	math: "\\rightarrowtriangle"
},
	"⇿": {
	math: "\\leftrightarrowtriangle"
},
	"∀": {
	math: "\\forall"
},
	"∁": {
	math: "\\complement"
},
	"∂": {
	math: "\\partial"
},
	"∃": {
	math: "\\exists"
},
	"∄": {
	math: "\\nexists"
},
	"∅": {
	math: "\\varnothing"
},
	"∆": {
	math: "\\increment"
},
	"∇": {
	math: "\\nabla"
},
	"∈": {
	math: "\\in"
},
	"∉": {
	math: "\\not\\in"
},
	"∊": {
	math: "\\smallin"
},
	"∋": {
	math: "\\ni"
},
	"∌": {
	math: "\\not\\ni"
},
	"∍": {
	math: "\\smallni"
},
	"∎": {
	math: "\\QED"
},
	"∏": {
	math: "\\prod"
},
	"∐": {
	math: "\\coprod"
},
	"∑": {
	math: "\\sum"
},
	"−": {
	math: "-",
	text: "-"
},
	"∓": {
	math: "\\mp"
},
	"∔": {
	math: "\\dotplus"
},
	"∕": {
	text: "/"
},
	"∖": {
	math: "\\setminus"
},
	"∗": {
	math: "{_\\ast}"
},
	"∘": {
	math: "\\circ"
},
	"∙": {
	math: "\\bullet"
},
	"√": {
	math: "\\surd"
},
	"∛": {
	math: "\\sqrt[3]"
},
	"∜": {
	math: "\\sqrt[4]"
},
	"∝": {
	math: "\\propto"
},
	"∞": {
	math: "\\infty"
},
	"∟": {
	math: "\\rightangle"
},
	"∠": {
	math: "\\angle"
},
	"∡": {
	math: "\\measuredangle"
},
	"∢": {
	math: "\\sphericalangle"
},
	"∣": {
	math: "\\mid"
},
	"∤": {
	math: "\\nmid"
},
	"∥": {
	math: "\\parallel"
},
	"∦": {
	math: "\\nparallel"
},
	"∧": {
	math: "\\wedge"
},
	"∨": {
	math: "\\vee"
},
	"∩": {
	math: "\\cap"
},
	"∪": {
	math: "\\cup"
},
	"∫": {
	math: "\\int"
},
	"∬": {
	math: "{\\int\\!\\int}"
},
	"∭": {
	math: "{\\int\\!\\int\\!\\int}"
},
	"∮": {
	math: "\\oint"
},
	"∯": {
	math: "\\surfintegral"
},
	"∰": {
	math: "\\volintegral"
},
	"∱": {
	math: "\\clwintegral"
},
	"∲": {
	math: "\\lcirclerightint",
	mathpackages: [
		"MnSymbol"
	]
},
	"∳": {
	math: "\\rcirclerightint",
	mathpackages: [
		"MnSymbol"
	]
},
	"∴": {
	math: "\\therefore"
},
	"∵": {
	math: "\\because"
},
	"∶": {
	math: ":"
},
	"∷": {
	math: "\\Colon"
},
	"∸": {
	math: "\\dotdiv",
	mathpackages: [
		"mathabx"
	]
},
	"∹": {
	math: "\\eqcolon"
},
	"∺": {
	math: "\\mathbin{{:}\\!\\!{-}\\!\\!{:}}"
},
	"∻": {
	math: "\\homothetic"
},
	"∼": {
	math: "\\sim"
},
	"∽": {
	math: "\\backsim"
},
	"∾": {
	math: "\\lazysinv"
},
	"∿": {
	math: "\\AC"
},
	"≀": {
	math: "\\wr"
},
	"≁": {
	math: "\\not\\sim"
},
	"≂": {
	math: "\\texteqsim",
	mathpackages: [
		"xecjk"
	]
},
	"≂̸": {
	math: "\\NotEqualTilde"
},
	"≃": {
	math: "\\simeq"
},
	"≄": {
	math: "\\not\\simeq"
},
	"≅": {
	math: "\\cong"
},
	"≆": {
	math: "\\approxnotequal"
},
	"≇": {
	math: "\\not\\cong"
},
	"≈": {
	math: "\\approx"
},
	"≉": {
	math: "\\not\\approx"
},
	"≊": {
	math: "\\approxeq"
},
	"≋": {
	math: "\\tildetrpl"
},
	"≋̸": {
	math: "\\not\\apid"
},
	"≌": {
	math: "\\allequal"
},
	"≍": {
	math: "\\asymp"
},
	"≎": {
	math: "\\Bumpeq"
},
	"≎̸": {
	math: "\\NotHumpDownHump"
},
	"≏": {
	math: "\\bumpeq"
},
	"≏̸": {
	math: "\\NotHumpEqual"
},
	"≐": {
	math: "\\doteq"
},
	"≐̸": {
	math: "\\not\\doteq"
},
	"≑": {
	math: "\\doteqdot"
},
	"≒": {
	math: "\\fallingdotseq"
},
	"≓": {
	math: "\\risingdotseq"
},
	"≔": {
	math: "\\coloneq",
	text: ":="
},
	"≕": {
	math: "=:"
},
	"≖": {
	math: "\\eqcirc"
},
	"≗": {
	math: "\\circeq"
},
	"≘": {
	math: "\\arceq"
},
	"≙": {
	math: "\\estimates"
},
	"≛": {
	math: "\\starequal"
},
	"≜": {
	math: "\\triangleq"
},
	"≝": {
	math: "\\eqdef"
},
	"≞": {
	math: "\\measeq"
},
	"≠": {
	math: "\\neq"
},
	"≡": {
	math: "\\equiv"
},
	"≢": {
	math: "\\not\\equiv"
},
	"≣": {
	math: "\\Equiv"
},
	"≤": {
	math: "\\leq"
},
	"≥": {
	math: "\\geq"
},
	"≦": {
	math: "\\leqq"
},
	"≧": {
	math: "\\geqq"
},
	"≨": {
	math: "\\lneqq"
},
	"≨︀": {
	math: "\\lvertneqq"
},
	"≩": {
	math: "\\gneqq"
},
	"≩︀": {
	math: "\\gvertneqq"
},
	"≪": {
	math: "\\ll"
},
	"≪̸": {
	math: "\\NotLessLess"
},
	"≫": {
	math: "\\gg"
},
	"≫̸": {
	math: "\\NotGreaterGreater"
},
	"≬": {
	math: "\\between"
},
	"≭": {
	math: "{\\not\\kern-0.3em\\times}"
},
	"≮": {
	math: "\\not<"
},
	"≯": {
	math: "\\not>"
},
	"≰": {
	math: "\\not\\leq"
},
	"≱": {
	math: "\\not\\geq"
},
	"≲": {
	math: "\\lessequivlnt"
},
	"≳": {
	math: "\\greaterequivlnt"
},
	"≶": {
	math: "\\lessgtr"
},
	"≷": {
	math: "\\gtrless"
},
	"≸": {
	math: "\\notlessgreater"
},
	"≹": {
	math: "\\notgreaterless"
},
	"≺": {
	math: "\\prec"
},
	"≻": {
	math: "\\succ"
},
	"≼": {
	math: "\\preccurlyeq"
},
	"≽": {
	math: "\\succcurlyeq"
},
	"≾": {
	math: "\\precapprox"
},
	"≾̸": {
	math: "\\NotPrecedesTilde"
},
	"≿": {
	math: "\\succapprox"
},
	"≿̸": {
	math: "\\NotSucceedsTilde"
},
	"⊀": {
	math: "\\not\\prec"
},
	"⊁": {
	math: "\\not\\succ"
},
	"⊂": {
	math: "\\subset"
},
	"⊃": {
	math: "\\supset"
},
	"⊄": {
	math: "\\not\\subset"
},
	"⊅": {
	math: "\\not\\supset"
},
	"⊆": {
	math: "\\subseteq"
},
	"⊇": {
	math: "\\supseteq"
},
	"⊈": {
	math: "\\not\\subseteq"
},
	"⊉": {
	math: "\\not\\supseteq"
},
	"⊊": {
	math: "\\subsetneq"
},
	"⊊︀": {
	math: "\\varsubsetneqq"
},
	"⊋": {
	math: "\\supsetneq"
},
	"⊋︀": {
	math: "\\varsupsetneq"
},
	"⊌": {
	math: "\\cupleftarrow"
},
	"⊍": {
	math: "\\cupdot"
},
	"⊎": {
	math: "\\uplus"
},
	"⊏": {
	math: "\\sqsubset"
},
	"⊏̸": {
	math: "\\NotSquareSubset"
},
	"⊐": {
	math: "\\sqsupset"
},
	"⊐̸": {
	math: "\\NotSquareSuperset"
},
	"⊑": {
	math: "\\sqsubseteq"
},
	"⊒": {
	math: "\\sqsupseteq"
},
	"⊓": {
	math: "\\sqcap"
},
	"⊔": {
	math: "\\sqcup"
},
	"⊕": {
	math: "\\oplus"
},
	"⊖": {
	math: "\\ominus"
},
	"⊗": {
	math: "\\otimes"
},
	"⊘": {
	math: "\\oslash"
},
	"⊙": {
	math: "\\odot"
},
	"⊚": {
	math: "\\circledcirc"
},
	"⊛": {
	math: "\\circledast"
},
	"⊜": {
	math: "\\circledequal"
},
	"⊝": {
	math: "\\circleddash"
},
	"⊞": {
	math: "\\boxplus"
},
	"⊟": {
	math: "\\boxminus"
},
	"⊠": {
	math: "\\boxtimes"
},
	"⊡": {
	math: "\\boxdot"
},
	"⊢": {
	math: "\\vdash"
},
	"⊣": {
	math: "\\dashv"
},
	"⊤": {
	math: "\\top"
},
	"⊥": {
	math: "\\perp"
},
	"⊦": {
	math: "\\assert"
},
	"⊧": {
	math: "\\truestate"
},
	"⊨": {
	math: "\\forcesextra"
},
	"⊩": {
	math: "\\Vdash"
},
	"⊪": {
	math: "\\Vvdash"
},
	"⊫": {
	math: "\\VDash"
},
	"⊬": {
	math: "\\nvdash"
},
	"⊭": {
	math: "\\nvDash"
},
	"⊮": {
	math: "\\nVdash"
},
	"⊯": {
	math: "\\nVDash"
},
	"⊰": {
	math: "\\prurel"
},
	"⊱": {
	math: "\\scurel"
},
	"⊲": {
	math: "\\vartriangleleft"
},
	"⊳": {
	math: "\\vartriangleright"
},
	"⊴": {
	math: "\\trianglelefteq"
},
	"⊵": {
	math: "\\trianglerighteq"
},
	"⊶": {
	math: "\\original"
},
	"⊷": {
	math: "\\image"
},
	"⊸": {
	math: "\\multimap"
},
	"⊹": {
	math: "\\hermitconjmatrix"
},
	"⊺": {
	math: "\\intercal"
},
	"⊻": {
	math: "\\veebar"
},
	"⊼": {
	math: "\\barwedge"
},
	"⊽": {
	math: "\\barvee"
},
	"⊾": {
	math: "\\rightanglearc"
},
	"⊿": {
	math: "\\varlrtriangle"
},
	"⋂": {
	math: "\\bigcap"
},
	"⋃": {
	math: "\\bigcup"
},
	"⋄": {
	math: "\\diamond"
},
	"⋅": {
	math: "\\cdot"
},
	"⋆": {
	math: "\\star"
},
	"⋇": {
	math: "\\divideontimes"
},
	"⋈": {
	math: "\\bowtie"
},
	"⋉": {
	math: "\\ltimes"
},
	"⋊": {
	math: "\\rtimes"
},
	"⋋": {
	math: "\\leftthreetimes"
},
	"⋌": {
	math: "\\rightthreetimes"
},
	"⋍": {
	math: "\\backsimeq"
},
	"⋎": {
	math: "\\curlyvee"
},
	"⋏": {
	math: "\\curlywedge"
},
	"⋐": {
	math: "\\Subset"
},
	"⋑": {
	math: "\\Supset"
},
	"⋒": {
	math: "\\Cap"
},
	"⋓": {
	math: "\\Cup"
},
	"⋔": {
	math: "\\pitchfork"
},
	"⋕": {
	math: "\\hash"
},
	"⋖": {
	math: "\\lessdot"
},
	"⋗": {
	math: "\\gtrdot"
},
	"⋘": {
	math: "\\verymuchless"
},
	"⋙": {
	math: "\\verymuchgreater"
},
	"⋚": {
	math: "\\lesseqgtr"
},
	"⋛": {
	math: "\\gtreqless"
},
	"⋜": {
	math: "\\eqless"
},
	"⋝": {
	math: "\\eqgtr"
},
	"⋞": {
	math: "\\curlyeqprec"
},
	"⋟": {
	math: "\\curlyeqsucc"
},
	"⋠": {
	math: "\\npreceq"
},
	"⋡": {
	math: "\\nsucceq"
},
	"⋢": {
	math: "\\not\\sqsubseteq"
},
	"⋣": {
	math: "\\not\\sqsupseteq"
},
	"⋤": {
	math: "\\sqsubsetneq"
},
	"⋥": {
	math: "\\Elzsqspne"
},
	"⋦": {
	math: "\\lnsim"
},
	"⋧": {
	math: "\\gnsim"
},
	"⋨": {
	math: "\\precedesnotsimilar"
},
	"⋩": {
	math: "\\succnsim"
},
	"⋪": {
	math: "\\ntriangleleft"
},
	"⋫": {
	math: "\\ntriangleright"
},
	"⋬": {
	math: "\\ntrianglelefteq"
},
	"⋭": {
	math: "\\ntrianglerighteq"
},
	"⋮": {
	math: "\\vdots"
},
	"⋯": {
	math: "\\cdots"
},
	"⋰": {
	math: "\\upslopeellipsis"
},
	"⋱": {
	math: "\\downslopeellipsis"
},
	"⋲": {
	math: "\\disin"
},
	"⋳": {
	math: "\\varisins"
},
	"⋴": {
	math: "\\isins"
},
	"⋵": {
	math: "\\isindot"
},
	"⋶": {
	math: "\\barin"
},
	"⋷": {
	math: "\\isinobar"
},
	"⋸": {
	math: "\\isinvb"
},
	"⋹": {
	math: "\\isinE"
},
	"⋺": {
	math: "\\nisd"
},
	"⋻": {
	math: "\\varnis"
},
	"⋼": {
	math: "\\nis"
},
	"⋽": {
	math: "\\varniobar"
},
	"⋾": {
	math: "\\niobar"
},
	"⋿": {
	math: "\\bagmember"
},
	"⌀": {
	math: "\\diameter"
},
	"⌂": {
	math: "\\house"
},
	"⌅": {
	math: "\\varbarwedge",
	text: "{\\barwedge}"
},
	"⌆": {
	math: "\\perspcorrespond"
},
	"⌈": {
	math: "\\lceil"
},
	"⌉": {
	math: "\\rceil"
},
	"⌊": {
	math: "\\lfloor"
},
	"⌋": {
	math: "\\rfloor"
},
	"⌐": {
	math: "\\invneg"
},
	"⌑": {
	math: "\\wasylozenge"
},
	"⌒": {
	math: "\\profline"
},
	"⌓": {
	math: "\\profsurf"
},
	"⌕": {
	math: "\\recorder"
},
	"⌖": {
	math: "{\\mathchar\"2208}"
},
	"⌗": {
	math: "\\viewdata"
},
	"⌙": {
	math: "\\turnednot"
},
	"⌜": {
	math: "\\ulcorner"
},
	"⌝": {
	math: "\\urcorner"
},
	"⌞": {
	math: "\\llcorner"
},
	"⌟": {
	math: "\\lrcorner"
},
	"⌠": {
	math: "\\inttop"
},
	"⌡": {
	math: "\\intbottom"
},
	"⌢": {
	math: "\\frown"
},
	"⌣": {
	math: "\\smile"
},
	"〈": {
	math: "\\langle"
},
	"〉": {
	math: "\\rangle"
},
	"⌬": {
	math: "\\varhexagonlrbonds"
},
	"⌲": {
	math: "\\conictaper"
},
	"⌶": {
	math: "\\topbot"
},
	"⌹": {
	math: "\\APLinv"
},
	"⌿": {
	math: "\\notslash"
},
	"⍀": {
	math: "\\notbackslash"
},
	"⍇": {
	math: "\\APLleftarrowbox"
},
	"⍈": {
	math: "\\APLrightarrowbox"
},
	"⍉": {
	math: "\\invdiameter"
},
	"⍐": {
	math: "\\APLuparrowbox"
},
	"⍓": {
	math: "\\APLboxupcaret"
},
	"⍗": {
	math: "\\APLdownarrowbox"
},
	"⍝": {
	math: "\\APLcomment"
},
	"⍞": {
	math: "\\APLinput"
},
	"⍟": {
	math: "\\APLlog"
},
	"⍰": {
	math: "\\APLboxquestion"
},
	"⍼": {
	math: "\\rangledownzigzagarrow"
},
	"⎔": {
	math: "\\hexagon"
},
	"⎛": {
	math: "\\lparenuend"
},
	"⎜": {
	math: "\\lparenextender"
},
	"⎝": {
	math: "\\lparenlend"
},
	"⎞": {
	math: "\\rparenuend"
},
	"⎟": {
	math: "\\rparenextender"
},
	"⎠": {
	math: "\\rparenlend"
},
	"⎡": {
	math: "\\lbrackuend"
},
	"⎢": {
	math: "\\lbrackextender"
},
	"⎣": {
	math: "\\Elzdlcorn"
},
	"⎤": {
	math: "\\rbrackuend"
},
	"⎥": {
	math: "\\rbrackextender"
},
	"⎦": {
	math: "\\rbracklend"
},
	"⎧": {
	math: "\\lbraceuend"
},
	"⎨": {
	math: "\\lbracemid"
},
	"⎩": {
	math: "\\lbracelend"
},
	"⎪": {
	math: "\\vbraceextender"
},
	"⎫": {
	math: "\\rbraceuend"
},
	"⎬": {
	math: "\\rbracemid"
},
	"⎭": {
	math: "\\rbracelend"
},
	"⎮": {
	math: "\\intextender"
},
	"⎯": {
	math: "\\harrowextender"
},
	"⎰": {
	math: "\\lmoustache"
},
	"⎱": {
	math: "\\rmoustache"
},
	"⎲": {
	math: "\\sumtop"
},
	"⎳": {
	math: "\\sumbottom"
},
	"⎴": {
	math: "\\overbracket"
},
	"⎵": {
	math: "\\underbracket"
},
	"⎶": {
	math: "\\bbrktbrk"
},
	"⎷": {
	math: "\\sqrtbottom"
},
	"⎸": {
	math: "\\lvboxline"
},
	"⎹": {
	math: "\\rvboxline"
},
	"⏎": {
	math: "\\varcarriagereturn"
},
	"⏜": {
	math: "\\overparen"
},
	"⏝": {
	math: "\\underparen"
},
	"⏞": {
	math: "\\overbrace"
},
	"⏟": {
	math: "\\underbrace"
},
	"⏠": {
	math: "\\obrbrak"
},
	"⏡": {
	math: "\\ubrbrak"
},
	"⏢": {
	math: "\\trapezium"
},
	"⏣": {
	math: "\\benzenr"
},
	"⏤": {
	math: "\\strns"
},
	"⏥": {
	math: "\\fltns"
},
	"⏦": {
	math: "\\accurrent"
},
	"⏧": {
	math: "\\elinters"
},
	"␀": {
	text: "NUL"
},
	"␁": {
	text: "SOH"
},
	"␂": {
	text: "STX"
},
	"␃": {
	text: "ETX"
},
	"␄": {
	text: "EOT"
},
	"␅": {
	text: "ENQ"
},
	"␆": {
	text: "ACK"
},
	"␇": {
	text: "BEL"
},
	"␈": {
	text: "BS"
},
	"␉": {
	text: "HT"
},
	"␊": {
	text: "LF"
},
	"␋": {
	text: "VT"
},
	"␌": {
	text: "FF"
},
	"␍": {
	text: "CR"
},
	"␎": {
	text: "SO"
},
	"␏": {
	text: "SI"
},
	"␐": {
	text: "DLE"
},
	"␑": {
	text: "DC1"
},
	"␒": {
	text: "DC2"
},
	"␓": {
	text: "DC3"
},
	"␔": {
	text: "DC4"
},
	"␕": {
	text: "NAK"
},
	"␖": {
	text: "SYN"
},
	"␗": {
	text: "ETB"
},
	"␘": {
	text: "CAN"
},
	"␙": {
	text: "EM"
},
	"␚": {
	text: "SUB"
},
	"␛": {
	text: "ESC"
},
	"␜": {
	text: "FS"
},
	"␝": {
	text: "GS"
},
	"␞": {
	text: "RS"
},
	"␟": {
	text: "US"
},
	"␠": {
	text: "SP"
},
	"␡": {
	text: "DEL"
},
	"␣": {
	text: "{\\textvisiblespace}"
},
	"␤": {
	text: "NL"
},
	"␥": {
	text: "///"
},
	"␦": {
	text: "?"
},
	"①": {
	text: "\\ding{172}"
},
	"②": {
	text: "\\ding{173}"
},
	"③": {
	text: "\\ding{174}"
},
	"④": {
	text: "\\ding{175}"
},
	"⑤": {
	text: "\\ding{176}"
},
	"⑥": {
	text: "\\ding{177}"
},
	"⑦": {
	text: "\\ding{178}"
},
	"⑧": {
	text: "\\ding{179}"
},
	"⑨": {
	text: "\\ding{180}"
},
	"⑩": {
	text: "\\ding{181}"
},
	"⑪": {
	text: "(11)"
},
	"⑫": {
	text: "(12)"
},
	"⑬": {
	text: "(13)"
},
	"⑭": {
	text: "(14)"
},
	"⑮": {
	text: "(15)"
},
	"⑯": {
	text: "(16)"
},
	"⑰": {
	text: "(17)"
},
	"⑱": {
	text: "(18)"
},
	"⑲": {
	text: "(19)"
},
	"⑳": {
	text: "(20)"
},
	"⑴": {
	text: "(1)"
},
	"⑵": {
	text: "(2)"
},
	"⑶": {
	text: "(3)"
},
	"⑷": {
	text: "(4)"
},
	"⑸": {
	text: "(5)"
},
	"⑹": {
	text: "(6)"
},
	"⑺": {
	text: "(7)"
},
	"⑻": {
	text: "(8)"
},
	"⑼": {
	text: "(9)"
},
	"⑽": {
	text: "(10)"
},
	"⑾": {
	text: "(11)"
},
	"⑿": {
	text: "(12)"
},
	"⒀": {
	text: "(13)"
},
	"⒁": {
	text: "(14)"
},
	"⒂": {
	text: "(15)"
},
	"⒃": {
	text: "(16)"
},
	"⒄": {
	text: "(17)"
},
	"⒅": {
	text: "(18)"
},
	"⒆": {
	text: "(19)"
},
	"⒇": {
	text: "(20)"
},
	"⒈": {
	text: "1."
},
	"⒉": {
	text: "2."
},
	"⒊": {
	text: "3."
},
	"⒋": {
	text: "4."
},
	"⒌": {
	text: "5."
},
	"⒍": {
	text: "6."
},
	"⒎": {
	text: "7."
},
	"⒏": {
	text: "8."
},
	"⒐": {
	text: "9."
},
	"⒑": {
	text: "10."
},
	"⒒": {
	text: "11."
},
	"⒓": {
	text: "12."
},
	"⒔": {
	text: "13."
},
	"⒕": {
	text: "14."
},
	"⒖": {
	text: "15."
},
	"⒗": {
	text: "16."
},
	"⒘": {
	text: "17."
},
	"⒙": {
	text: "18."
},
	"⒚": {
	text: "19."
},
	"⒛": {
	text: "20."
},
	"⒜": {
	text: "(a)"
},
	"⒝": {
	text: "(b)"
},
	"⒞": {
	text: "(c)"
},
	"⒟": {
	text: "(d)"
},
	"⒠": {
	text: "(e)"
},
	"⒡": {
	text: "(f)"
},
	"⒢": {
	text: "(g)"
},
	"⒣": {
	text: "(h)"
},
	"⒤": {
	text: "(i)"
},
	"⒥": {
	text: "(j)"
},
	"⒦": {
	text: "(k)"
},
	"⒧": {
	text: "(l)"
},
	"⒨": {
	text: "(m)"
},
	"⒩": {
	text: "(n)"
},
	"⒪": {
	text: "(o)"
},
	"⒫": {
	text: "(p)"
},
	"⒬": {
	text: "(q)"
},
	"⒭": {
	text: "(r)"
},
	"⒮": {
	text: "(s)"
},
	"⒯": {
	text: "(t)"
},
	"⒰": {
	text: "(u)"
},
	"⒱": {
	text: "(v)"
},
	"⒲": {
	text: "(w)"
},
	"⒳": {
	text: "(x)"
},
	"⒴": {
	text: "(y)"
},
	"⒵": {
	text: "(z)"
},
	"Ⓐ": {
	text: "(A)"
},
	"Ⓑ": {
	text: "(B)"
},
	"Ⓒ": {
	text: "(C)"
},
	"Ⓓ": {
	text: "(D)"
},
	"Ⓔ": {
	text: "(E)"
},
	"Ⓕ": {
	text: "(F)"
},
	"Ⓖ": {
	text: "(G)"
},
	"Ⓗ": {
	text: "(H)"
},
	"Ⓘ": {
	text: "(I)"
},
	"Ⓙ": {
	text: "(J)"
},
	"Ⓚ": {
	text: "(K)"
},
	"Ⓛ": {
	text: "(L)"
},
	"Ⓜ": {
	text: "(M)"
},
	"Ⓝ": {
	text: "(N)"
},
	"Ⓞ": {
	text: "(O)"
},
	"Ⓟ": {
	text: "(P)"
},
	"Ⓠ": {
	text: "(Q)"
},
	"Ⓡ": {
	text: "(R)"
},
	"Ⓢ": {
	math: "\\circledS"
},
	"Ⓣ": {
	text: "(T)"
},
	"Ⓤ": {
	text: "(U)"
},
	"Ⓥ": {
	text: "(V)"
},
	"Ⓦ": {
	text: "(W)"
},
	"Ⓧ": {
	text: "(X)"
},
	"Ⓨ": {
	text: "(Y)"
},
	"Ⓩ": {
	text: "(Z)"
},
	"ⓐ": {
	text: "(a)"
},
	"ⓑ": {
	text: "(b)"
},
	"ⓒ": {
	text: "(c)"
},
	"ⓓ": {
	text: "(d)"
},
	"ⓔ": {
	text: "(e)"
},
	"ⓕ": {
	text: "(f)"
},
	"ⓖ": {
	text: "(g)"
},
	"ⓗ": {
	text: "(h)"
},
	"ⓘ": {
	text: "(i)"
},
	"ⓙ": {
	text: "(j)"
},
	"ⓚ": {
	text: "(k)"
},
	"ⓛ": {
	text: "(l)"
},
	"ⓜ": {
	text: "(m)"
},
	"ⓝ": {
	text: "(n)"
},
	"ⓞ": {
	text: "(o)"
},
	"ⓟ": {
	text: "(p)"
},
	"ⓠ": {
	text: "(q)"
},
	"ⓡ": {
	text: "(r)"
},
	"ⓢ": {
	text: "(s)"
},
	"ⓣ": {
	text: "(t)"
},
	"ⓤ": {
	text: "(u)"
},
	"ⓥ": {
	text: "(v)"
},
	"ⓦ": {
	text: "(w)"
},
	"ⓧ": {
	text: "(x)"
},
	"ⓨ": {
	text: "(y)"
},
	"ⓩ": {
	text: "(z)"
},
	"⓪": {
	text: "(0)"
},
	"─": {
	text: "-"
},
	"━": {
	text: "="
},
	"│": {
	text: "|"
},
	"┃": {
	text: "|"
},
	"┄": {
	text: "-"
},
	"┅": {
	text: "="
},
	"┆": {
	math: "\\Elzdshfnc"
},
	"┇": {
	text: "|"
},
	"┈": {
	text: "-"
},
	"┉": {
	text: "="
},
	"┊": {
	text: "|"
},
	"┋": {
	text: "|"
},
	"┌": {
	text: "+"
},
	"┍": {
	text: "+"
},
	"┎": {
	text: "+"
},
	"┏": {
	text: "+"
},
	"┐": {
	text: "+"
},
	"┑": {
	text: "+"
},
	"┒": {
	text: "+"
},
	"┓": {
	text: "+"
},
	"└": {
	text: "+"
},
	"┕": {
	text: "+"
},
	"┖": {
	text: "+"
},
	"┗": {
	text: "+"
},
	"┘": {
	text: "+"
},
	"┙": {
	math: "\\Elzsqfnw"
},
	"┚": {
	text: "+"
},
	"┛": {
	text: "+"
},
	"├": {
	text: "+"
},
	"┝": {
	text: "+"
},
	"┞": {
	text: "+"
},
	"┟": {
	text: "+"
},
	"┠": {
	text: "+"
},
	"┡": {
	text: "+"
},
	"┢": {
	text: "+"
},
	"┣": {
	text: "+"
},
	"┤": {
	text: "+"
},
	"┥": {
	text: "+"
},
	"┦": {
	text: "+"
},
	"┧": {
	text: "+"
},
	"┨": {
	text: "+"
},
	"┩": {
	text: "+"
},
	"┪": {
	text: "+"
},
	"┫": {
	text: "+"
},
	"┬": {
	text: "+"
},
	"┭": {
	text: "+"
},
	"┮": {
	text: "+"
},
	"┯": {
	text: "+"
},
	"┰": {
	text: "+"
},
	"┱": {
	text: "+"
},
	"┲": {
	text: "+"
},
	"┳": {
	text: "+"
},
	"┴": {
	text: "+"
},
	"┵": {
	text: "+"
},
	"┶": {
	text: "+"
},
	"┷": {
	text: "+"
},
	"┸": {
	text: "+"
},
	"┹": {
	text: "+"
},
	"┺": {
	text: "+"
},
	"┻": {
	text: "+"
},
	"┼": {
	text: "+"
},
	"┽": {
	text: "+"
},
	"┾": {
	text: "+"
},
	"┿": {
	text: "+"
},
	"╀": {
	text: "+"
},
	"╁": {
	text: "+"
},
	"╂": {
	text: "+"
},
	"╃": {
	text: "+"
},
	"╄": {
	text: "+"
},
	"╅": {
	text: "+"
},
	"╆": {
	text: "+"
},
	"╇": {
	text: "+"
},
	"╈": {
	text: "+"
},
	"╉": {
	text: "+"
},
	"╊": {
	text: "+"
},
	"╋": {
	text: "+"
},
	"╌": {
	text: "-"
},
	"╍": {
	text: "="
},
	"╎": {
	text: "|"
},
	"╏": {
	text: "|"
},
	"═": {
	text: "="
},
	"║": {
	text: "|"
},
	"╒": {
	text: "+"
},
	"╓": {
	text: "+"
},
	"╔": {
	text: "+"
},
	"╕": {
	text: "+"
},
	"╖": {
	text: "+"
},
	"╗": {
	text: "+"
},
	"╘": {
	text: "+"
},
	"╙": {
	text: "+"
},
	"╚": {
	text: "+"
},
	"╛": {
	text: "+"
},
	"╜": {
	text: "+"
},
	"╝": {
	text: "+"
},
	"╞": {
	text: "+"
},
	"╟": {
	text: "+"
},
	"╠": {
	text: "+"
},
	"╡": {
	text: "+"
},
	"╢": {
	text: "+"
},
	"╣": {
	text: "+"
},
	"╤": {
	text: "+"
},
	"╥": {
	text: "+"
},
	"╦": {
	text: "+"
},
	"╧": {
	text: "+"
},
	"╨": {
	text: "+"
},
	"╩": {
	text: "+"
},
	"╪": {
	text: "+"
},
	"╫": {
	text: "+"
},
	"╬": {
	text: "+"
},
	"╭": {
	text: "+"
},
	"╮": {
	text: "+"
},
	"╯": {
	text: "+"
},
	"╰": {
	text: "+"
},
	"╱": {
	math: "\\diagup"
},
	"╲": {
	text: "\\"
},
	"╳": {
	text: "X"
},
	"╼": {
	text: "-"
},
	"╽": {
	text: "|"
},
	"╾": {
	text: "-"
},
	"╿": {
	text: "|"
},
	"▀": {
	math: "\\blockuphalf"
},
	"▄": {
	math: "\\blocklowhalf"
},
	"█": {
	math: "\\blockfull"
},
	"▌": {
	math: "\\blocklefthalf"
},
	"▐": {
	math: "\\blockrighthalf"
},
	"░": {
	math: "\\blockqtrshaded"
},
	"▒": {
	math: "\\blockhalfshaded"
},
	"▓": {
	math: "\\blockthreeqtrshaded"
},
	"■": {
	math: "\\mdlgblksquare",
	text: "\\ding{110}"
},
	"□": {
	math: "\\square"
},
	"▢": {
	math: "\\squoval"
},
	"▣": {
	math: "\\blackinwhitesquare"
},
	"▤": {
	math: "\\squarehfill"
},
	"▥": {
	math: "\\squarevfill"
},
	"▦": {
	math: "\\squarehvfill"
},
	"▧": {
	math: "\\squarenwsefill"
},
	"▨": {
	math: "\\squareneswfill"
},
	"▩": {
	math: "\\squarecrossfill"
},
	"▪": {
	math: "\\blacksquare"
},
	"▫": {
	math: "\\smwhtsquare"
},
	"▬": {
	math: "\\hrectangleblack"
},
	"▭": {
	math: "\\fbox{~~}"
},
	"▮": {
	math: "\\vrectangleblack"
},
	"▯": {
	math: "\\Elzvrecto"
},
	"▰": {
	math: "\\parallelogramblack"
},
	"▲": {
	math: "\\bigblacktriangleup",
	text: "\\ding{115}"
},
	"△": {
	math: "\\bigtriangleup"
},
	"▴": {
	math: "\\blacktriangle"
},
	"▵": {
	math: "\\vartriangle"
},
	"▶": {
	math: "\\RHD"
},
	"▷": {
	math: "\\rhd"
},
	"▸": {
	math: "\\blacktriangleright"
},
	"▹": {
	math: "\\triangleright"
},
	"►": {
	math: "\\blackpointerright"
},
	"▻": {
	math: "\\whitepointerright"
},
	"▼": {
	math: "\\bigblacktriangledown",
	text: "\\ding{116}"
},
	"▽": {
	math: "\\bigtriangledown"
},
	"▾": {
	math: "\\blacktriangledown"
},
	"▿": {
	math: "\\triangledown"
},
	"◀": {
	math: "\\LHD"
},
	"◁": {
	math: "\\lhd"
},
	"◂": {
	math: "\\blacktriangleleft"
},
	"◃": {
	math: "\\triangleleft"
},
	"◄": {
	math: "\\blackpointerleft"
},
	"◅": {
	math: "\\whitepointerleft"
},
	"◆": {
	math: "\\Diamondblack",
	text: "\\ding{117}"
},
	"◇": {
	math: "\\Diamond"
},
	"◈": {
	math: "\\blackinwhitediamond"
},
	"◉": {
	math: "\\fisheye"
},
	"◊": {
	math: "\\lozenge"
},
	"○": {
	math: "\\bigcirc"
},
	"◌": {
	math: "\\dottedcircle"
},
	"◍": {
	math: "\\circlevertfill"
},
	"◎": {
	math: "\\bullseye"
},
	"●": {
	math: "\\CIRCLE",
	text: "\\ding{108}"
},
	"◐": {
	math: "\\Elzcirfl"
},
	"◑": {
	math: "\\Elzcirfr"
},
	"◒": {
	math: "\\Elzcirfb"
},
	"◓": {
	math: "\\circletophalfblack"
},
	"◔": {
	math: "\\circleurquadblack"
},
	"◕": {
	math: "\\blackcircleulquadwhite"
},
	"◖": {
	math: "\\LEFTCIRCLE"
},
	"◗": {
	math: "\\RIGHTCIRCLE",
	text: "\\ding{119}"
},
	"◘": {
	math: "\\Elzrvbull"
},
	"◙": {
	math: "\\inversewhitecircle"
},
	"◚": {
	math: "\\invwhiteupperhalfcircle"
},
	"◛": {
	math: "\\invwhitelowerhalfcircle"
},
	"◜": {
	math: "\\ularc"
},
	"◝": {
	math: "\\urarc"
},
	"◞": {
	math: "\\lrarc"
},
	"◟": {
	math: "\\llarc"
},
	"◠": {
	math: "\\topsemicircle"
},
	"◡": {
	math: "\\botsemicircle"
},
	"◢": {
	math: "\\lrblacktriangle"
},
	"◣": {
	math: "\\llblacktriangle"
},
	"◤": {
	math: "\\ulblacktriangle"
},
	"◥": {
	math: "\\urblacktriangle"
},
	"◦": {
	math: "\\smwhtcircle"
},
	"◧": {
	math: "\\Elzsqfl"
},
	"◨": {
	math: "\\Elzsqfr"
},
	"◩": {
	math: "\\squareulblack"
},
	"◪": {
	math: "\\Elzsqfse"
},
	"◫": {
	math: "\\boxbar"
},
	"◬": {
	math: "\\trianglecdot"
},
	"◭": {
	math: "\\triangleleftblack"
},
	"◮": {
	math: "\\trianglerightblack"
},
	"◯": {
	math: "\\bigcirc"
},
	"◰": {
	math: "\\squareulquad"
},
	"◱": {
	math: "\\squarellquad"
},
	"◲": {
	math: "\\squarelrquad"
},
	"◳": {
	math: "\\squareurquad"
},
	"◴": {
	math: "\\circleulquad"
},
	"◵": {
	math: "\\circlellquad"
},
	"◶": {
	math: "\\circlelrquad"
},
	"◷": {
	math: "\\circleurquad"
},
	"◸": {
	math: "\\ultriangle"
},
	"◹": {
	math: "\\urtriangle"
},
	"◺": {
	math: "\\lltriangle"
},
	"◻": {
	math: "\\square"
},
	"◼": {
	math: "\\blacksquare"
},
	"◽": {
	math: "\\mdsmwhtsquare"
},
	"◾": {
	math: "\\mdsmblksquare"
},
	"◿": {
	math: "\\lrtriangle"
},
	"★": {
	math: "\\bigstar",
	text: "\\ding{72}"
},
	"☆": {
	math: "\\bigwhitestar",
	text: "\\ding{73}"
},
	"☉": {
	math: "\\Sun"
},
	"☎": {
	text: "\\ding{37}"
},
	"☐": {
	math: "\\Square"
},
	"☑": {
	math: "\\CheckedBox"
},
	"☒": {
	math: "\\XBox"
},
	"☓": {
	text: "X"
},
	"☕": {
	math: "\\steaming"
},
	"☛": {
	text: "\\ding{42}"
},
	"☞": {
	math: "\\pointright",
	text: "\\ding{43}"
},
	"☠": {
	math: "\\skull"
},
	"☡": {
	math: "\\danger"
},
	"☢": {
	math: "\\radiation"
},
	"☣": {
	math: "\\biohazard"
},
	"☯": {
	math: "\\yinyang"
},
	"☹": {
	math: "\\frownie"
},
	"☺": {
	math: "\\smiley"
},
	"☻": {
	math: "\\blacksmiley"
},
	"☼": {
	math: "\\sun"
},
	"☽": {
	text: "{\\rightmoon}",
	textpackages: [
		"wasysym"
	]
},
	"☾": {
	text: "{\\leftmoon}",
	textpackages: [
		"wasysym"
	]
},
	"☿": {
	math: "\\mercury",
	text: "{\\mercury}"
},
	"♀": {
	math: "\\female",
	text: "{\\venus}"
},
	"♁": {
	math: "\\earth"
},
	"♂": {
	math: "\\male",
	text: "{\\male}"
},
	"♃": {
	math: "\\jupiter",
	text: "{\\jupiter}"
},
	"♄": {
	math: "\\saturn",
	text: "{\\saturn}"
},
	"♅": {
	math: "\\uranus",
	text: "{\\uranus}"
},
	"♆": {
	math: "\\neptune",
	text: "{\\neptune}"
},
	"♇": {
	math: "\\pluto",
	text: "{\\pluto}"
},
	"♈": {
	math: "\\aries",
	text: "{\\aries}"
},
	"♉": {
	math: "\\taurus",
	text: "{\\taurus}"
},
	"♊": {
	math: "\\gemini",
	text: "{\\gemini}"
},
	"♋": {
	math: "\\cancer",
	text: "{\\cancer}"
},
	"♌": {
	math: "\\leo",
	text: "{\\leo}"
},
	"♍": {
	math: "\\virgo",
	text: "{\\virgo}"
},
	"♎": {
	math: "\\libra",
	text: "{\\libra}"
},
	"♏": {
	math: "\\scorpio",
	text: "{\\scorpio}"
},
	"♐": {
	math: "\\sagittarius",
	text: "{\\sagittarius}"
},
	"♑": {
	math: "\\capricornus",
	text: "{\\capricornus}"
},
	"♒": {
	math: "\\aquarius",
	text: "{\\aquarius}"
},
	"♓": {
	math: "\\pisces",
	text: "{\\pisces}"
},
	"♠": {
	math: "\\spadesuit",
	text: "\\ding{171}"
},
	"♡": {
	math: "\\heartsuit"
},
	"♢": {
	math: "\\diamond"
},
	"♣": {
	math: "\\clubsuit",
	text: "\\ding{168}"
},
	"♤": {
	math: "\\varspadesuit"
},
	"♥": {
	math: "\\varheartsuit",
	text: "\\ding{170}"
},
	"♦": {
	math: "\\vardiamondsuit",
	text: "\\ding{169}"
},
	"♧": {
	math: "\\varclubsuit"
},
	"♩": {
	math: "\\quarternote",
	text: "{\\quarternote}"
},
	"♪": {
	math: "\\eighthnote",
	text: "{\\eighthnote}"
},
	"♫": {
	math: "\\twonotes"
},
	"♬": {
	math: "\\sixteenthnote"
},
	"♭": {
	math: "\\flat"
},
	"♮": {
	math: "\\natural"
},
	"♯": {
	math: "\\sharp"
},
	"♻": {
	math: "\\recycle"
},
	"♾": {
	math: "\\acidfree"
},
	"⚀": {
	math: "\\dicei"
},
	"⚁": {
	math: "\\diceii"
},
	"⚂": {
	math: "\\diceiii"
},
	"⚃": {
	math: "\\diceiv"
},
	"⚄": {
	math: "\\dicev"
},
	"⚅": {
	math: "\\dicevi"
},
	"⚆": {
	math: "\\circledrightdot"
},
	"⚇": {
	math: "\\circledtwodots"
},
	"⚈": {
	math: "\\blackcircledrightdot"
},
	"⚉": {
	math: "\\blackcircledtwodots"
},
	"⚓": {
	math: "\\anchor"
},
	"⚔": {
	math: "\\swords"
},
	"⚠": {
	math: "\\warning"
},
	"⚥": {
	math: "\\Hermaphrodite"
},
	"⚪": {
	math: "\\medcirc"
},
	"⚫": {
	math: "\\medbullet"
},
	"⚬": {
	math: "\\mdsmwhtcircle"
},
	"⚲": {
	math: "\\neuter"
},
	"✁": {
	text: "\\ding{33}"
},
	"✂": {
	text: "\\ding{34}"
},
	"✃": {
	text: "\\ding{35}"
},
	"✄": {
	text: "\\ding{36}"
},
	"✆": {
	text: "\\ding{38}"
},
	"✇": {
	text: "\\ding{39}"
},
	"✈": {
	text: "\\ding{40}"
},
	"✉": {
	text: "\\ding{41}"
},
	"✌": {
	text: "\\ding{44}"
},
	"✍": {
	text: "\\ding{45}"
},
	"✎": {
	math: "\\pencil",
	text: "\\ding{46}"
},
	"✏": {
	text: "\\ding{47}"
},
	"✐": {
	text: "\\ding{48}"
},
	"✑": {
	text: "\\ding{49}"
},
	"✒": {
	text: "\\ding{50}"
},
	"✓": {
	math: "\\checkmark",
	text: "\\ding{51}"
},
	"✔": {
	text: "\\ding{52}"
},
	"✕": {
	text: "\\ding{53}"
},
	"✖": {
	text: "\\ding{54}"
},
	"✗": {
	math: "\\ballotx",
	text: "\\ding{55}"
},
	"✘": {
	text: "\\ding{56}"
},
	"✙": {
	text: "\\ding{57}"
},
	"✚": {
	text: "\\ding{58}"
},
	"✛": {
	text: "\\ding{59}"
},
	"✜": {
	text: "\\ding{60}"
},
	"✝": {
	text: "\\ding{61}"
},
	"✞": {
	text: "\\ding{62}"
},
	"✟": {
	text: "\\ding{63}"
},
	"✠": {
	math: "\\maltese",
	text: "\\ding{64}"
},
	"✡": {
	text: "\\ding{65}"
},
	"✢": {
	text: "\\ding{66}"
},
	"✣": {
	text: "\\ding{67}"
},
	"✤": {
	text: "\\ding{68}"
},
	"✥": {
	text: "\\ding{69}"
},
	"✦": {
	text: "\\ding{70}"
},
	"✧": {
	text: "\\ding{71}"
},
	"✩": {
	text: "\\ding{73}"
},
	"✪": {
	math: "\\circledstar",
	text: "\\ding{74}"
},
	"✫": {
	text: "\\ding{75}"
},
	"✬": {
	text: "\\ding{76}"
},
	"✭": {
	text: "\\ding{77}"
},
	"✮": {
	text: "\\ding{78}"
},
	"✯": {
	text: "\\ding{79}"
},
	"✰": {
	text: "\\ding{80}"
},
	"✱": {
	text: "\\ding{81}"
},
	"✲": {
	text: "\\ding{82}"
},
	"✳": {
	text: "\\ding{83}"
},
	"✴": {
	text: "\\ding{84}"
},
	"✵": {
	text: "\\ding{85}"
},
	"✶": {
	math: "\\varstar",
	text: "\\ding{86}"
},
	"✷": {
	text: "\\ding{87}"
},
	"✸": {
	text: "\\ding{88}"
},
	"✹": {
	text: "\\ding{89}"
},
	"✺": {
	text: "\\ding{90}"
},
	"✻": {
	text: "\\ding{91}"
},
	"✼": {
	text: "\\ding{92}"
},
	"✽": {
	math: "\\dingasterisk",
	text: "\\ding{93}"
},
	"✾": {
	text: "\\ding{94}"
},
	"✿": {
	text: "\\ding{95}"
},
	"❀": {
	text: "\\ding{96}"
},
	"❁": {
	text: "\\ding{97}"
},
	"❂": {
	text: "\\ding{98}"
},
	"❃": {
	text: "\\ding{99}"
},
	"❄": {
	text: "\\ding{100}"
},
	"❅": {
	text: "\\ding{101}"
},
	"❆": {
	text: "\\ding{102}"
},
	"❇": {
	text: "\\ding{103}"
},
	"❈": {
	text: "\\ding{104}"
},
	"❉": {
	text: "\\ding{105}"
},
	"❊": {
	text: "\\ding{106}"
},
	"❋": {
	text: "\\ding{107}"
},
	"❍": {
	text: "\\ding{109}"
},
	"❏": {
	text: "\\ding{111}"
},
	"❐": {
	text: "\\ding{112}"
},
	"❑": {
	text: "\\ding{113}"
},
	"❒": {
	text: "\\ding{114}"
},
	"❖": {
	text: "\\ding{118}"
},
	"❘": {
	text: "\\ding{120}"
},
	"❙": {
	text: "\\ding{121}"
},
	"❚": {
	text: "\\ding{122}"
},
	"❛": {
	text: "\\ding{123}"
},
	"❜": {
	text: "\\ding{124}"
},
	"❝": {
	text: "\\ding{125}"
},
	"❞": {
	text: "\\ding{126}"
},
	"❡": {
	text: "\\ding{161}"
},
	"❢": {
	text: "\\ding{162}"
},
	"❣": {
	text: "\\ding{163}"
},
	"❤": {
	text: "\\ding{164}"
},
	"❥": {
	text: "\\ding{165}"
},
	"❦": {
	text: "\\ding{166}"
},
	"❧": {
	text: "\\ding{167}"
},
	"❲": {
	math: "\\lbrbrak"
},
	"❳": {
	math: "\\rbrbrak"
},
	"❶": {
	text: "\\ding{182}"
},
	"❷": {
	text: "\\ding{183}"
},
	"❸": {
	text: "\\ding{184}"
},
	"❹": {
	text: "\\ding{185}"
},
	"❺": {
	text: "\\ding{186}"
},
	"❻": {
	text: "\\ding{187}"
},
	"❼": {
	text: "\\ding{188}"
},
	"❽": {
	text: "\\ding{189}"
},
	"❾": {
	text: "\\ding{190}"
},
	"❿": {
	text: "\\ding{191}"
},
	"➀": {
	text: "\\ding{192}"
},
	"➁": {
	text: "\\ding{193}"
},
	"➂": {
	text: "\\ding{194}"
},
	"➃": {
	text: "\\ding{195}"
},
	"➄": {
	text: "\\ding{196}"
},
	"➅": {
	text: "\\ding{197}"
},
	"➆": {
	text: "\\ding{198}"
},
	"➇": {
	text: "\\ding{199}"
},
	"➈": {
	text: "\\ding{200}"
},
	"➉": {
	text: "\\ding{201}"
},
	"➊": {
	text: "\\ding{202}"
},
	"➋": {
	text: "\\ding{203}"
},
	"➌": {
	text: "\\ding{204}"
},
	"➍": {
	text: "\\ding{205}"
},
	"➎": {
	text: "\\ding{206}"
},
	"➏": {
	text: "\\ding{207}"
},
	"➐": {
	text: "\\ding{208}"
},
	"➑": {
	text: "\\ding{209}"
},
	"➒": {
	text: "\\ding{210}"
},
	"➓": {
	text: "\\ding{211}"
},
	"➔": {
	text: "\\ding{212}"
},
	"➘": {
	text: "\\ding{216}"
},
	"➙": {
	text: "\\ding{217}"
},
	"➚": {
	text: "\\ding{218}"
},
	"➛": {
	math: "\\draftingarrow",
	text: "\\ding{219}"
},
	"➜": {
	text: "\\ding{220}"
},
	"➝": {
	text: "\\ding{221}"
},
	"➞": {
	text: "\\ding{222}"
},
	"➟": {
	text: "\\ding{223}"
},
	"➠": {
	text: "\\ding{224}"
},
	"➡": {
	text: "\\ding{225}"
},
	"➢": {
	math: "\\arrowbullet",
	text: "\\ding{226}"
},
	"➣": {
	text: "\\ding{227}"
},
	"➤": {
	text: "\\ding{228}"
},
	"➥": {
	text: "\\ding{229}"
},
	"➦": {
	text: "\\ding{230}"
},
	"➧": {
	text: "\\ding{231}"
},
	"➨": {
	text: "\\ding{232}"
},
	"➩": {
	text: "\\ding{233}"
},
	"➪": {
	text: "\\ding{234}"
},
	"➫": {
	text: "\\ding{235}"
},
	"➬": {
	text: "\\ding{236}"
},
	"➭": {
	text: "\\ding{237}"
},
	"➮": {
	text: "\\ding{238}"
},
	"➯": {
	text: "\\ding{239}"
},
	"➱": {
	text: "\\ding{241}"
},
	"➲": {
	text: "\\ding{242}"
},
	"➳": {
	text: "\\ding{243}"
},
	"➴": {
	text: "\\ding{244}"
},
	"➵": {
	text: "\\ding{245}"
},
	"➶": {
	text: "\\ding{246}"
},
	"➷": {
	text: "\\ding{247}"
},
	"➸": {
	text: "\\ding{248}"
},
	"➹": {
	text: "\\ding{249}"
},
	"➺": {
	text: "\\ding{250}"
},
	"➻": {
	text: "\\ding{251}"
},
	"➼": {
	text: "\\ding{252}"
},
	"➽": {
	text: "\\ding{253}"
},
	"➾": {
	text: "\\ding{254}"
},
	"⟀": {
	math: "\\threedangle"
},
	"⟁": {
	math: "\\whiteinwhitetriangle"
},
	"⟂": {
	math: "\\perp"
},
	"⟃": {
	math: "\\subsetcirc"
},
	"⟄": {
	math: "\\supsetcirc"
},
	"⟅": {
	math: "\\Lbag"
},
	"⟆": {
	math: "\\Rbag"
},
	"⟇": {
	math: "\\veedot"
},
	"⟈": {
	math: "\\bsolhsub"
},
	"⟉": {
	math: "\\suphsol"
},
	"⟌": {
	math: "\\longdivision"
},
	"⟐": {
	math: "\\Diamonddot"
},
	"⟑": {
	math: "\\wedgedot"
},
	"⟒": {
	math: "\\upin"
},
	"⟓": {
	math: "\\pullback"
},
	"⟔": {
	math: "\\pushout"
},
	"⟕": {
	math: "\\leftouterjoin"
},
	"⟖": {
	math: "\\rightouterjoin"
},
	"⟗": {
	math: "\\fullouterjoin"
},
	"⟘": {
	math: "\\bigbot"
},
	"⟙": {
	math: "\\bigtop"
},
	"⟚": {
	math: "\\DashVDash"
},
	"⟛": {
	math: "\\dashVdash"
},
	"⟜": {
	math: "\\multimapinv"
},
	"⟝": {
	math: "\\vlongdash"
},
	"⟞": {
	math: "\\longdashv"
},
	"⟟": {
	math: "\\cirbot"
},
	"⟠": {
	math: "\\lozengeminus"
},
	"⟡": {
	math: "\\concavediamond"
},
	"⟢": {
	math: "\\concavediamondtickleft"
},
	"⟣": {
	math: "\\concavediamondtickright"
},
	"⟤": {
	math: "\\whitesquaretickleft"
},
	"⟥": {
	math: "\\whitesquaretickright"
},
	"⟦": {
	math: "\\llbracket"
},
	"⟧": {
	math: "\\rrbracket"
},
	"⟨": {
	math: "\\langle"
},
	"⟩": {
	math: "\\rangle"
},
	"⟪": {
	math: "\\lang"
},
	"⟫": {
	math: "\\rang"
},
	"⟬": {
	math: "\\Lbrbrak"
},
	"⟭": {
	math: "\\Rbrbrak"
},
	"⟮": {
	math: "\\lgroup"
},
	"⟯": {
	math: "\\rgroup"
},
	"⟰": {
	math: "\\UUparrow"
},
	"⟱": {
	math: "\\DDownarrow"
},
	"⟲": {
	math: "\\acwgapcirclearrow"
},
	"⟳": {
	math: "\\cwgapcirclearrow"
},
	"⟴": {
	math: "\\rightarrowonoplus"
},
	"⟵": {
	math: "\\longleftarrow"
},
	"⟶": {
	math: "\\longrightarrow"
},
	"⟷": {
	math: "\\longleftrightarrow"
},
	"⟸": {
	math: "\\Longleftarrow"
},
	"⟹": {
	math: "\\Longrightarrow"
},
	"⟺": {
	math: "\\Longleftrightarrow"
},
	"⟻": {
	math: "\\longmapsfrom"
},
	"⟼": {
	math: "\\longmapsto"
},
	"⟽": {
	math: "\\Longmapsfrom"
},
	"⟾": {
	math: "\\Longmapsto"
},
	"⟿": {
	math: "\\sim\\joinrel\\leadsto"
},
	"⤀": {
	math: "\\psur"
},
	"⤁": {
	math: "\\nVtwoheadrightarrow"
},
	"⤂": {
	math: "\\nvLeftarrow"
},
	"⤃": {
	math: "\\nvRightarrow"
},
	"⤄": {
	math: "\\nvLeftrightarrow"
},
	"⤆": {
	math: "\\Mapsfrom"
},
	"⤇": {
	math: "\\Mapsto"
},
	"⤈": {
	math: "\\downarrowbarred"
},
	"⤉": {
	math: "\\uparrowbarred"
},
	"⤊": {
	math: "\\Uuparrow"
},
	"⤋": {
	math: "\\Ddownarrow"
},
	"⤌": {
	math: "\\leftbkarrow"
},
	"⤍": {
	math: "\\rightbkarrow"
},
	"⤎": {
	math: "\\leftdbkarrow"
},
	"⤏": {
	math: "\\dbkarow"
},
	"⤐": {
	math: "\\drbkarow"
},
	"⤑": {
	math: "\\rightdotarrow"
},
	"⤒": {
	math: "\\UpArrowBar"
},
	"⤓": {
	math: "\\DownArrowBar"
},
	"⤔": {
	math: "\\pinj"
},
	"⤕": {
	math: "\\finj"
},
	"⤖": {
	math: "\\bij"
},
	"⤗": {
	math: "\\nvtwoheadrightarrowtail"
},
	"⤘": {
	math: "\\nVtwoheadrightarrowtail"
},
	"⤙": {
	math: "\\lefttail"
},
	"⤚": {
	math: "\\righttail"
},
	"⤛": {
	math: "\\leftdbltail"
},
	"⤜": {
	math: "\\rightdbltail"
},
	"⤝": {
	math: "\\diamondleftarrow"
},
	"⤞": {
	math: "\\rightarrowdiamond"
},
	"⤟": {
	math: "\\diamondleftarrowbar"
},
	"⤠": {
	math: "\\barrightarrowdiamond"
},
	"⤡": {
	math: "\\nwsearrow"
},
	"⤢": {
	math: "\\neswarrow"
},
	"⤫": {
	math: "\\rdiagovfdiag"
},
	"⤬": {
	math: "\\fdiagovrdiag"
},
	"⤭": {
	math: "\\seovnearrow"
},
	"⤮": {
	math: "\\neovsearrow"
},
	"⤯": {
	math: "\\fdiagovnearrow"
},
	"⤰": {
	math: "\\rdiagovsearrow"
},
	"⤱": {
	math: "\\neovnwarrow"
},
	"⤲": {
	math: "\\nwovnearrow"
},
	"⤴": {
	math: "\\uprightcurvearrow"
},
	"⤵": {
	math: "\\downrightcurvedarrow"
},
	"⤸": {
	math: "\\cwrightarcarrow"
},
	"⤹": {
	math: "\\acwleftarcarrow"
},
	"⤺": {
	math: "\\acwoverarcarrow"
},
	"⤻": {
	math: "\\acwunderarcarrow"
},
	"⤼": {
	math: "\\curvearrowrightminus"
},
	"⤽": {
	math: "\\curvearrowleftplus"
},
	"⤾": {
	math: "\\cwundercurvearrow"
},
	"⤿": {
	math: "\\ccwundercurvearrow"
},
	"⥀": {
	math: "\\Elolarr"
},
	"⥁": {
	math: "\\Elorarr"
},
	"⥂": {
	math: "\\ElzRlarr"
},
	"⥃": {
	math: "\\leftarrowshortrightarrow"
},
	"⥄": {
	math: "\\ElzrLarr"
},
	"⥅": {
	math: "\\rightarrowplus"
},
	"⥆": {
	math: "\\leftarrowplus"
},
	"⥇": {
	math: "\\Elzrarrx"
},
	"⥈": {
	math: "\\leftrightarrowcircle"
},
	"⥉": {
	math: "\\twoheaduparrowcircle"
},
	"⥊": {
	math: "\\leftrightharpoon"
},
	"⥋": {
	math: "\\rightleftharpoon"
},
	"⥌": {
	math: "\\updownharpoonrightleft"
},
	"⥍": {
	math: "\\updownharpoonleftright"
},
	"⥎": {
	math: "\\LeftRightVector"
},
	"⥏": {
	math: "\\RightUpDownVector"
},
	"⥐": {
	math: "\\DownLeftRightVector"
},
	"⥑": {
	math: "\\LeftUpDownVector"
},
	"⥒": {
	math: "\\LeftVectorBar"
},
	"⥓": {
	math: "\\RightVectorBar"
},
	"⥔": {
	math: "\\RightUpVectorBar"
},
	"⥕": {
	math: "\\RightDownVectorBar"
},
	"⥖": {
	math: "\\DownLeftVectorBar"
},
	"⥗": {
	math: "\\DownRightVectorBar"
},
	"⥘": {
	math: "\\LeftUpVectorBar"
},
	"⥙": {
	math: "\\LeftDownVectorBar"
},
	"⥚": {
	math: "\\LeftTeeVector"
},
	"⥛": {
	math: "\\RightTeeVector"
},
	"⥜": {
	math: "\\RightUpTeeVector"
},
	"⥝": {
	math: "\\RightDownTeeVector"
},
	"⥞": {
	math: "\\DownLeftTeeVector"
},
	"⥟": {
	math: "\\DownRightTeeVector"
},
	"⥠": {
	math: "\\LeftUpTeeVector"
},
	"⥡": {
	math: "\\LeftDownTeeVector"
},
	"⥢": {
	math: "\\leftleftharpoons"
},
	"⥣": {
	math: "\\upupharpoons"
},
	"⥤": {
	math: "\\rightrightharpoons"
},
	"⥥": {
	math: "\\downdownharpoons"
},
	"⥦": {
	math: "\\leftrightharpoonsup"
},
	"⥧": {
	math: "\\leftrightharpoonsdown"
},
	"⥨": {
	math: "\\rightleftharpoonsup"
},
	"⥩": {
	math: "\\rightleftharpoonsdown"
},
	"⥪": {
	math: "\\leftbarharpoon"
},
	"⥫": {
	math: "\\barleftharpoon"
},
	"⥬": {
	math: "\\rightbarharpoon"
},
	"⥭": {
	math: "\\barrightharpoon"
},
	"⥮": {
	math: "\\UpEquilibrium"
},
	"⥯": {
	math: "\\ReverseUpEquilibrium"
},
	"⥰": {
	math: "\\RoundImplies"
},
	"⥱": {
	math: "\\equalrightarrow"
},
	"⥲": {
	math: "\\similarrightarrow"
},
	"⥳": {
	math: "\\leftarrowsimilar"
},
	"⥴": {
	math: "\\rightarrowsimilar"
},
	"⥵": {
	math: "\\rightarrowapprox"
},
	"⥶": {
	math: "\\ltlarr"
},
	"⥷": {
	math: "\\leftarrowless"
},
	"⥸": {
	math: "\\gtrarr"
},
	"⥹": {
	math: "\\subrarr"
},
	"⥺": {
	math: "\\leftarrowsubset"
},
	"⥻": {
	math: "\\suplarr"
},
	"⥾": {
	math: "\\upfishtail"
},
	"⥿": {
	math: "\\downfishtail"
},
	"⦀": {
	math: "\\Elztfnc"
},
	"⦁": {
	math: "\\spot"
},
	"⦂": {
	math: "\\typecolon"
},
	"⦃": {
	math: "\\lBrace"
},
	"⦄": {
	math: "\\rBrace"
},
	"⦆": {
	math: "\\Elroang"
},
	"⦇": {
	math: "\\limg"
},
	"⦈": {
	math: "\\rimg"
},
	"⦉": {
	math: "\\lblot"
},
	"⦊": {
	math: "\\rblot"
},
	"⦋": {
	math: "\\lbrackubar"
},
	"⦌": {
	math: "\\rbrackubar"
},
	"⦍": {
	math: "\\lbrackultick"
},
	"⦎": {
	math: "\\rbracklrtick"
},
	"⦏": {
	math: "\\lbracklltick"
},
	"⦐": {
	math: "\\rbrackurtick"
},
	"⦑": {
	math: "\\langledot"
},
	"⦒": {
	math: "\\rangledot"
},
	"⦓": {
	math: "<\\kern-0.58em("
},
	"⦕": {
	math: "\\Lparengtr"
},
	"⦖": {
	math: "\\Rparenless"
},
	"⦗": {
	math: "\\lblkbrbrak"
},
	"⦘": {
	math: "\\rblkbrbrak"
},
	"⦙": {
	math: "\\Elzddfnc"
},
	"⦚": {
	math: "\\vzigzag"
},
	"⦛": {
	math: "\\measuredangleleft"
},
	"⦜": {
	math: "\\Angle"
},
	"⦝": {
	math: "\\rightanglemdot"
},
	"⦞": {
	math: "\\angles"
},
	"⦟": {
	math: "\\angdnr"
},
	"⦠": {
	math: "\\Elzlpargt"
},
	"⦡": {
	math: "\\sphericalangleup"
},
	"⦢": {
	math: "\\turnangle"
},
	"⦣": {
	math: "\\revangle"
},
	"⦤": {
	math: "\\angleubar"
},
	"⦥": {
	math: "\\revangleubar"
},
	"⦦": {
	math: "\\wideangledown"
},
	"⦧": {
	math: "\\wideangleup"
},
	"⦨": {
	math: "\\measanglerutone"
},
	"⦩": {
	math: "\\measanglelutonw"
},
	"⦪": {
	math: "\\measanglerdtose"
},
	"⦫": {
	math: "\\measangleldtosw"
},
	"⦬": {
	math: "\\measangleurtone"
},
	"⦭": {
	math: "\\measangleultonw"
},
	"⦮": {
	math: "\\measangledrtose"
},
	"⦯": {
	math: "\\measangledltosw"
},
	"⦰": {
	math: "\\revemptyset"
},
	"⦱": {
	math: "\\emptysetobar"
},
	"⦲": {
	math: "\\emptysetocirc"
},
	"⦳": {
	math: "\\emptysetoarr"
},
	"⦴": {
	math: "\\emptysetoarrl"
},
	"⦷": {
	math: "\\circledparallel"
},
	"⦸": {
	math: "\\circledbslash"
},
	"⦹": {
	math: "\\operp"
},
	"⦺": {
	math: "\\obot"
},
	"⦻": {
	math: "\\olcross"
},
	"⦼": {
	math: "\\odotslashdot"
},
	"⦽": {
	math: "\\uparrowoncircle"
},
	"⦾": {
	math: "\\circledwhitebullet"
},
	"⦿": {
	math: "\\circledbullet"
},
	"⧀": {
	math: "\\circledless"
},
	"⧁": {
	math: "\\circledgtr"
},
	"⧂": {
	math: "\\cirscir"
},
	"⧃": {
	math: "\\cirE"
},
	"⧄": {
	math: "\\boxslash"
},
	"⧅": {
	math: "\\boxbslash"
},
	"⧆": {
	math: "\\boxast"
},
	"⧇": {
	math: "\\boxcircle"
},
	"⧈": {
	math: "\\boxbox"
},
	"⧉": {
	math: "\\boxonbox"
},
	"⧊": {
	math: "\\ElzLap"
},
	"⧋": {
	math: "\\Elzdefas"
},
	"⧌": {
	math: "\\triangles"
},
	"⧍": {
	math: "\\triangleserifs"
},
	"⧎": {
	math: "\\rtriltri"
},
	"⧏": {
	math: "\\LeftTriangleBar"
},
	"⧏̸": {
	math: "\\NotLeftTriangleBar"
},
	"⧐": {
	math: "\\RightTriangleBar"
},
	"⧐̸": {
	math: "\\NotRightTriangleBar"
},
	"⧑": {
	math: "\\lfbowtie"
},
	"⧒": {
	math: "\\rfbowtie"
},
	"⧓": {
	math: "\\fbowtie"
},
	"⧔": {
	math: "\\lftimes"
},
	"⧕": {
	math: "\\rftimes"
},
	"⧖": {
	math: "\\hourglass"
},
	"⧗": {
	math: "\\blackhourglass"
},
	"⧘": {
	math: "\\lvzigzag"
},
	"⧙": {
	math: "\\rvzigzag"
},
	"⧚": {
	math: "\\Lvzigzag"
},
	"⧛": {
	math: "\\Rvzigzag"
},
	"⧝": {
	math: "\\tieinfty"
},
	"⧞": {
	math: "\\nvinfty"
},
	"⧟": {
	math: "\\multimapboth"
},
	"⧠": {
	math: "\\laplac"
},
	"⧡": {
	math: "\\lrtriangleeq"
},
	"⧢": {
	math: "\\shuffle"
},
	"⧣": {
	math: "\\eparsl"
},
	"⧤": {
	math: "\\smeparsl"
},
	"⧥": {
	math: "\\eqvparsl"
},
	"⧦": {
	math: "\\gleichstark"
},
	"⧧": {
	math: "\\thermod"
},
	"⧨": {
	math: "\\downtriangleleftblack"
},
	"⧩": {
	math: "\\downtrianglerightblack"
},
	"⧪": {
	math: "\\blackdiamonddownarrow"
},
	"⧫": {
	math: "\\blacklozenge"
},
	"⧬": {
	math: "\\circledownarrow"
},
	"⧭": {
	math: "\\blackcircledownarrow"
},
	"⧮": {
	math: "\\errbarsquare"
},
	"⧯": {
	math: "\\errbarblacksquare"
},
	"⧰": {
	math: "\\errbardiamond"
},
	"⧱": {
	math: "\\errbarblackdiamond"
},
	"⧲": {
	math: "\\errbarcircle"
},
	"⧳": {
	math: "\\errbarblackcircle"
},
	"⧴": {
	math: "\\RuleDelayed"
},
	"⧵": {
	math: "\\setminus"
},
	"⧶": {
	math: "\\dsol"
},
	"⧷": {
	math: "\\rsolbar"
},
	"⧸": {
	math: "\\xsol"
},
	"⧹": {
	math: "\\zhide"
},
	"⧺": {
	math: "\\doubleplus"
},
	"⧻": {
	math: "\\tripleplus"
},
	"⧼": {
	math: "\\lcurvyangle"
},
	"⧽": {
	math: "\\rcurvyangle"
},
	"⧾": {
	math: "\\tplus"
},
	"⧿": {
	math: "\\tminus"
},
	"⨀": {
	math: "\\bigodot"
},
	"⨁": {
	math: "\\bigoplus"
},
	"⨂": {
	math: "\\bigotimes"
},
	"⨃": {
	math: "\\bigcupdot"
},
	"⨄": {
	math: "\\Elxuplus"
},
	"⨅": {
	math: "\\ElzThr"
},
	"⨆": {
	math: "\\Elxsqcup"
},
	"⨇": {
	math: "\\ElzInf"
},
	"⨈": {
	math: "\\ElzSup"
},
	"⨉": {
	math: "\\varprod"
},
	"⨊": {
	math: "\\modtwosum"
},
	"⨋": {
	math: "\\sumint"
},
	"⨌": {
	math: "\\iiiint"
},
	"⨍": {
	math: "\\ElzCint"
},
	"⨎": {
	math: "\\intBar"
},
	"⨏": {
	math: "\\clockoint"
},
	"⨑": {
	math: "\\awint"
},
	"⨒": {
	math: "\\rppolint"
},
	"⨓": {
	math: "\\scpolint"
},
	"⨔": {
	math: "\\npolint"
},
	"⨕": {
	math: "\\pointint"
},
	"⨖": {
	math: "\\sqrint"
},
	"⨗": {
	math: "\\intlarhk"
},
	"⨘": {
	math: "\\intx"
},
	"⨙": {
	math: "\\intcap"
},
	"⨚": {
	math: "\\intcup"
},
	"⨛": {
	math: "\\upint"
},
	"⨜": {
	math: "\\lowint"
},
	"⨝": {
	math: "\\Join"
},
	"⨞": {
	math: "\\bigtriangleleft"
},
	"⨟": {
	math: "\\zcmp"
},
	"⨠": {
	math: "\\zpipe"
},
	"⨡": {
	math: "\\zproject"
},
	"⨢": {
	math: "\\ringplus"
},
	"⨣": {
	math: "\\plushat"
},
	"⨤": {
	math: "\\simplus"
},
	"⨦": {
	math: "\\plussim"
},
	"⨧": {
	math: "\\plussubtwo"
},
	"⨨": {
	math: "\\plustrif"
},
	"⨩": {
	math: "\\commaminus"
},
	"⨫": {
	math: "\\minusfdots"
},
	"⨬": {
	math: "\\minusrdots"
},
	"⨯": {
	math: "\\ElzTimes"
},
	"⨰": {
	math: "\\dottimes"
},
	"⨱": {
	math: "\\timesbar"
},
	"⨲": {
	math: "\\btimes"
},
	"⨳": {
	math: "\\smashtimes"
},
	"⨶": {
	math: "\\otimeshat"
},
	"⨷": {
	math: "\\Otimes"
},
	"⨸": {
	math: "\\odiv"
},
	"⨹": {
	math: "\\triangleplus"
},
	"⨺": {
	math: "\\triangleminus"
},
	"⨻": {
	math: "\\triangletimes"
},
	"⨽": {
	math: "\\intprodr"
},
	"⨾": {
	math: "\\fcmp"
},
	"⨿": {
	math: "\\amalg"
},
	"⩀": {
	math: "\\capdot"
},
	"⩁": {
	math: "\\uminus"
},
	"⩂": {
	math: "\\barcup"
},
	"⩃": {
	math: "\\barcap"
},
	"⩄": {
	math: "\\capwedge"
},
	"⩅": {
	math: "\\cupvee"
},
	"⩆": {
	math: "\\cupovercap"
},
	"⩇": {
	math: "\\capovercup"
},
	"⩈": {
	math: "\\cupbarcap"
},
	"⩉": {
	math: "\\capbarcup"
},
	"⩊": {
	math: "\\twocups"
},
	"⩋": {
	math: "\\twocaps"
},
	"⩌": {
	math: "\\closedvarcup"
},
	"⩍": {
	math: "\\closedvarcap"
},
	"⩎": {
	math: "\\Sqcap"
},
	"⩏": {
	math: "\\Sqcup"
},
	"⩐": {
	math: "\\closedvarcupsmashprod"
},
	"⩑": {
	math: "\\wedgeodot"
},
	"⩒": {
	math: "\\veeodot"
},
	"⩓": {
	math: "\\ElzAnd"
},
	"⩔": {
	math: "\\ElzOr"
},
	"⩖": {
	math: "\\ElOr"
},
	"⩗": {
	math: "\\bigslopedvee"
},
	"⩘": {
	math: "\\bigslopedwedge"
},
	"⩙": {
	math: "\\veeonwedge"
},
	"⩚": {
	math: "\\wedgemidvert"
},
	"⩛": {
	math: "\\veemidvert"
},
	"⩜": {
	math: "\\midbarwedge"
},
	"⩝": {
	math: "\\midbarvee"
},
	"⩞": {
	math: "\\perspcorrespond"
},
	"⩟": {
	math: "\\Elzminhat"
},
	"⩠": {
	math: "\\wedgedoublebar"
},
	"⩡": {
	math: "\\varveebar"
},
	"⩢": {
	math: "\\doublebarvee"
},
	"⩤": {
	math: "\\dsub"
},
	"⩥": {
	math: "\\rsub"
},
	"⩦": {
	math: "\\eqdot"
},
	"⩧": {
	math: "\\dotequiv"
},
	"⩨": {
	math: "\\equivVert"
},
	"⩩": {
	math: "\\equivVvert"
},
	"⩪": {
	math: "\\dotsim"
},
	"⩫": {
	math: "\\simrdots"
},
	"⩬": {
	math: "\\simminussim"
},
	"⩭": {
	math: "\\congdot"
},
	"⩮": {
	math: "\\stackrel{*}{=}"
},
	"⩯": {
	math: "\\hatapprox"
},
	"⩰": {
	math: "\\approxeqq"
},
	"⩱": {
	math: "\\eqqplus"
},
	"⩲": {
	math: "\\pluseqq"
},
	"⩳": {
	math: "\\eqqsim"
},
	"⩴": {
	math: "\\Coloneqq"
},
	"⩵": {
	math: "\\Equal"
},
	"⩶": {
	math: "\\Same"
},
	"⩷": {
	math: "\\ddotseq"
},
	"⩸": {
	math: "\\equivDD"
},
	"⩹": {
	math: "\\ltcir"
},
	"⩺": {
	math: "\\gtcir"
},
	"⩻": {
	math: "\\ltquest"
},
	"⩼": {
	math: "\\gtquest"
},
	"⩽": {
	math: "\\leqslant",
	mathpackages: [
		"amssymb"
	]
},
	"⩽̸": {
	math: "\\nleqslant",
	mathpackages: [
		"amssymb"
	]
},
	"⩾": {
	math: "\\geqslant",
	mathpackages: [
		"amssymb"
	]
},
	"⩾̸": {
	math: "\\ngeqslant",
	mathpackages: [
		"amssymb"
	]
},
	"⩿": {
	math: "\\lesdot"
},
	"⪀": {
	math: "\\gesdot"
},
	"⪁": {
	math: "\\lesdoto"
},
	"⪂": {
	math: "\\gesdoto"
},
	"⪃": {
	math: "\\lesdotor"
},
	"⪄": {
	math: "\\gesdotol"
},
	"⪅": {
	math: "\\lessapprox"
},
	"⪆": {
	math: "\\gtrapprox"
},
	"⪇": {
	math: "\\lneq"
},
	"⪈": {
	math: "\\gneq"
},
	"⪉": {
	math: "\\lnapprox"
},
	"⪊": {
	math: "\\gnapprox"
},
	"⪋": {
	math: "\\lesseqqgtr"
},
	"⪌": {
	math: "\\gtreqqless"
},
	"⪍": {
	math: "\\lsime"
},
	"⪎": {
	math: "\\gsime"
},
	"⪏": {
	math: "\\lsimg"
},
	"⪐": {
	math: "\\gsiml"
},
	"⪑": {
	math: "\\lgE"
},
	"⪒": {
	math: "\\glE"
},
	"⪓": {
	math: "\\lesges"
},
	"⪔": {
	math: "\\gesles"
},
	"⪕": {
	math: "\\eqslantless"
},
	"⪖": {
	math: "\\eqslantgtr"
},
	"⪗": {
	math: "\\elsdot"
},
	"⪘": {
	math: "\\egsdot"
},
	"⪙": {
	math: "\\eqqless"
},
	"⪚": {
	math: "\\eqqgtr"
},
	"⪛": {
	math: "\\eqqslantless"
},
	"⪜": {
	math: "\\eqqslantgtr"
},
	"⪝": {
	math: "\\Pisymbol{ppi020}{117}"
},
	"⪞": {
	math: "\\Pisymbol{ppi020}{105}"
},
	"⪟": {
	math: "\\simlE"
},
	"⪠": {
	math: "\\simgE"
},
	"⪡": {
	math: "\\NestedLessLess"
},
	"⪡̸": {
	math: "\\NotNestedLessLess"
},
	"⪢": {
	math: "\\NestedGreaterGreater"
},
	"⪢̸": {
	math: "\\NotNestedGreaterGreater"
},
	"⪣": {
	math: "\\partialmeetcontraction"
},
	"⪤": {
	math: "\\glj"
},
	"⪥": {
	math: "\\gla"
},
	"⪦": {
	math: "\\leftslice"
},
	"⪧": {
	math: "\\rightslice"
},
	"⪨": {
	math: "\\lescc"
},
	"⪩": {
	math: "\\gescc"
},
	"⪪": {
	math: "\\smt"
},
	"⪫": {
	math: "\\lat"
},
	"⪬": {
	math: "\\smte"
},
	"⪭": {
	math: "\\late"
},
	"⪮": {
	math: "\\bumpeqq"
},
	"⪯": {
	math: "\\preceq"
},
	"⪯̸": {
	math: "\\not\\preceq"
},
	"⪰": {
	math: "\\succeq"
},
	"⪰̸": {
	math: "\\not\\succeq"
},
	"⪱": {
	math: "\\precneq"
},
	"⪲": {
	math: "\\succneq"
},
	"⪳": {
	math: "\\preceqq"
},
	"⪴": {
	math: "\\succeqq"
},
	"⪵": {
	math: "\\precneqq"
},
	"⪶": {
	math: "\\succneqq"
},
	"⪷": {
	math: "\\precapprox"
},
	"⪸": {
	math: "\\succapprox"
},
	"⪹": {
	math: "\\precnapprox"
},
	"⪺": {
	math: "\\succnapprox"
},
	"⪻": {
	math: "\\llcurly"
},
	"⪼": {
	math: "\\ggcurly"
},
	"⪽": {
	math: "\\subsetdot"
},
	"⪾": {
	math: "\\supsetdot"
},
	"⪿": {
	math: "\\subsetplus"
},
	"⫀": {
	math: "\\supsetplus"
},
	"⫁": {
	math: "\\submult"
},
	"⫂": {
	math: "\\supmult"
},
	"⫃": {
	math: "\\subedot"
},
	"⫄": {
	math: "\\supedot"
},
	"⫅": {
	math: "\\subseteqq"
},
	"⫅̸": {
	math: "\\nsubseteqq"
},
	"⫆": {
	math: "\\supseteqq"
},
	"⫆̸": {
	math: "\\nsupseteqq"
},
	"⫇": {
	math: "\\subsim"
},
	"⫈": {
	math: "\\supsim"
},
	"⫉": {
	math: "\\subsetapprox"
},
	"⫊": {
	math: "\\supsetapprox"
},
	"⫋": {
	math: "\\subsetneqq"
},
	"⫌": {
	math: "\\supsetneqq"
},
	"⫍": {
	math: "\\lsqhook"
},
	"⫎": {
	math: "\\rsqhook"
},
	"⫏": {
	math: "\\csub"
},
	"⫐": {
	math: "\\csup"
},
	"⫑": {
	math: "\\csube"
},
	"⫒": {
	math: "\\csupe"
},
	"⫓": {
	math: "\\subsup"
},
	"⫔": {
	math: "\\supsub"
},
	"⫕": {
	math: "\\subsub"
},
	"⫖": {
	math: "\\supsup"
},
	"⫗": {
	math: "\\suphsub"
},
	"⫘": {
	math: "\\supdsub"
},
	"⫙": {
	math: "\\forkv"
},
	"⫚": {
	math: "\\topfork"
},
	"⫛": {
	math: "\\mlcp"
},
	"⫝̸": {
	math: "\\forks"
},
	"⫝": {
	math: "\\forksnot"
},
	"⫝̸": {
	math: "\\forks"
},
	"⫞": {
	math: "\\shortlefttack"
},
	"⫟": {
	math: "\\shortdowntack"
},
	"⫠": {
	math: "\\shortuptack"
},
	"⫡": {
	math: "\\perps"
},
	"⫢": {
	math: "\\vDdash"
},
	"⫣": {
	math: "\\dashV"
},
	"⫤": {
	math: "\\Dashv"
},
	"⫥": {
	math: "\\DashV"
},
	"⫦": {
	math: "\\varVdash"
},
	"⫧": {
	math: "\\Barv"
},
	"⫨": {
	math: "\\vBar"
},
	"⫩": {
	math: "\\vBarv"
},
	"⫪": {
	math: "\\Top"
},
	"⫬": {
	math: "\\Not"
},
	"⫭": {
	math: "\\bNot"
},
	"⫮": {
	math: "\\revnmid"
},
	"⫯": {
	math: "\\cirmid"
},
	"⫰": {
	math: "\\midcir"
},
	"⫱": {
	math: "\\topcir"
},
	"⫲": {
	math: "\\nhpar"
},
	"⫳": {
	math: "\\parsim"
},
	"⫴": {
	math: "\\interleave"
},
	"⫵": {
	math: "\\nhVvert"
},
	"⫶": {
	math: "\\Elztdcol"
},
	"⫷": {
	math: "\\lllnest"
},
	"⫸": {
	math: "\\gggnest"
},
	"⫹": {
	math: "\\leqqslant"
},
	"⫺": {
	math: "\\geqqslant"
},
	"⫻": {
	math: "\\trslash"
},
	"⫼": {
	math: "\\biginterleave"
},
	"⫽": {
	math: "{{/}\\!\\!{/}}"
},
	"⫽⃥": {
	math: "{\\rlap{\\textbackslash}{{/}\\!\\!{/}}}"
},
	"⫾": {
	math: "\\talloblong"
},
	"⫿": {
	math: "\\bigtalloblong"
},
	"⬒": {
	math: "\\squaretopblack"
},
	"⬓": {
	math: "\\squarebotblack"
},
	"⬔": {
	math: "\\squareurblack"
},
	"⬕": {
	math: "\\squarellblack"
},
	"⬖": {
	math: "\\diamondleftblack"
},
	"⬗": {
	math: "\\diamondrightblack"
},
	"⬘": {
	math: "\\diamondtopblack"
},
	"⬙": {
	math: "\\diamondbotblack"
},
	"⬚": {
	math: "\\dottedsquare"
},
	"⬛": {
	math: "\\blacksquare"
},
	"⬜": {
	math: "\\square"
},
	"⬝": {
	math: "\\vysmblksquare"
},
	"⬞": {
	math: "\\vysmwhtsquare"
},
	"⬟": {
	math: "\\pentagonblack"
},
	"⬠": {
	math: "\\pentagon"
},
	"⬡": {
	math: "\\varhexagon"
},
	"⬢": {
	math: "\\varhexagonblack"
},
	"⬣": {
	math: "\\hexagonblack"
},
	"⬤": {
	math: "\\lgblkcircle"
},
	"⬥": {
	math: "\\mdblkdiamond"
},
	"⬦": {
	math: "\\mdwhtdiamond"
},
	"⬧": {
	math: "\\mdblklozenge"
},
	"⬨": {
	math: "\\mdwhtlozenge"
},
	"⬩": {
	math: "\\smblkdiamond"
},
	"⬪": {
	math: "\\smblklozenge"
},
	"⬫": {
	math: "\\smwhtlozenge"
},
	"⬬": {
	math: "\\blkhorzoval"
},
	"⬭": {
	math: "\\whthorzoval"
},
	"⬮": {
	math: "\\blkvertoval"
},
	"⬯": {
	math: "\\whtvertoval"
},
	"⬰": {
	math: "\\circleonleftarrow"
},
	"⬱": {
	math: "\\leftthreearrows"
},
	"⬲": {
	math: "\\leftarrowonoplus"
},
	"⬳": {
	math: "\\longleftsquigarrow"
},
	"⬴": {
	math: "\\nvtwoheadleftarrow"
},
	"⬵": {
	math: "\\nVtwoheadleftarrow"
},
	"⬶": {
	math: "\\twoheadmapsfrom"
},
	"⬷": {
	math: "\\twoheadleftdbkarrow"
},
	"⬸": {
	math: "\\leftdotarrow"
},
	"⬹": {
	math: "\\nvleftarrowtail"
},
	"⬺": {
	math: "\\nVleftarrowtail"
},
	"⬻": {
	math: "\\twoheadleftarrowtail"
},
	"⬼": {
	math: "\\nvtwoheadleftarrowtail"
},
	"⬽": {
	math: "\\nVtwoheadleftarrowtail"
},
	"⬾": {
	math: "\\leftarrowx"
},
	"⬿": {
	math: "\\leftcurvedarrow"
},
	"⭀": {
	math: "\\equalleftarrow"
},
	"⭁": {
	math: "\\bsimilarleftarrow"
},
	"⭂": {
	math: "\\leftarrowbackapprox"
},
	"⭃": {
	math: "\\rightarrowgtr"
},
	"⭄": {
	math: "\\rightarrowsupset"
},
	"⭅": {
	math: "\\LLeftarrow"
},
	"⭆": {
	math: "\\RRightarrow"
},
	"⭇": {
	math: "\\bsimilarrightarrow"
},
	"⭈": {
	math: "\\rightarrowbackapprox"
},
	"⭉": {
	math: "\\similarleftarrow"
},
	"⭊": {
	math: "\\leftarrowapprox"
},
	"⭋": {
	math: "\\leftarrowbsimilar"
},
	"⭌": {
	math: "\\rightarrowbsimilar"
},
	"⭐": {
	math: "\\medwhitestar"
},
	"⭑": {
	math: "\\medblackstar"
},
	"⭒": {
	math: "\\smwhitestar"
},
	"⭓": {
	math: "\\rightpentagonblack"
},
	"⭔": {
	math: "\\rightpentagon"
},
	"〈": {
	math: "\\langle"
},
	"〉": {
	math: "\\rangle"
},
	"〒": {
	math: "\\postalmark"
},
	"〔": {
	math: "\\lbrbrak"
},
	"〕": {
	math: "\\rbrbrak"
},
	"〚": {
	math: "\\openbracketleft"
},
	"〛": {
	math: "\\openbracketright"
},
	"〰": {
	math: "\\hzigzag"
},
	"ﬀ": {
	text: "ff"
},
	"ﬁ": {
	text: "fi"
},
	"ﬂ": {
	text: "fl"
},
	"ﬃ": {
	text: "ffi"
},
	"ﬄ": {
	text: "ffl"
},
	"ﬅ": {
	text: "st"
},
	"ﬆ": {
	text: "st"
},
	"�": {
	text: "{\\dbend}"
},
	"𝐀": {
	math: "\\mathbf{A}"
},
	"𝐁": {
	math: "\\mathbf{B}"
},
	"𝐂": {
	math: "\\mathbf{C}"
},
	"𝐃": {
	math: "\\mathbf{D}"
},
	"𝐄": {
	math: "\\mathbf{E}"
},
	"𝐅": {
	math: "\\mathbf{F}"
},
	"𝐆": {
	math: "\\mathbf{G}"
},
	"𝐇": {
	math: "\\mathbf{H}"
},
	"𝐈": {
	math: "\\mathbf{I}"
},
	"𝐉": {
	math: "\\mathbf{J}"
},
	"𝐊": {
	math: "\\mathbf{K}"
},
	"𝐋": {
	math: "\\mathbf{L}"
},
	"𝐌": {
	math: "\\mathbf{M}"
},
	"𝐍": {
	math: "\\mathbf{N}"
},
	"𝐎": {
	math: "\\mathbf{O}"
},
	"𝐏": {
	math: "\\mathbf{P}"
},
	"𝐐": {
	math: "\\mathbf{Q}"
},
	"𝐑": {
	math: "\\mathbf{R}"
},
	"𝐒": {
	math: "\\mathbf{S}"
},
	"𝐓": {
	math: "\\mathbf{T}"
},
	"𝐔": {
	math: "\\mathbf{U}"
},
	"𝐕": {
	math: "\\mathbf{V}"
},
	"𝐖": {
	math: "\\mathbf{W}"
},
	"𝐗": {
	math: "\\mathbf{X}"
},
	"𝐘": {
	math: "\\mathbf{Y}"
},
	"𝐙": {
	math: "\\mathbf{Z}"
},
	"𝐚": {
	math: "\\mathbf{a}"
},
	"𝐛": {
	math: "\\mathbf{b}"
},
	"𝐜": {
	math: "\\mathbf{c}"
},
	"𝐝": {
	math: "\\mathbf{d}"
},
	"𝐞": {
	math: "\\mathbf{e}"
},
	"𝐟": {
	math: "\\mathbf{f}"
},
	"𝐠": {
	math: "\\mathbf{g}"
},
	"𝐡": {
	math: "\\mathbf{h}"
},
	"𝐢": {
	math: "\\mathbf{i}"
},
	"𝐣": {
	math: "\\mathbf{j}"
},
	"𝐤": {
	math: "\\mathbf{k}"
},
	"𝐥": {
	math: "\\mathbf{l}"
},
	"𝐦": {
	math: "\\mathbf{m}"
},
	"𝐧": {
	math: "\\mathbf{n}"
},
	"𝐨": {
	math: "\\mathbf{o}"
},
	"𝐩": {
	math: "\\mathbf{p}"
},
	"𝐪": {
	math: "\\mathbf{q}"
},
	"𝐫": {
	math: "\\mathbf{r}"
},
	"𝐬": {
	math: "\\mathbf{s}"
},
	"𝐭": {
	math: "\\mathbf{t}"
},
	"𝐮": {
	math: "\\mathbf{u}"
},
	"𝐯": {
	math: "\\mathbf{v}"
},
	"𝐰": {
	math: "\\mathbf{w}"
},
	"𝐱": {
	math: "\\mathbf{x}"
},
	"𝐲": {
	math: "\\mathbf{y}"
},
	"𝐳": {
	math: "\\mathbf{z}"
},
	"𝐴": {
	math: "\\mathsl{A}"
},
	"𝐵": {
	math: "\\mathsl{B}"
},
	"𝐶": {
	math: "\\mathsl{C}"
},
	"𝐷": {
	math: "\\mathsl{D}"
},
	"𝐸": {
	math: "\\mathsl{E}"
},
	"𝐹": {
	math: "\\mathsl{F}"
},
	"𝐺": {
	math: "\\mathsl{G}"
},
	"𝐻": {
	math: "\\mathsl{H}"
},
	"𝐼": {
	math: "\\mathsl{I}"
},
	"𝐽": {
	math: "\\mathsl{J}"
},
	"𝐾": {
	math: "\\mathsl{K}"
},
	"𝐿": {
	math: "\\mathsl{L}"
},
	"𝑀": {
	math: "\\mathsl{M}"
},
	"𝑁": {
	math: "\\mathsl{N}"
},
	"𝑂": {
	math: "\\mathsl{O}"
},
	"𝑃": {
	math: "\\mathsl{P}"
},
	"𝑄": {
	math: "\\mathsl{Q}"
},
	"𝑅": {
	math: "\\mathsl{R}"
},
	"𝑆": {
	math: "\\mathsl{S}"
},
	"𝑇": {
	math: "\\mathsl{T}"
},
	"𝑈": {
	math: "\\mathsl{U}"
},
	"𝑉": {
	math: "\\mathsl{V}"
},
	"𝑊": {
	math: "\\mathsl{W}"
},
	"𝑋": {
	math: "\\mathsl{X}"
},
	"𝑌": {
	math: "\\mathsl{Y}"
},
	"𝑍": {
	math: "\\mathsl{Z}"
},
	"𝑎": {
	math: "\\mathsl{a}"
},
	"𝑏": {
	math: "\\mathsl{b}"
},
	"𝑐": {
	math: "\\mathsl{c}"
},
	"𝑑": {
	math: "\\mathsl{d}"
},
	"𝑒": {
	math: "\\mathsl{e}"
},
	"𝑓": {
	math: "\\mathsl{f}"
},
	"𝑔": {
	math: "\\mathsl{g}"
},
	"𝑖": {
	math: "\\mathsl{i}"
},
	"𝑗": {
	math: "\\mathsl{j}"
},
	"𝑘": {
	math: "\\mathsl{k}"
},
	"𝑙": {
	math: "\\mathsl{l}"
},
	"𝑚": {
	math: "\\mathsl{m}"
},
	"𝑛": {
	math: "\\mathsl{n}"
},
	"𝑜": {
	math: "\\mathsl{o}"
},
	"𝑝": {
	math: "\\mathsl{p}"
},
	"𝑞": {
	math: "\\mathsl{q}"
},
	"𝑟": {
	math: "\\mathsl{r}"
},
	"𝑠": {
	math: "\\mathsl{s}"
},
	"𝑡": {
	math: "\\mathsl{t}"
},
	"𝑢": {
	math: "\\mathsl{u}"
},
	"𝑣": {
	math: "\\mathsl{v}"
},
	"𝑤": {
	math: "\\mathsl{w}"
},
	"𝑥": {
	math: "\\mathsl{x}"
},
	"𝑦": {
	math: "\\mathsl{y}"
},
	"𝑧": {
	math: "\\mathsl{z}"
},
	"𝑨": {
	math: "\\mathbit{A}"
},
	"𝑩": {
	math: "\\mathbit{B}"
},
	"𝑪": {
	math: "\\mathbit{C}"
},
	"𝑫": {
	math: "\\mathbit{D}"
},
	"𝑬": {
	math: "\\mathbit{E}"
},
	"𝑭": {
	math: "\\mathbit{F}"
},
	"𝑮": {
	math: "\\mathbit{G}"
},
	"𝑯": {
	math: "\\mathbit{H}"
},
	"𝑰": {
	math: "\\mathbit{I}"
},
	"𝑱": {
	math: "\\mathbit{J}"
},
	"𝑲": {
	math: "\\mathbit{K}"
},
	"𝑳": {
	math: "\\mathbit{L}"
},
	"𝑴": {
	math: "\\mathbit{M}"
},
	"𝑵": {
	math: "\\mathbit{N}"
},
	"𝑶": {
	math: "\\mathbit{O}"
},
	"𝑷": {
	math: "\\mathbit{P}"
},
	"𝑸": {
	math: "\\mathbit{Q}"
},
	"𝑹": {
	math: "\\mathbit{R}"
},
	"𝑺": {
	math: "\\mathbit{S}"
},
	"𝑻": {
	math: "\\mathbit{T}"
},
	"𝑼": {
	math: "\\mathbit{U}"
},
	"𝑽": {
	math: "\\mathbit{V}"
},
	"𝑾": {
	math: "\\mathbit{W}"
},
	"𝑿": {
	math: "\\mathbit{X}"
},
	"𝒀": {
	math: "\\mathbit{Y}"
},
	"𝒁": {
	math: "\\mathbit{Z}"
},
	"𝒂": {
	math: "\\mathbit{a}"
},
	"𝒃": {
	math: "\\mathbit{b}"
},
	"𝒄": {
	math: "\\mathbit{c}"
},
	"𝒅": {
	math: "\\mathbit{d}"
},
	"𝒆": {
	math: "\\mathbit{e}"
},
	"𝒇": {
	math: "\\mathbit{f}"
},
	"𝒈": {
	math: "\\mathbit{g}"
},
	"𝒉": {
	math: "\\mathbit{h}"
},
	"𝒊": {
	math: "\\mathbit{i}"
},
	"𝒋": {
	math: "\\mathbit{j}"
},
	"𝒌": {
	math: "\\mathbit{k}"
},
	"𝒍": {
	math: "\\mathbit{l}"
},
	"𝒎": {
	math: "\\mathbit{m}"
},
	"𝒏": {
	math: "\\mathbit{n}"
},
	"𝒐": {
	math: "\\mathbit{o}"
},
	"𝒑": {
	math: "\\mathbit{p}"
},
	"𝒒": {
	math: "\\mathbit{q}"
},
	"𝒓": {
	math: "\\mathbit{r}"
},
	"𝒔": {
	math: "\\mathbit{s}"
},
	"𝒕": {
	math: "\\mathbit{t}"
},
	"𝒖": {
	math: "\\mathbit{u}"
},
	"𝒗": {
	math: "\\mathbit{v}"
},
	"𝒘": {
	math: "\\mathbit{w}"
},
	"𝒙": {
	math: "\\mathbit{x}"
},
	"𝒚": {
	math: "\\mathbit{y}"
},
	"𝒛": {
	math: "\\mathbit{z}"
},
	"𝒜": {
	math: "\\mathscr{A}"
},
	"𝒞": {
	math: "\\mathscr{C}"
},
	"𝒟": {
	math: "\\mathscr{D}"
},
	"𝒢": {
	math: "\\mathscr{G}"
},
	"𝒥": {
	math: "\\mathscr{J}"
},
	"𝒦": {
	math: "\\mathscr{K}"
},
	"𝒩": {
	math: "\\mathscr{N}"
},
	"𝒪": {
	math: "\\mathscr{O}"
},
	"𝒫": {
	math: "\\mathscr{P}"
},
	"𝒬": {
	math: "\\mathscr{Q}"
},
	"𝒮": {
	math: "\\mathscr{S}"
},
	"𝒯": {
	math: "\\mathscr{T}"
},
	"𝒰": {
	math: "\\mathscr{U}"
},
	"𝒱": {
	math: "\\mathscr{V}"
},
	"𝒲": {
	math: "\\mathscr{W}"
},
	"𝒳": {
	math: "\\mathscr{X}"
},
	"𝒴": {
	math: "\\mathscr{Y}"
},
	"𝒵": {
	math: "\\mathscr{Z}"
},
	"𝒶": {
	math: "\\mathscr{a}"
},
	"𝒷": {
	math: "\\mathscr{b}"
},
	"𝒸": {
	math: "\\mathscr{c}"
},
	"𝒹": {
	math: "\\mathscr{d}"
},
	"𝒻": {
	math: "\\mathscr{f}"
},
	"𝒽": {
	math: "\\mathscr{h}"
},
	"𝒾": {
	math: "\\mathscr{i}"
},
	"𝒿": {
	math: "\\mathscr{j}"
},
	"𝓀": {
	math: "\\mathscr{k}"
},
	"𝓁": {
	math: "\\mathscr{l}"
},
	"𝓂": {
	math: "\\mathscr{m}"
},
	"𝓃": {
	math: "\\mathscr{n}"
},
	"𝓅": {
	math: "\\mathscr{p}"
},
	"𝓆": {
	math: "\\mathscr{q}"
},
	"𝓇": {
	math: "\\mathscr{r}"
},
	"𝓈": {
	math: "\\mathscr{s}"
},
	"𝓉": {
	math: "\\mathscr{t}"
},
	"𝓊": {
	math: "\\mathscr{u}"
},
	"𝓋": {
	math: "\\mathscr{v}"
},
	"𝓌": {
	math: "\\mathscr{w}"
},
	"𝓍": {
	math: "\\mathscr{x}"
},
	"𝓎": {
	math: "\\mathscr{y}"
},
	"𝓏": {
	math: "\\mathscr{z}"
},
	"𝓐": {
	math: "\\mathmit{A}"
},
	"𝓑": {
	math: "\\mathmit{B}"
},
	"𝓒": {
	math: "\\mathmit{C}"
},
	"𝓓": {
	math: "\\mathmit{D}"
},
	"𝓔": {
	math: "\\mathmit{E}"
},
	"𝓕": {
	math: "\\mathmit{F}"
},
	"𝓖": {
	math: "\\mathmit{G}"
},
	"𝓗": {
	math: "\\mathmit{H}"
},
	"𝓘": {
	math: "\\mathmit{I}"
},
	"𝓙": {
	math: "\\mathmit{J}"
},
	"𝓚": {
	math: "\\mathmit{K}"
},
	"𝓛": {
	math: "\\mathmit{L}"
},
	"𝓜": {
	math: "\\mathmit{M}"
},
	"𝓝": {
	math: "\\mathmit{N}"
},
	"𝓞": {
	math: "\\mathmit{O}"
},
	"𝓟": {
	math: "\\mathmit{P}"
},
	"𝓠": {
	math: "\\mathmit{Q}"
},
	"𝓡": {
	math: "\\mathmit{R}"
},
	"𝓢": {
	math: "\\mathmit{S}"
},
	"𝓣": {
	math: "\\mathmit{T}"
},
	"𝓤": {
	math: "\\mathmit{U}"
},
	"𝓥": {
	math: "\\mathmit{V}"
},
	"𝓦": {
	math: "\\mathmit{W}"
},
	"𝓧": {
	math: "\\mathmit{X}"
},
	"𝓨": {
	math: "\\mathmit{Y}"
},
	"𝓩": {
	math: "\\mathmit{Z}"
},
	"𝓪": {
	math: "\\mathmit{a}"
},
	"𝓫": {
	math: "\\mathmit{b}"
},
	"𝓬": {
	math: "\\mathmit{c}"
},
	"𝓭": {
	math: "\\mathmit{d}"
},
	"𝓮": {
	math: "\\mathmit{e}"
},
	"𝓯": {
	math: "\\mathmit{f}"
},
	"𝓰": {
	math: "\\mathmit{g}"
},
	"𝓱": {
	math: "\\mathmit{h}"
},
	"𝓲": {
	math: "\\mathmit{i}"
},
	"𝓳": {
	math: "\\mathmit{j}"
},
	"𝓴": {
	math: "\\mathmit{k}"
},
	"𝓵": {
	math: "\\mathmit{l}"
},
	"𝓶": {
	math: "\\mathmit{m}"
},
	"𝓷": {
	math: "\\mathmit{n}"
},
	"𝓸": {
	math: "\\mathmit{o}"
},
	"𝓹": {
	math: "\\mathmit{p}"
},
	"𝓺": {
	math: "\\mathmit{q}"
},
	"𝓻": {
	math: "\\mathmit{r}"
},
	"𝓼": {
	math: "\\mathmit{s}"
},
	"𝓽": {
	math: "\\mathmit{t}"
},
	"𝓾": {
	math: "\\mathmit{u}"
},
	"𝓿": {
	math: "\\mathmit{v}"
},
	"𝔀": {
	math: "\\mathmit{w}"
},
	"𝔁": {
	math: "\\mathmit{x}"
},
	"𝔂": {
	math: "\\mathmit{y}"
},
	"𝔃": {
	math: "\\mathmit{z}"
},
	"𝔄": {
	math: "\\mathfrak{A}"
},
	"𝔅": {
	math: "\\mathfrak{B}"
},
	"𝔇": {
	math: "\\mathfrak{D}"
},
	"𝔈": {
	math: "\\mathfrak{E}"
},
	"𝔉": {
	math: "\\mathfrak{F}"
},
	"𝔊": {
	math: "\\mathfrak{G}"
},
	"𝔍": {
	math: "\\mathfrak{J}"
},
	"𝔎": {
	math: "\\mathfrak{K}"
},
	"𝔏": {
	math: "\\mathfrak{L}"
},
	"𝔐": {
	math: "\\mathfrak{M}"
},
	"𝔑": {
	math: "\\mathfrak{N}"
},
	"𝔒": {
	math: "\\mathfrak{O}"
},
	"𝔓": {
	math: "\\mathfrak{P}"
},
	"𝔔": {
	math: "\\mathfrak{Q}"
},
	"𝔖": {
	math: "\\mathfrak{S}"
},
	"𝔗": {
	math: "\\mathfrak{T}"
},
	"𝔘": {
	math: "\\mathfrak{U}"
},
	"𝔙": {
	math: "\\mathfrak{V}"
},
	"𝔚": {
	math: "\\mathfrak{W}"
},
	"𝔛": {
	math: "\\mathfrak{X}"
},
	"𝔜": {
	math: "\\mathfrak{Y}"
},
	"𝔞": {
	math: "\\mathfrak{a}"
},
	"𝔟": {
	math: "\\mathfrak{b}"
},
	"𝔠": {
	math: "\\mathfrak{c}"
},
	"𝔡": {
	math: "\\mathfrak{d}"
},
	"𝔢": {
	math: "\\mathfrak{e}"
},
	"𝔣": {
	math: "\\mathfrak{f}"
},
	"𝔤": {
	math: "\\mathfrak{g}"
},
	"𝔥": {
	math: "\\mathfrak{h}"
},
	"𝔦": {
	math: "\\mathfrak{i}"
},
	"𝔧": {
	math: "\\mathfrak{j}"
},
	"𝔨": {
	math: "\\mathfrak{k}"
},
	"𝔩": {
	math: "\\mathfrak{l}"
},
	"𝔪": {
	math: "\\mathfrak{m}"
},
	"𝔫": {
	math: "\\mathfrak{n}"
},
	"𝔬": {
	math: "\\mathfrak{o}"
},
	"𝔭": {
	math: "\\mathfrak{p}"
},
	"𝔮": {
	math: "\\mathfrak{q}"
},
	"𝔯": {
	math: "\\mathfrak{r}"
},
	"𝔰": {
	math: "\\mathfrak{s}"
},
	"𝔱": {
	math: "\\mathfrak{t}"
},
	"𝔲": {
	math: "\\mathfrak{u}"
},
	"𝔳": {
	math: "\\mathfrak{v}"
},
	"𝔴": {
	math: "\\mathfrak{w}"
},
	"𝔵": {
	math: "\\mathfrak{x}"
},
	"𝔶": {
	math: "\\mathfrak{y}"
},
	"𝔷": {
	math: "\\mathfrak{z}"
},
	"𝔸": {
	math: "\\mathbb{A}"
},
	"𝔹": {
	math: "\\mathbb{B}"
},
	"𝔻": {
	math: "\\mathbb{D}"
},
	"𝔼": {
	math: "\\mathbb{E}"
},
	"𝔽": {
	math: "\\mathbb{F}"
},
	"𝔾": {
	math: "\\mathbb{G}"
},
	"𝕀": {
	math: "\\mathbb{I}"
},
	"𝕁": {
	math: "\\mathbb{J}"
},
	"𝕂": {
	math: "\\mathbb{K}"
},
	"𝕃": {
	math: "\\mathbb{L}"
},
	"𝕄": {
	math: "\\mathbb{M}"
},
	"𝕆": {
	math: "\\mathbb{O}"
},
	"𝕊": {
	math: "\\mathbb{S}"
},
	"𝕋": {
	math: "\\mathbb{T}"
},
	"𝕌": {
	math: "\\mathbb{U}"
},
	"𝕍": {
	math: "\\mathbb{V}"
},
	"𝕎": {
	math: "\\mathbb{W}"
},
	"𝕏": {
	math: "\\mathbb{X}"
},
	"𝕐": {
	math: "\\mathbb{Y}"
},
	"𝕒": {
	math: "\\mathbb{a}"
},
	"𝕓": {
	math: "\\mathbb{b}"
},
	"𝕔": {
	math: "\\mathbb{c}"
},
	"𝕕": {
	math: "\\mathbb{d}"
},
	"𝕖": {
	math: "\\mathbb{e}"
},
	"𝕗": {
	math: "\\mathbb{f}"
},
	"𝕘": {
	math: "\\mathbb{g}"
},
	"𝕙": {
	math: "\\mathbb{h}"
},
	"𝕚": {
	math: "\\mathbb{i}"
},
	"𝕛": {
	math: "\\mathbb{j}"
},
	"𝕜": {
	math: "\\mathbb{k}"
},
	"𝕝": {
	math: "\\mathbb{l}"
},
	"𝕞": {
	math: "\\mathbb{m}"
},
	"𝕟": {
	math: "\\mathbb{n}"
},
	"𝕠": {
	math: "\\mathbb{o}"
},
	"𝕡": {
	math: "\\mathbb{p}"
},
	"𝕢": {
	math: "\\mathbb{q}"
},
	"𝕣": {
	math: "\\mathbb{r}"
},
	"𝕤": {
	math: "\\mathbb{s}"
},
	"𝕥": {
	math: "\\mathbb{t}"
},
	"𝕦": {
	math: "\\mathbb{u}"
},
	"𝕧": {
	math: "\\mathbb{v}"
},
	"𝕨": {
	math: "\\mathbb{w}"
},
	"𝕩": {
	math: "\\mathbb{x}"
},
	"𝕪": {
	math: "\\mathbb{y}"
},
	"𝕫": {
	math: "\\mathbb{z}"
},
	"𝕬": {
	math: "\\mathslbb{A}"
},
	"𝕭": {
	math: "\\mathslbb{B}"
},
	"𝕮": {
	math: "\\mathslbb{C}"
},
	"𝕯": {
	math: "\\mathslbb{D}"
},
	"𝕰": {
	math: "\\mathslbb{E}"
},
	"𝕱": {
	math: "\\mathslbb{F}"
},
	"𝕲": {
	math: "\\mathslbb{G}"
},
	"𝕳": {
	math: "\\mathslbb{H}"
},
	"𝕴": {
	math: "\\mathslbb{I}"
},
	"𝕵": {
	math: "\\mathslbb{J}"
},
	"𝕶": {
	math: "\\mathslbb{K}"
},
	"𝕷": {
	math: "\\mathslbb{L}"
},
	"𝕸": {
	math: "\\mathslbb{M}"
},
	"𝕹": {
	math: "\\mathslbb{N}"
},
	"𝕺": {
	math: "\\mathslbb{O}"
},
	"𝕻": {
	math: "\\mathslbb{P}"
},
	"𝕼": {
	math: "\\mathslbb{Q}"
},
	"𝕽": {
	math: "\\mathslbb{R}"
},
	"𝕾": {
	math: "\\mathslbb{S}"
},
	"𝕿": {
	math: "\\mathslbb{T}"
},
	"𝖀": {
	math: "\\mathslbb{U}"
},
	"𝖁": {
	math: "\\mathslbb{V}"
},
	"𝖂": {
	math: "\\mathslbb{W}"
},
	"𝖃": {
	math: "\\mathslbb{X}"
},
	"𝖄": {
	math: "\\mathslbb{Y}"
},
	"𝖅": {
	math: "\\mathslbb{Z}"
},
	"𝖆": {
	math: "\\mathslbb{a}"
},
	"𝖇": {
	math: "\\mathslbb{b}"
},
	"𝖈": {
	math: "\\mathslbb{c}"
},
	"𝖉": {
	math: "\\mathslbb{d}"
},
	"𝖊": {
	math: "\\mathslbb{e}"
},
	"𝖋": {
	math: "\\mathslbb{f}"
},
	"𝖌": {
	math: "\\mathslbb{g}"
},
	"𝖍": {
	math: "\\mathslbb{h}"
},
	"𝖎": {
	math: "\\mathslbb{i}"
},
	"𝖏": {
	math: "\\mathslbb{j}"
},
	"𝖐": {
	math: "\\mathslbb{k}"
},
	"𝖑": {
	math: "\\mathslbb{l}"
},
	"𝖒": {
	math: "\\mathslbb{m}"
},
	"𝖓": {
	math: "\\mathslbb{n}"
},
	"𝖔": {
	math: "\\mathslbb{o}"
},
	"𝖕": {
	math: "\\mathslbb{p}"
},
	"𝖖": {
	math: "\\mathslbb{q}"
},
	"𝖗": {
	math: "\\mathslbb{r}"
},
	"𝖘": {
	math: "\\mathslbb{s}"
},
	"𝖙": {
	math: "\\mathslbb{t}"
},
	"𝖚": {
	math: "\\mathslbb{u}"
},
	"𝖛": {
	math: "\\mathslbb{v}"
},
	"𝖜": {
	math: "\\mathslbb{w}"
},
	"𝖝": {
	math: "\\mathslbb{x}"
},
	"𝖞": {
	math: "\\mathslbb{y}"
},
	"𝖟": {
	math: "\\mathslbb{z}"
},
	"𝖠": {
	math: "\\mathsf{A}"
},
	"𝖡": {
	math: "\\mathsf{B}"
},
	"𝖢": {
	math: "\\mathsf{C}"
},
	"𝖣": {
	math: "\\mathsf{D}"
},
	"𝖤": {
	math: "\\mathsf{E}"
},
	"𝖥": {
	math: "\\mathsf{F}"
},
	"𝖦": {
	math: "\\mathsf{G}"
},
	"𝖧": {
	math: "\\mathsf{H}"
},
	"𝖨": {
	math: "\\mathsf{I}"
},
	"𝖩": {
	math: "\\mathsf{J}"
},
	"𝖪": {
	math: "\\mathsf{K}"
},
	"𝖫": {
	math: "\\mathsf{L}"
},
	"𝖬": {
	math: "\\mathsf{M}"
},
	"𝖭": {
	math: "\\mathsf{N}"
},
	"𝖮": {
	math: "\\mathsf{O}"
},
	"𝖯": {
	math: "\\mathsf{P}"
},
	"𝖰": {
	math: "\\mathsf{Q}"
},
	"𝖱": {
	math: "\\mathsf{R}"
},
	"𝖲": {
	math: "\\mathsf{S}"
},
	"𝖳": {
	math: "\\mathsf{T}"
},
	"𝖴": {
	math: "\\mathsf{U}"
},
	"𝖵": {
	math: "\\mathsf{V}"
},
	"𝖶": {
	math: "\\mathsf{W}"
},
	"𝖷": {
	math: "\\mathsf{X}"
},
	"𝖸": {
	math: "\\mathsf{Y}"
},
	"𝖹": {
	math: "\\mathsf{Z}"
},
	"𝖺": {
	math: "\\mathsf{a}"
},
	"𝖻": {
	math: "\\mathsf{b}"
},
	"𝖼": {
	math: "\\mathsf{c}"
},
	"𝖽": {
	math: "\\mathsf{d}"
},
	"𝖾": {
	math: "\\mathsf{e}"
},
	"𝖿": {
	math: "\\mathsf{f}"
},
	"𝗀": {
	math: "\\mathsf{g}"
},
	"𝗁": {
	math: "\\mathsf{h}"
},
	"𝗂": {
	math: "\\mathsf{i}"
},
	"𝗃": {
	math: "\\mathsf{j}"
},
	"𝗄": {
	math: "\\mathsf{k}"
},
	"𝗅": {
	math: "\\mathsf{l}"
},
	"𝗆": {
	math: "\\mathsf{m}"
},
	"𝗇": {
	math: "\\mathsf{n}"
},
	"𝗈": {
	math: "\\mathsf{o}"
},
	"𝗉": {
	math: "\\mathsf{p}"
},
	"𝗊": {
	math: "\\mathsf{q}"
},
	"𝗋": {
	math: "\\mathsf{r}"
},
	"𝗌": {
	math: "\\mathsf{s}"
},
	"𝗍": {
	math: "\\mathsf{t}"
},
	"𝗎": {
	math: "\\mathsf{u}"
},
	"𝗏": {
	math: "\\mathsf{v}"
},
	"𝗐": {
	math: "\\mathsf{w}"
},
	"𝗑": {
	math: "\\mathsf{x}"
},
	"𝗒": {
	math: "\\mathsf{y}"
},
	"𝗓": {
	math: "\\mathsf{z}"
},
	"𝗔": {
	math: "\\mathsfbf{A}"
},
	"𝗕": {
	math: "\\mathsfbf{B}"
},
	"𝗖": {
	math: "\\mathsfbf{C}"
},
	"𝗗": {
	math: "\\mathsfbf{D}"
},
	"𝗘": {
	math: "\\mathsfbf{E}"
},
	"𝗙": {
	math: "\\mathsfbf{F}"
},
	"𝗚": {
	math: "\\mathsfbf{G}"
},
	"𝗛": {
	math: "\\mathsfbf{H}"
},
	"𝗜": {
	math: "\\mathsfbf{I}"
},
	"𝗝": {
	math: "\\mathsfbf{J}"
},
	"𝗞": {
	math: "\\mathsfbf{K}"
},
	"𝗟": {
	math: "\\mathsfbf{L}"
},
	"𝗠": {
	math: "\\mathsfbf{M}"
},
	"𝗡": {
	math: "\\mathsfbf{N}"
},
	"𝗢": {
	math: "\\mathsfbf{O}"
},
	"𝗣": {
	math: "\\mathsfbf{P}"
},
	"𝗤": {
	math: "\\mathsfbf{Q}"
},
	"𝗥": {
	math: "\\mathsfbf{R}"
},
	"𝗦": {
	math: "\\mathsfbf{S}"
},
	"𝗧": {
	math: "\\mathsfbf{T}"
},
	"𝗨": {
	math: "\\mathsfbf{U}"
},
	"𝗩": {
	math: "\\mathsfbf{V}"
},
	"𝗪": {
	math: "\\mathsfbf{W}"
},
	"𝗫": {
	math: "\\mathsfbf{X}"
},
	"𝗬": {
	math: "\\mathsfbf{Y}"
},
	"𝗭": {
	math: "\\mathsfbf{Z}"
},
	"𝗮": {
	math: "\\mathsfbf{a}"
},
	"𝗯": {
	math: "\\mathsfbf{b}"
},
	"𝗰": {
	math: "\\mathsfbf{c}"
},
	"𝗱": {
	math: "\\mathsfbf{d}"
},
	"𝗲": {
	math: "\\mathsfbf{e}"
},
	"𝗳": {
	math: "\\mathsfbf{f}"
},
	"𝗴": {
	math: "\\mathsfbf{g}"
},
	"𝗵": {
	math: "\\mathsfbf{h}"
},
	"𝗶": {
	math: "\\mathsfbf{i}"
},
	"𝗷": {
	math: "\\mathsfbf{j}"
},
	"𝗸": {
	math: "\\mathsfbf{k}"
},
	"𝗹": {
	math: "\\mathsfbf{l}"
},
	"𝗺": {
	math: "\\mathsfbf{m}"
},
	"𝗻": {
	math: "\\mathsfbf{n}"
},
	"𝗼": {
	math: "\\mathsfbf{o}"
},
	"𝗽": {
	math: "\\mathsfbf{p}"
},
	"𝗾": {
	math: "\\mathsfbf{q}"
},
	"𝗿": {
	math: "\\mathsfbf{r}"
},
	"𝘀": {
	math: "\\mathsfbf{s}"
},
	"𝘁": {
	math: "\\mathsfbf{t}"
},
	"𝘂": {
	math: "\\mathsfbf{u}"
},
	"𝘃": {
	math: "\\mathsfbf{v}"
},
	"𝘄": {
	math: "\\mathsfbf{w}"
},
	"𝘅": {
	math: "\\mathsfbf{x}"
},
	"𝘆": {
	math: "\\mathsfbf{y}"
},
	"𝘇": {
	math: "\\mathsfbf{z}"
},
	"𝘈": {
	math: "\\mathsfsl{A}"
},
	"𝘉": {
	math: "\\mathsfsl{B}"
},
	"𝘊": {
	math: "\\mathsfsl{C}"
},
	"𝘋": {
	math: "\\mathsfsl{D}"
},
	"𝘌": {
	math: "\\mathsfsl{E}"
},
	"𝘍": {
	math: "\\mathsfsl{F}"
},
	"𝘎": {
	math: "\\mathsfsl{G}"
},
	"𝘏": {
	math: "\\mathsfsl{H}"
},
	"𝘐": {
	math: "\\mathsfsl{I}"
},
	"𝘑": {
	math: "\\mathsfsl{J}"
},
	"𝘒": {
	math: "\\mathsfsl{K}"
},
	"𝘓": {
	math: "\\mathsfsl{L}"
},
	"𝘔": {
	math: "\\mathsfsl{M}"
},
	"𝘕": {
	math: "\\mathsfsl{N}"
},
	"𝘖": {
	math: "\\mathsfsl{O}"
},
	"𝘗": {
	math: "\\mathsfsl{P}"
},
	"𝘘": {
	math: "\\mathsfsl{Q}"
},
	"𝘙": {
	math: "\\mathsfsl{R}"
},
	"𝘚": {
	math: "\\mathsfsl{S}"
},
	"𝘛": {
	math: "\\mathsfsl{T}"
},
	"𝘜": {
	math: "\\mathsfsl{U}"
},
	"𝘝": {
	math: "\\mathsfsl{V}"
},
	"𝘞": {
	math: "\\mathsfsl{W}"
},
	"𝘟": {
	math: "\\mathsfsl{X}"
},
	"𝘠": {
	math: "\\mathsfsl{Y}"
},
	"𝘡": {
	math: "\\mathsfsl{Z}"
},
	"𝘢": {
	math: "\\mathsfsl{a}"
},
	"𝘣": {
	math: "\\mathsfsl{b}"
},
	"𝘤": {
	math: "\\mathsfsl{c}"
},
	"𝘥": {
	math: "\\mathsfsl{d}"
},
	"𝘦": {
	math: "\\mathsfsl{e}"
},
	"𝘧": {
	math: "\\mathsfsl{f}"
},
	"𝘨": {
	math: "\\mathsfsl{g}"
},
	"𝘩": {
	math: "\\mathsfsl{h}"
},
	"𝘪": {
	math: "\\mathsfsl{i}"
},
	"𝘫": {
	math: "\\mathsfsl{j}"
},
	"𝘬": {
	math: "\\mathsfsl{k}"
},
	"𝘭": {
	math: "\\mathsfsl{l}"
},
	"𝘮": {
	math: "\\mathsfsl{m}"
},
	"𝘯": {
	math: "\\mathsfsl{n}"
},
	"𝘰": {
	math: "\\mathsfsl{o}"
},
	"𝘱": {
	math: "\\mathsfsl{p}"
},
	"𝘲": {
	math: "\\mathsfsl{q}"
},
	"𝘳": {
	math: "\\mathsfsl{r}"
},
	"𝘴": {
	math: "\\mathsfsl{s}"
},
	"𝘵": {
	math: "\\mathsfsl{t}"
},
	"𝘶": {
	math: "\\mathsfsl{u}"
},
	"𝘷": {
	math: "\\mathsfsl{v}"
},
	"𝘸": {
	math: "\\mathsfsl{w}"
},
	"𝘹": {
	math: "\\mathsfsl{x}"
},
	"𝘺": {
	math: "\\mathsfsl{y}"
},
	"𝘻": {
	math: "\\mathsfsl{z}"
},
	"𝘼": {
	math: "\\mathsfbfsl{A}"
},
	"𝘽": {
	math: "\\mathsfbfsl{B}"
},
	"𝘾": {
	math: "\\mathsfbfsl{C}"
},
	"𝘿": {
	math: "\\mathsfbfsl{D}"
},
	"𝙀": {
	math: "\\mathsfbfsl{E}"
},
	"𝙁": {
	math: "\\mathsfbfsl{F}"
},
	"𝙂": {
	math: "\\mathsfbfsl{G}"
},
	"𝙃": {
	math: "\\mathsfbfsl{H}"
},
	"𝙄": {
	math: "\\mathsfbfsl{I}"
},
	"𝙅": {
	math: "\\mathsfbfsl{J}"
},
	"𝙆": {
	math: "\\mathsfbfsl{K}"
},
	"𝙇": {
	math: "\\mathsfbfsl{L}"
},
	"𝙈": {
	math: "\\mathsfbfsl{M}"
},
	"𝙉": {
	math: "\\mathsfbfsl{N}"
},
	"𝙊": {
	math: "\\mathsfbfsl{O}"
},
	"𝙋": {
	math: "\\mathsfbfsl{P}"
},
	"𝙌": {
	math: "\\mathsfbfsl{Q}"
},
	"𝙍": {
	math: "\\mathsfbfsl{R}"
},
	"𝙎": {
	math: "\\mathsfbfsl{S}"
},
	"𝙏": {
	math: "\\mathsfbfsl{T}"
},
	"𝙐": {
	math: "\\mathsfbfsl{U}"
},
	"𝙑": {
	math: "\\mathsfbfsl{V}"
},
	"𝙒": {
	math: "\\mathsfbfsl{W}"
},
	"𝙓": {
	math: "\\mathsfbfsl{X}"
},
	"𝙔": {
	math: "\\mathsfbfsl{Y}"
},
	"𝙕": {
	math: "\\mathsfbfsl{Z}"
},
	"𝙖": {
	math: "\\mathsfbfsl{a}"
},
	"𝙗": {
	math: "\\mathsfbfsl{b}"
},
	"𝙘": {
	math: "\\mathsfbfsl{c}"
},
	"𝙙": {
	math: "\\mathsfbfsl{d}"
},
	"𝙚": {
	math: "\\mathsfbfsl{e}"
},
	"𝙛": {
	math: "\\mathsfbfsl{f}"
},
	"𝙜": {
	math: "\\mathsfbfsl{g}"
},
	"𝙝": {
	math: "\\mathsfbfsl{h}"
},
	"𝙞": {
	math: "\\mathsfbfsl{i}"
},
	"𝙟": {
	math: "\\mathsfbfsl{j}"
},
	"𝙠": {
	math: "\\mathsfbfsl{k}"
},
	"𝙡": {
	math: "\\mathsfbfsl{l}"
},
	"𝙢": {
	math: "\\mathsfbfsl{m}"
},
	"𝙣": {
	math: "\\mathsfbfsl{n}"
},
	"𝙤": {
	math: "\\mathsfbfsl{o}"
},
	"𝙥": {
	math: "\\mathsfbfsl{p}"
},
	"𝙦": {
	math: "\\mathsfbfsl{q}"
},
	"𝙧": {
	math: "\\mathsfbfsl{r}"
},
	"𝙨": {
	math: "\\mathsfbfsl{s}"
},
	"𝙩": {
	math: "\\mathsfbfsl{t}"
},
	"𝙪": {
	math: "\\mathsfbfsl{u}"
},
	"𝙫": {
	math: "\\mathsfbfsl{v}"
},
	"𝙬": {
	math: "\\mathsfbfsl{w}"
},
	"𝙭": {
	math: "\\mathsfbfsl{x}"
},
	"𝙮": {
	math: "\\mathsfbfsl{y}"
},
	"𝙯": {
	math: "\\mathsfbfsl{z}"
},
	"𝙰": {
	math: "\\mathtt{A}"
},
	"𝙱": {
	math: "\\mathtt{B}"
},
	"𝙲": {
	math: "\\mathtt{C}"
},
	"𝙳": {
	math: "\\mathtt{D}"
},
	"𝙴": {
	math: "\\mathtt{E}"
},
	"𝙵": {
	math: "\\mathtt{F}"
},
	"𝙶": {
	math: "\\mathtt{G}"
},
	"𝙷": {
	math: "\\mathtt{H}"
},
	"𝙸": {
	math: "\\mathtt{I}"
},
	"𝙹": {
	math: "\\mathtt{J}"
},
	"𝙺": {
	math: "\\mathtt{K}"
},
	"𝙻": {
	math: "\\mathtt{L}"
},
	"𝙼": {
	math: "\\mathtt{M}"
},
	"𝙽": {
	math: "\\mathtt{N}"
},
	"𝙾": {
	math: "\\mathtt{O}"
},
	"𝙿": {
	math: "\\mathtt{P}"
},
	"𝚀": {
	math: "\\mathtt{Q}"
},
	"𝚁": {
	math: "\\mathtt{R}"
},
	"𝚂": {
	math: "\\mathtt{S}"
},
	"𝚃": {
	math: "\\mathtt{T}"
},
	"𝚄": {
	math: "\\mathtt{U}"
},
	"𝚅": {
	math: "\\mathtt{V}"
},
	"𝚆": {
	math: "\\mathtt{W}"
},
	"𝚇": {
	math: "\\mathtt{X}"
},
	"𝚈": {
	math: "\\mathtt{Y}"
},
	"𝚉": {
	math: "\\mathtt{Z}"
},
	"𝚊": {
	math: "\\mathtt{a}"
},
	"𝚋": {
	math: "\\mathtt{b}"
},
	"𝚌": {
	math: "\\mathtt{c}"
},
	"𝚍": {
	math: "\\mathtt{d}"
},
	"𝚎": {
	math: "\\mathtt{e}"
},
	"𝚏": {
	math: "\\mathtt{f}"
},
	"𝚐": {
	math: "\\mathtt{g}"
},
	"𝚑": {
	math: "\\mathtt{h}"
},
	"𝚒": {
	math: "\\mathtt{i}"
},
	"𝚓": {
	math: "\\mathtt{j}"
},
	"𝚔": {
	math: "\\mathtt{k}"
},
	"𝚕": {
	math: "\\mathtt{l}"
},
	"𝚖": {
	math: "\\mathtt{m}"
},
	"𝚗": {
	math: "\\mathtt{n}"
},
	"𝚘": {
	math: "\\mathtt{o}"
},
	"𝚙": {
	math: "\\mathtt{p}"
},
	"𝚚": {
	math: "\\mathtt{q}"
},
	"𝚛": {
	math: "\\mathtt{r}"
},
	"𝚜": {
	math: "\\mathtt{s}"
},
	"𝚝": {
	math: "\\mathtt{t}"
},
	"𝚞": {
	math: "\\mathtt{u}"
},
	"𝚟": {
	math: "\\mathtt{v}"
},
	"𝚠": {
	math: "\\mathtt{w}"
},
	"𝚡": {
	math: "\\mathtt{x}"
},
	"𝚢": {
	math: "\\mathtt{y}"
},
	"𝚣": {
	math: "\\mathtt{z}"
},
	"𝚤": {
	math: "\\imath"
},
	"𝚥": {
	math: "\\jmath"
},
	"𝚨": {
	math: "\\mathbf{A}"
},
	"𝚩": {
	math: "\\mathbf{B}"
},
	"𝚪": {
	math: "\\mathbf{\\Gamma}"
},
	"𝚫": {
	math: "\\mathbf{\\Delta}"
},
	"𝚬": {
	math: "\\mathbf{E}"
},
	"𝚭": {
	math: "\\mathbf{Z}"
},
	"𝚮": {
	math: "\\mathbf{H}"
},
	"𝚯": {
	math: "\\mathbf{\\Theta}"
},
	"𝚰": {
	math: "\\mathbf{I}"
},
	"𝚱": {
	math: "\\mathbf{K}"
},
	"𝚲": {
	math: "\\mathbf{\\Lambda}"
},
	"𝚳": {
	math: "M"
},
	"𝚴": {
	math: "N"
},
	"𝚵": {
	math: "\\mathbf{\\Xi}"
},
	"𝚶": {
	math: "O"
},
	"𝚷": {
	math: "\\mathbf{\\Pi}"
},
	"𝚸": {
	math: "\\mathbf{P}"
},
	"𝚹": {
	math: "\\mathbf{\\vartheta}"
},
	"𝚺": {
	math: "\\mathbf{\\Sigma}"
},
	"𝚻": {
	math: "\\mathbf{T}"
},
	"𝚼": {
	math: "\\mathbf{\\Upsilon}"
},
	"𝚽": {
	math: "\\mathbf{\\Phi}"
},
	"𝚾": {
	math: "\\mathbf{X}"
},
	"𝚿": {
	math: "\\mathbf{\\Psi}"
},
	"𝛀": {
	math: "\\mathbf{\\Omega}"
},
	"𝛁": {
	math: "\\mathbf{\\nabla}"
},
	"𝛂": {
	math: "\\mathbf{\\alpha}"
},
	"𝛃": {
	math: "\\mathbf{\\beta}"
},
	"𝛄": {
	math: "\\mathbf{\\gamma}"
},
	"𝛅": {
	math: "\\mathbf{\\delta}"
},
	"𝛆": {
	math: "\\mathbf{\\epsilon}"
},
	"𝛇": {
	math: "\\mathbf{\\zeta}"
},
	"𝛈": {
	math: "\\mathbf{\\eta}"
},
	"𝛉": {
	math: "\\mathbf{\\theta}"
},
	"𝛊": {
	math: "\\mathbf{I}"
},
	"𝛋": {
	math: "\\mathbf{K}"
},
	"𝛌": {
	math: "\\mathbf{\\lambda}"
},
	"𝛍": {
	math: "M"
},
	"𝛎": {
	math: "N"
},
	"𝛏": {
	math: "\\mathbf{\\xi}"
},
	"𝛐": {
	math: "O"
},
	"𝛑": {
	math: "\\mathbf{\\pi}"
},
	"𝛒": {
	math: "\\mathbf{P}"
},
	"𝛓": {
	math: "\\mathbf{\\varsigma}"
},
	"𝛔": {
	math: "\\mathbf{\\sigma}"
},
	"𝛕": {
	math: "\\mathbf{T}"
},
	"𝛖": {
	math: "\\mathbf{\\upsilon}"
},
	"𝛗": {
	math: "\\mathbf{\\phi}"
},
	"𝛘": {
	math: "\\mathbf{X}"
},
	"𝛙": {
	math: "\\mathbf{\\psi}"
},
	"𝛚": {
	math: "\\mathbf{\\omega}"
},
	"𝛛": {
	math: "\\partial"
},
	"𝛜": {
	math: "\\in"
},
	"𝛝": {
	math: "\\mathbf{\\vartheta}"
},
	"𝛞": {
	math: "\\mathbf{\\varkappa}"
},
	"𝛟": {
	math: "\\mathbf{\\phi}"
},
	"𝛠": {
	math: "\\mathbf{\\varrho}"
},
	"𝛡": {
	math: "\\mathbf{\\varpi}"
},
	"𝛢": {
	math: "\\mathsl{A}"
},
	"𝛣": {
	math: "\\mathsl{B}"
},
	"𝛤": {
	math: "\\mathsl{\\Gamma}"
},
	"𝛥": {
	math: "\\mathsl{\\Delta}"
},
	"𝛦": {
	math: "\\mathsl{E}"
},
	"𝛧": {
	math: "\\mathsl{Z}"
},
	"𝛨": {
	math: "\\mathsl{H}"
},
	"𝛩": {
	math: "\\mathsl{\\Theta}"
},
	"𝛪": {
	math: "\\mathsl{I}"
},
	"𝛫": {
	math: "\\mathsl{K}"
},
	"𝛬": {
	math: "\\mathsl{\\Lambda}"
},
	"𝛭": {
	math: "M"
},
	"𝛮": {
	math: "N"
},
	"𝛯": {
	math: "\\mathsl{\\Xi}"
},
	"𝛰": {
	math: "O"
},
	"𝛱": {
	math: "\\mathsl{\\Pi}"
},
	"𝛲": {
	math: "\\mathsl{P}"
},
	"𝛳": {
	math: "\\mathsl{\\Theta}"
},
	"𝛴": {
	math: "\\mathsl{\\Sigma}"
},
	"𝛵": {
	math: "\\mathsl{T}"
},
	"𝛶": {
	math: "\\mathsl{\\Upsilon}"
},
	"𝛷": {
	math: "\\mathsl{\\Phi}"
},
	"𝛸": {
	math: "\\mathsl{X}"
},
	"𝛹": {
	math: "\\mathsl{\\Psi}"
},
	"𝛺": {
	math: "\\mathsl{\\Omega}"
},
	"𝛻": {
	math: "\\mathsl{\\nabla}"
},
	"𝛼": {
	math: "\\mathsl{A}"
},
	"𝛽": {
	math: "\\mathsl{B}"
},
	"𝛾": {
	math: "\\mathsl{\\gamma}"
},
	"𝛿": {
	math: "\\mathsl{\\delta}"
},
	"𝜀": {
	math: "\\mathsl{E}"
},
	"𝜁": {
	math: "\\mathsl{Z}"
},
	"𝜂": {
	math: "\\mathsl{H}"
},
	"𝜃": {
	math: "\\mathsl{\\theta}"
},
	"𝜄": {
	math: "\\mathsl{I}"
},
	"𝜅": {
	math: "\\mathsl{K}"
},
	"𝜆": {
	math: "\\mathsl{\\lambda}"
},
	"𝜇": {
	math: "\\mu"
},
	"𝜈": {
	math: "\\nu"
},
	"𝜉": {
	math: "\\mathsl{\\xi}"
},
	"𝜊": {
	math: "o"
},
	"𝜋": {
	math: "\\mathsl{\\pi}"
},
	"𝜌": {
	math: "\\mathsl{P}"
},
	"𝜍": {
	math: "\\mathsl{\\varsigma}"
},
	"𝜎": {
	math: "\\mathsl{\\sigma}"
},
	"𝜏": {
	math: "\\mathsl{T}"
},
	"𝜐": {
	math: "\\mathsl{\\upsilon}"
},
	"𝜑": {
	math: "\\mathsl{\\varphi}"
},
	"𝜒": {
	math: "\\mathsl{X}"
},
	"𝜓": {
	math: "\\mathsl{\\psi}"
},
	"𝜔": {
	math: "\\mathsl{\\omega}"
},
	"𝜕": {
	math: "\\partial"
},
	"𝜖": {
	math: "\\in"
},
	"𝜗": {
	math: "\\mathsl{\\vartheta}"
},
	"𝜘": {
	math: "\\mathsl{\\varkappa}"
},
	"𝜙": {
	math: "\\mathsl{\\phi}"
},
	"𝜚": {
	math: "\\mathsl{\\varrho}"
},
	"𝜛": {
	math: "\\mathsl{\\varpi}"
},
	"𝜜": {
	math: "\\mathbit{A}"
},
	"𝜝": {
	math: "\\mathbit{B}"
},
	"𝜞": {
	math: "\\mathbit{\\Gamma}"
},
	"𝜟": {
	math: "\\mathbit{\\Delta}"
},
	"𝜠": {
	math: "\\mathbit{E}"
},
	"𝜡": {
	math: "\\mathbit{Z}"
},
	"𝜢": {
	math: "\\mathbit{H}"
},
	"𝜣": {
	math: "\\mathbit{\\Theta}"
},
	"𝜤": {
	math: "\\mathbit{I}"
},
	"𝜥": {
	math: "\\mathbit{K}"
},
	"𝜦": {
	math: "\\mathbit{\\Lambda}"
},
	"𝜧": {
	math: "M"
},
	"𝜨": {
	math: "N"
},
	"𝜩": {
	math: "\\mathbit{\\Xi}"
},
	"𝜪": {
	math: "O"
},
	"𝜫": {
	math: "\\mathbit{\\Pi}"
},
	"𝜬": {
	math: "\\mathbit{P}"
},
	"𝜭": {
	math: "\\mathbit{O}"
},
	"𝜮": {
	math: "\\mathbit{\\Sigma}"
},
	"𝜯": {
	math: "\\mathbit{T}"
},
	"𝜰": {
	math: "\\mathbit{\\Upsilon}"
},
	"𝜱": {
	math: "\\mathbit{\\Phi}"
},
	"𝜲": {
	math: "\\mathbit{X}"
},
	"𝜳": {
	math: "\\mathbit{\\Psi}"
},
	"𝜴": {
	math: "\\mathbit{\\Omega}"
},
	"𝜵": {
	math: "\\mathbit{\\nabla}"
},
	"𝜶": {
	math: "\\mathbit{\\alpha}"
},
	"𝜷": {
	math: "\\mathbit{\\beta}"
},
	"𝜸": {
	math: "\\mathbit{\\gamma}"
},
	"𝜹": {
	math: "\\mathbit{\\delta}"
},
	"𝜺": {
	math: "\\mathbit{\\epsilon}"
},
	"𝜻": {
	math: "\\mathbit{\\zeta}"
},
	"𝜼": {
	math: "\\mathbit{\\eta}"
},
	"𝜽": {
	math: "\\mathbit{\\theta}"
},
	"𝜾": {
	math: "\\mathbit{\\imath}"
},
	"𝜿": {
	math: "\\mathbit{\\kappa}"
},
	"𝝀": {
	math: "\\mathbit{\\lambda}"
},
	"𝝁": {
	math: "\\mu"
},
	"𝝂": {
	math: "N"
},
	"𝝃": {
	math: "\\mathbit{\\xi}"
},
	"𝝄": {
	math: "O"
},
	"𝝅": {
	math: "\\mathbit{\\pi}"
},
	"𝝆": {
	math: "\\mathbit{\\rho}"
},
	"𝝇": {
	math: "\\mathbit{\\varsigma}"
},
	"𝝈": {
	math: "\\mathbit{\\sigma}"
},
	"𝝉": {
	math: "\\mathbit{\\tau}"
},
	"𝝊": {
	math: "\\mathbit{\\upsilon}"
},
	"𝝋": {
	math: "\\mathbit{\\varphi}"
},
	"𝝌": {
	math: "\\mathbit{\\chi}"
},
	"𝝍": {
	math: "\\mathbit{\\psi}"
},
	"𝝎": {
	math: "\\mathbit{\\omega}"
},
	"𝝏": {
	math: "\\partial"
},
	"𝝐": {
	math: "\\in"
},
	"𝝑": {
	math: "\\mathbit{\\vartheta}"
},
	"𝝒": {
	math: "\\mathbit{\\varkappa}"
},
	"𝝓": {
	math: "\\mathbit{\\phi}"
},
	"𝝔": {
	math: "\\mathbit{\\varrho}"
},
	"𝝕": {
	math: "\\mathbit{\\varpi}"
},
	"𝝖": {
	math: "\\mathsfbf{A}"
},
	"𝝗": {
	math: "\\mathsfbf{B}"
},
	"𝝘": {
	math: "\\mathsfbf{\\Gamma}"
},
	"𝝙": {
	math: "\\mathsfbf{\\Delta}"
},
	"𝝚": {
	math: "\\mathsfbf{E}"
},
	"𝝛": {
	math: "\\mathsfbf{Z}"
},
	"𝝜": {
	math: "\\mathsfbf{H}"
},
	"𝝝": {
	math: "\\mathsfbf{\\Theta}"
},
	"𝝞": {
	math: "\\mathsfbf{I}"
},
	"𝝟": {
	math: "\\mathsfbf{K}"
},
	"𝝠": {
	math: "\\mathsfbf{\\Lambda}"
},
	"𝝡": {
	math: "M"
},
	"𝝢": {
	math: "N"
},
	"𝝣": {
	math: "\\mathsfbf{\\Xi}"
},
	"𝝤": {
	math: "O"
},
	"𝝥": {
	math: "\\mathsfbf{\\Pi}"
},
	"𝝦": {
	math: "\\mathsfbf{P}"
},
	"𝝧": {
	math: "\\mathsfbf{\\Theta}"
},
	"𝝨": {
	math: "\\mathsfbf{\\Sigma}"
},
	"𝝩": {
	math: "\\mathsfbf{T}"
},
	"𝝪": {
	math: "\\mathsfbf{\\Upsilon}"
},
	"𝝫": {
	math: "\\mathsfbf{\\Phi}"
},
	"𝝬": {
	math: "\\mathsfbf{X}"
},
	"𝝭": {
	math: "\\mathsfbf{\\Psi}"
},
	"𝝮": {
	math: "\\mathsfbf{\\Omega}"
},
	"𝝯": {
	math: "\\mathsfbf{\\nabla}"
},
	"𝝰": {
	math: "\\mathsfbf{\\alpha}"
},
	"𝝱": {
	math: "\\mathsfbf{\\beta}"
},
	"𝝲": {
	math: "\\mathsfbf{\\gamma}"
},
	"𝝳": {
	math: "\\mathsfbf{\\delta}"
},
	"𝝴": {
	math: "\\mathsfbf{\\varepsilon}"
},
	"𝝵": {
	math: "\\mathsfbf{\\zeta}"
},
	"𝝶": {
	math: "\\mathsfbf{\\eta}"
},
	"𝝷": {
	math: "\\mathsfbf{\\theta}"
},
	"𝝸": {
	math: "\\mathsfbf{\\imath}"
},
	"𝝹": {
	math: "\\mathsfbf{\\kappa}"
},
	"𝝺": {
	math: "\\mathsfbf{\\lambda}"
},
	"𝝻": {
	math: "\\mu"
},
	"𝝼": {
	math: "\\nu"
},
	"𝝽": {
	math: "\\mathsfbf{\\xi}"
},
	"𝝾": {
	math: "o"
},
	"𝝿": {
	math: "\\mathsfbf{\\pi}"
},
	"𝞀": {
	math: "\\mathsfbf{\\rho}"
},
	"𝞁": {
	math: "\\mathsfbf{\\varsigma}"
},
	"𝞂": {
	math: "\\mathsfbf{\\sigma}"
},
	"𝞃": {
	math: "\\mathsfbf{\\tau}"
},
	"𝞄": {
	math: "\\mathsfbf{\\upsilon}"
},
	"𝞅": {
	math: "\\mathsfbf{\\varphi}"
},
	"𝞆": {
	math: "\\mathsfbf{\\chi}"
},
	"𝞇": {
	math: "\\mathsfbf{\\psi}"
},
	"𝞈": {
	math: "\\mathsfbf{\\omega}"
},
	"𝞉": {
	math: "\\partial"
},
	"𝞊": {
	math: "\\in"
},
	"𝞋": {
	math: "\\mathsfbf{\\vartheta}"
},
	"𝞌": {
	math: "\\mathsfbf{\\varkappa}"
},
	"𝞍": {
	math: "\\mathsfbf{\\phi}"
},
	"𝞎": {
	math: "\\mathsfbf{\\varrho}"
},
	"𝞏": {
	math: "\\mathsfbf{\\varpi}"
},
	"𝞐": {
	math: "\\mathsfbfsl{A}"
},
	"𝞑": {
	math: "\\mathsfbfsl{B}"
},
	"𝞒": {
	math: "\\mathsfbfsl{\\Gamma}"
},
	"𝞓": {
	math: "\\mathsfbfsl{\\Delta}"
},
	"𝞔": {
	math: "\\mathsfbfsl{E}"
},
	"𝞕": {
	math: "\\mathsfbfsl{Z}"
},
	"𝞖": {
	math: "\\mathsfbfsl{H}"
},
	"𝞗": {
	math: "\\mathsfbfsl{\\Theta}"
},
	"𝞘": {
	math: "\\mathsfbfsl{I}"
},
	"𝞙": {
	math: "\\mathsfbfsl{K}"
},
	"𝞚": {
	math: "\\mathsfbfsl{\\Lambda}"
},
	"𝞛": {
	math: "\\mathsfbfsl{M}"
},
	"𝞜": {
	math: "\\mathsfbfsl{N}"
},
	"𝞝": {
	math: "\\mathsfbfsl{\\Xi}"
},
	"𝞞": {
	math: "\\mathsfbfsl{O}"
},
	"𝞟": {
	math: "\\mathsfbfsl{\\Pi}"
},
	"𝞠": {
	math: "\\mathsfbfsl{P}"
},
	"𝞡": {
	math: "\\mathsfbfsl{\\Theta}"
},
	"𝞢": {
	math: "\\mathsfbfsl{\\Sigma}"
},
	"𝞣": {
	math: "\\mathsfbfsl{T}"
},
	"𝞤": {
	math: "\\mathsfbfsl{\\Upsilon}"
},
	"𝞥": {
	math: "\\mathsfbfsl{\\Phi}"
},
	"𝞦": {
	math: "\\mathsfbfsl{X}"
},
	"𝞧": {
	math: "\\mathsfbfsl{\\Psi}"
},
	"𝞨": {
	math: "\\mathsfbfsl{\\Omega}"
},
	"𝞩": {
	math: "\\mathsfbfsl{\\nabla}"
},
	"𝞪": {
	math: "\\mathsfbfsl{\\alpha}"
},
	"𝞫": {
	math: "\\mathsfbfsl{\\beta}"
},
	"𝞬": {
	math: "\\mathsfbfsl{\\gamma}"
},
	"𝞭": {
	math: "\\mathsfbfsl{\\delta}"
},
	"𝞮": {
	math: "\\mathsfbfsl{\\varepsilon}"
},
	"𝞯": {
	math: "\\mathsfbfsl{\\zeta}"
},
	"𝞰": {
	math: "\\mathsfbfsl{\\eta}"
},
	"𝞱": {
	math: "\\mathsfbfsl{\\theta}"
},
	"𝞲": {
	math: "\\mathsfbfsl{\\imath}"
},
	"𝞳": {
	math: "\\mathsfbfsl{\\kappa}"
},
	"𝞴": {
	math: "\\mathsfbfsl{\\lambda}"
},
	"𝞵": {
	math: "\\mu"
},
	"𝞶": {
	math: "\\nu"
},
	"𝞷": {
	math: "\\mathsfbfsl{\\xi}"
},
	"𝞸": {
	math: "o"
},
	"𝞹": {
	math: "\\mathsfbfsl{\\pi}"
},
	"𝞺": {
	math: "\\mathsfbfsl{\\rho}"
},
	"𝞻": {
	math: "\\mathsfbfsl{\\varsigma}"
},
	"𝞼": {
	math: "\\mathsfbfsl{\\sigma}"
},
	"𝞽": {
	math: "\\mathsfbfsl{\\tau}"
},
	"𝞾": {
	math: "\\mathsfbfsl{\\upsilon}"
},
	"𝞿": {
	math: "\\mathsfbfsl{\\varphi}"
},
	"𝟀": {
	math: "\\mathsfbfsl{\\chi}"
},
	"𝟁": {
	math: "\\mathsfbfsl{\\psi}"
},
	"𝟂": {
	math: "\\mathsfbfsl{\\omega}"
},
	"𝟃": {
	math: "\\partial"
},
	"𝟄": {
	math: "\\in"
},
	"𝟅": {
	math: "\\mathsfbfsl{\\vartheta}"
},
	"𝟆": {
	math: "\\mathsfbfsl{\\varkappa}"
},
	"𝟇": {
	math: "\\mathsfbfsl{\\phi}"
},
	"𝟈": {
	math: "\\mathsfbfsl{\\varrho}"
},
	"𝟉": {
	math: "\\mathsfbfsl{\\varpi}"
},
	"𝟊": {
	math: "\\mbfDigamma"
},
	"𝟋": {
	math: "\\mbfdigamma"
},
	"𝟎": {
	math: "\\mathbf{0}"
},
	"𝟏": {
	math: "\\mathbf{1}"
},
	"𝟐": {
	math: "\\mathbf{2}"
},
	"𝟑": {
	math: "\\mathbf{3}"
},
	"𝟒": {
	math: "\\mathbf{4}"
},
	"𝟓": {
	math: "\\mathbf{5}"
},
	"𝟔": {
	math: "\\mathbf{6}"
},
	"𝟕": {
	math: "\\mathbf{7}"
},
	"𝟖": {
	math: "\\mathbf{8}"
},
	"𝟗": {
	math: "\\mathbf{9}"
},
	"𝟘": {
	math: "\\mathbb{0}"
},
	"𝟙": {
	math: "\\mathbb{1}"
},
	"𝟚": {
	math: "\\mathbb{2}"
},
	"𝟛": {
	math: "\\mathbb{3}"
},
	"𝟜": {
	math: "\\mathbb{4}"
},
	"𝟝": {
	math: "\\mathbb{5}"
},
	"𝟞": {
	math: "\\mathbb{6}"
},
	"𝟟": {
	math: "\\mathbb{7}"
},
	"𝟠": {
	math: "\\mathbb{8}"
},
	"𝟡": {
	math: "\\mathbb{9}"
},
	"𝟢": {
	math: "\\mathsf{0}"
},
	"𝟣": {
	math: "\\mathsf{1}"
},
	"𝟤": {
	math: "\\mathsf{2}"
},
	"𝟥": {
	math: "\\mathsf{3}"
},
	"𝟦": {
	math: "\\mathsf{4}"
},
	"𝟧": {
	math: "\\mathsf{5}"
},
	"𝟨": {
	math: "\\mathsf{6}"
},
	"𝟩": {
	math: "\\mathsf{7}"
},
	"𝟪": {
	math: "\\mathsf{8}"
},
	"𝟫": {
	math: "\\mathsf{9}"
},
	"𝟬": {
	math: "\\mathsfbf{0}"
},
	"𝟭": {
	math: "\\mathsfbf{1}"
},
	"𝟮": {
	math: "\\mathsfbf{2}"
},
	"𝟯": {
	math: "\\mathsfbf{3}"
},
	"𝟰": {
	math: "\\mathsfbf{4}"
},
	"𝟱": {
	math: "\\mathsfbf{5}"
},
	"𝟲": {
	math: "\\mathsfbf{6}"
},
	"𝟳": {
	math: "\\mathsfbf{7}"
},
	"𝟴": {
	math: "\\mathsfbf{8}"
},
	"𝟵": {
	math: "\\mathsfbf{9}"
},
	"𝟶": {
	math: "\\mathtt{0}"
},
	"𝟷": {
	math: "\\mathtt{1}"
},
	"𝟸": {
	math: "\\mathtt{2}"
},
	"𝟹": {
	math: "\\mathtt{3}"
},
	"𝟺": {
	math: "\\mathtt{4}"
},
	"𝟻": {
	math: "\\mathtt{5}"
},
	"𝟼": {
	math: "\\mathtt{6}"
},
	"𝟽": {
	math: "\\mathtt{7}"
},
	"𝟾": {
	math: "\\mathtt{8}"
},
	"𝟿": {
	math: "\\mathtt{9}"
}
};

var $$2 = {
	math: "\\$",
	text: "\\$"
};
var _$2 = {
	math: "\\_",
	text: "\\_"
};
var require$$2 = {
	"#": {
	math: "\\#",
	text: "\\#"
},
	$: $$2,
	"%": {
	math: "\\%",
	text: "\\%"
},
	"&": {
	math: "\\&",
	text: "\\&"
},
	"/​": {
	text: "\\slash",
	commandspacer: true
},
	"<": {
	math: "<"
},
	">": {
	math: ">"
},
	"\\": {
	math: "\\backslash",
	text: "\\textbackslash",
	commandspacer: true
},
	"^": {
	math: "\\sphat",
	text: "\\^"
},
	_: _$2,
	"{": {
	math: "\\lbrace",
	text: "\\{"
},
	"}": {
	math: "\\rbrace",
	text: "\\}"
},
	"~": {
	math: "\\sptilde",
	text: "\\textasciitilde",
	commandspacer: true
},
	" ": {
	math: "~",
	space: true,
	text: "~"
},
	" ": {
	text: " ",
	space: true
},
	" ": {
	math: "\\quad",
	space: true
},
	" ": {
	text: "\\hspace{0.6em}",
	space: true
},
	" ": {
	math: "\\quad",
	space: true,
	text: "\\hspace{1em}"
},
	" ": {
	text: "\\;",
	space: true
},
	" ": {
	text: "\\hspace{0.25em}",
	space: true
},
	" ": {
	text: "\\hspace{0.166em}",
	space: true
},
	" ": {
	text: "\\hphantom{0}",
	space: true
},
	" ": {
	text: "\\hphantom{,}",
	space: true
},
	" ": {
	text: "\\,",
	space: true
},
	" ": {
	math: "\\mkern1mu",
	space: true
},
	"​": {
	text: "\\mbox",
	commandspacer: true,
	space: true
},
	" ": {
	text: " ",
	space: true
},
	" ": {
	math: "\\:",
	space: true,
	text: "\\:"
}
};

var require$$3 = {
	"\\#": "#",
	"\\$": "$",
	"\\%": "%",
	"\\&": "&",
	"\\slash": "/​",
	"\\textless": "<",
	"\\textgreater": ">",
	"\\LaTeX": "LaTeX",
	"\\textbackslash": "\\",
	"\\backslash": "\\",
	"\\": "\\",
	"\\^": "^",
	"\\sphat": "^",
	"\\_": "_",
	"\\t{ia}": "i︠a︡",
	"{\\~ w}": "w̃",
	"\\{": "{",
	"\\lbrace": "{",
	"\\textbar": "|",
	"\\}": "}",
	"\\rbrace": "}",
	"\\textasciitilde": "~",
	"\\sptilde": "~",
	"\\textexclamdown": "¡",
	"\\textcent": "¢",
	"\\cent": "¢",
	"\\textsterling": "£",
	"\\pounds": "£",
	"\\textcurrency": "¤",
	"\\textyen": "¥",
	"\\yen": "¥",
	"\\textbrokenbar": "¦",
	"\\textsection": "§",
	"\\textasciidieresis": "¨",
	"\\spddot": "¨",
	"\\textcopyright": "©",
	"\\textordfeminine": "ª",
	"\\guillemotleft": "«",
	"\\lnot": "¬",
	"\\neg": "¬",
	"\\-": "­",
	"\\textregistered": "®",
	"\\circledR": "®",
	"\\textasciimacron": "¯",
	"\\textdegree": "°",
	"^\\circ": "°",
	"\\pm": "±",
	"^{2}": "²",
	"^{3}": "³",
	"\\textasciiacute": "´",
	"\\textmu": "µ",
	"\\textparagraph": "¶",
	"^{1}": "¹",
	"\\textordmasculine": "º",
	"\\guillemotright": "»",
	"\\frac{1}{4}": "¼",
	"\\textonequarter": "¼",
	"\\frac{1}{2}": "½",
	"\\textonehalf": "½",
	"\\frac{3}{4}": "¾",
	"\\textthreequarters": "¾",
	"\\textquestiondown": "¿",
	"\\`A": "À",
	"\\'A": "Á",
	"\\^A": "Â",
	"\\~A": "Ã",
	"\\\"A": "Ä",
	"\\AA": "Å",
	"\\r{A}": "Å",
	"{\\r A}": "Å",
	"\\AE": "Æ",
	"\\c{C}": "Ç",
	"\\`E": "È",
	"\\'E": "É",
	"\\^E": "Ê",
	"\\\"E": "Ë",
	"\\`I": "Ì",
	"\\'I": "Í",
	"\\^I": "Î",
	"\\\"I": "Ï",
	"\\DH": "Ð",
	"\\~N": "Ñ",
	"\\`O": "Ò",
	"\\'O": "Ó",
	"\\^O": "Ô",
	"\\~O": "Õ",
	"\\\"O": "Ö",
	"\\texttimes": "×",
	"\\times": "×",
	"\\O": "Ø",
	"\\`U": "Ù",
	"\\'U": "Ú",
	"\\^U": "Û",
	"\\\"U": "Ü",
	"\\'Y": "Ý",
	"\\TH": "Þ",
	"\\ss": "ß",
	"\\`a": "à",
	"\\'a": "á",
	"\\^a": "â",
	"\\~a": "ã",
	"\\\"a": "ä",
	"\\aa": "å",
	"\\r{a}": "å",
	"{\\r a}": "å",
	"\\ae": "æ",
	"\\c{c}": "ç",
	"\\`e": "è",
	"\\'e": "é",
	"\\^e": "ê",
	"\\\"e": "ë",
	"\\`i": "ì",
	"\\`\\i": "ì",
	"\\'i": "í",
	"\\'\\i": "í",
	"\\^i": "î",
	"\\^\\i": "î",
	"\\\"i": "ï",
	"\\\"\\i": "ï",
	"\\dh": "ð",
	"\\eth": "ð",
	"\\~n": "ñ",
	"\\`o": "ò",
	"\\'o": "ó",
	"\\^o": "ô",
	"\\~o": "õ",
	"\\\"o": "ö",
	"\\div": "÷",
	"\\o": "ø",
	"\\`u": "ù",
	"\\'u": "ú",
	"\\^u": "û",
	"\\\"u": "ü",
	"\\'y": "ý",
	"\\th": "þ",
	"\\\"y": "ÿ",
	"\\=A": "Ā",
	"\\=a": "ā",
	"\\u{A}": "Ă",
	"\\u{a}": "ă",
	"\\k{A}": "Ą",
	"\\k{a}": "ą",
	"\\'C": "Ć",
	"\\'c": "ć",
	"\\^C": "Ĉ",
	"\\^c": "ĉ",
	"\\.C": "Ċ",
	"\\.c": "ċ",
	"\\v{C}": "Č",
	"\\v{c}": "č",
	"\\v{D}": "Ď",
	"\\v{d}": "ď",
	"\\DJ": "Đ",
	"\\dj": "đ",
	"\\=E": "Ē",
	"\\=e": "ē",
	"\\u{E}": "Ĕ",
	"\\u{e}": "ĕ",
	"\\.E": "Ė",
	"\\.e": "ė",
	"\\k{E}": "Ę",
	"\\k{e}": "ę",
	"\\v{E}": "Ě",
	"\\v{e}": "ě",
	"\\^G": "Ĝ",
	"\\^g": "ĝ",
	"\\u{G}": "Ğ",
	"\\u{g}": "ğ",
	"\\.G": "Ġ",
	"\\.g": "ġ",
	"\\c{G}": "Ģ",
	"\\c{g}": "ģ",
	"\\^H": "Ĥ",
	"\\^h": "ĥ",
	"{\\fontencoding{LELA}\\selectfont\\char40}": "Ħ",
	"\\Elzxh": "ħ",
	"\\~I": "Ĩ",
	"\\~i": "ĩ",
	"\\=I": "Ī",
	"\\=i": "ī",
	"\\u{I}": "Ĭ",
	"{\\u \\i}": "ĭ",
	"\\k{I}": "Į",
	"\\k{i}": "į",
	"\\.I": "İ",
	"\\i": "ı",
	"\\imath": "ı",
	"\\^J": "Ĵ",
	"\\^\\j": "ĵ",
	"\\c{K}": "Ķ",
	"\\c{k}": "ķ",
	"{\\fontencoding{LELA}\\selectfont\\char91}": "ĸ",
	"\\'L": "Ĺ",
	"\\'l": "ĺ",
	"\\c{L}": "Ļ",
	"\\c{l}": "ļ",
	"\\v{L}": "Ľ",
	"\\v{l}": "ľ",
	"{\\fontencoding{LELA}\\selectfont\\char201}": "Ŀ",
	"{\\fontencoding{LELA}\\selectfont\\char202}": "ŀ",
	"\\L": "Ł",
	"\\l": "ł",
	"\\'N": "Ń",
	"\\'n": "ń",
	"\\c{N}": "Ņ",
	"\\c{n}": "ņ",
	"\\v{N}": "Ň",
	"\\v{n}": "ň",
	"\\NG": "Ŋ",
	"\\ng": "ŋ",
	"\\=O": "Ō",
	"\\=o": "ō",
	"\\u{O}": "Ŏ",
	"\\u{o}": "ŏ",
	"\\H{O}": "Ő",
	"\\H{o}": "ő",
	"\\OE": "Œ",
	"\\oe": "œ",
	"\\'R": "Ŕ",
	"\\'r": "ŕ",
	"\\c{R}": "Ŗ",
	"\\c{r}": "ŗ",
	"\\v{R}": "Ř",
	"\\v{r}": "ř",
	"\\'S": "Ś",
	"\\'s": "ś",
	"\\^S": "Ŝ",
	"\\^s": "ŝ",
	"\\c{S}": "Ş",
	"\\c{s}": "ş",
	"\\v{S}": "Š",
	"\\v{s}": "š",
	"\\c{T}": "Ţ",
	"\\c{t}": "ţ",
	"\\v{T}": "Ť",
	"\\v{t}": "ť",
	"{\\fontencoding{LELA}\\selectfont\\char47}": "Ŧ",
	"{\\fontencoding{LELA}\\selectfont\\char63}": "ŧ",
	"\\~U": "Ũ",
	"\\~u": "ũ",
	"\\=U": "Ū",
	"\\=u": "ū",
	"\\u{U}": "Ŭ",
	"\\u{u}": "ŭ",
	"\\r{U}": "Ů",
	"{\\r U}": "Ů",
	"\\r{u}": "ů",
	"\\ocirc{u}": "ů",
	"{\\r u}": "ů",
	"\\H{U}": "Ű",
	"\\H{u}": "ű",
	"\\k{U}": "Ų",
	"\\k{u}": "ų",
	"\\^W": "Ŵ",
	"\\^w": "ŵ",
	"\\^Y": "Ŷ",
	"\\^y": "ŷ",
	"\\\"Y": "Ÿ",
	"\\'Z": "Ź",
	"\\'z": "ź",
	"\\.Z": "Ż",
	"\\.z": "ż",
	"\\v{Z}": "Ž",
	"\\v{z}": "ž",
	"\\texthvlig": "ƕ",
	"\\textnrleg": "ƞ",
	"\\textesh": "ƪ",
	"\\Zbar": "Ƶ",
	"{\\fontencoding{LELA}\\selectfont\\char195}": "ƺ",
	"\\textdoublepipe": "ǂ",
	"\\v{A}": "Ǎ",
	"\\v{a}": "ǎ",
	"\\v{I}": "Ǐ",
	"\\v{i}": "ǐ",
	"\\v{O}": "Ǒ",
	"\\v{o}": "ǒ",
	"\\v{U}": "Ǔ",
	"\\v{u}": "ǔ",
	"\\v{G}": "Ǧ",
	"\\v{g}": "ǧ",
	"\\v{K}": "Ǩ",
	"\\v{k}": "ǩ",
	"\\k{O}": "Ǫ",
	"\\k{o}": "ǫ",
	"\\v{j}": "ǰ",
	"\\'G": "Ǵ",
	"\\'g": "ǵ",
	"\\c{E}": "Ȩ",
	"\\c{e}": "ȩ",
	"\\jmath": "ȷ",
	"\\Elztrna": "ɐ",
	"\\Elztrnsa": "ɒ",
	"\\Elzopeno": "ɔ",
	"\\Elzrtld": "ɖ",
	"{\\fontencoding{LEIP}\\selectfont\\char61}": "ɘ",
	"\\Elzschwa": "ə",
	"\\varepsilon": "ɛ",
	"\\Elzpgamma": "ɣ",
	"\\Elzpbgam": "ɤ",
	"\\Elztrnh": "ɥ",
	"\\Elzbtdl": "ɬ",
	"\\Elzrtll": "ɭ",
	"\\Elztrnm": "ɯ",
	"\\Elztrnmlr": "ɰ",
	"\\Elzltlmr": "ɱ",
	"\\Elzltln": "ɲ",
	"\\Elzrtln": "ɳ",
	"\\Elzclomeg": "ɷ",
	"\\textphi": "ɸ",
	"\\Elztrnr": "ɹ",
	"\\Elztrnrl": "ɺ",
	"\\Elzrttrnr": "ɻ",
	"\\Elzrl": "ɼ",
	"\\Elzrtlr": "ɽ",
	"\\Elzfhr": "ɾ",
	"{\\fontencoding{LEIP}\\selectfont\\char202}": "ɿ",
	"\\Elzrtls": "ʂ",
	"\\Elzesh": "ʃ",
	"\\Elztrnt": "ʇ",
	"\\Elzrtlt": "ʈ",
	"\\Elzpupsil": "ʊ",
	"\\Elzpscrv": "ʋ",
	"\\Elzinvv": "ʌ",
	"\\Elzinvw": "ʍ",
	"\\Elztrny": "ʎ",
	"\\Elzrtlz": "ʐ",
	"\\Elzyogh": "ʒ",
	"\\Elzglst": "ʔ",
	"\\Elzreglst": "ʕ",
	"\\Elzinglst": "ʖ",
	"\\textturnk": "ʞ",
	"\\Elzdyogh": "ʤ",
	"\\Elztesh": "ʧ",
	"\\textsuperscript{h}": "ʰ",
	"^{h}": "ʰ",
	"\\textsuperscript{j}": "ʲ",
	"^{j}": "ʲ",
	"\\textsuperscript{r}": "ʳ",
	"^{r}": "ʳ",
	"\\textsuperscript{w}": "ʷ",
	"^{w}": "ʷ",
	"\\textsuperscript{y}": "ʸ",
	"^{y}": "ʸ",
	"\\lasp": "ʿ",
	"\\textasciicircum": "ˆ",
	"\\textasciicaron": "ˇ",
	"\\Elzverts": "ˈ",
	"\\Elzverti": "ˌ",
	"\\Elzlmrk": "ː",
	"\\Elzhlmrk": "ˑ",
	"\\Elzsbrhr": "˒",
	"\\Elzsblhr": "˓",
	"\\Elzrais": "˔",
	"\\Elzlow": "˕",
	"\\textasciibreve": "˘",
	"\\textperiodcentered": "˙",
	"\\texttildelow": "˜",
	"\\textsuperscript{l}": "ˡ",
	"^{l}": "ˡ",
	"\\textsuperscript{s}": "ˢ",
	"^{s}": "ˢ",
	"\\textsuperscript{x}": "ˣ",
	"^{x}": "ˣ",
	"\\tone{55}": "˥",
	"\\tone{44}": "˦",
	"\\tone{33}": "˧",
	"\\tone{22}": "˨",
	"\\tone{11}": "˩",
	"\\`": "̀",
	"\\grave": "̀",
	"\\textgravemacron": "̀̄",
	"\\textgravedot": "̀̇",
	"\\'": "́",
	"\\acute": "́",
	"\\textacutemacron": "́̄",
	"\\textacutewedge": "́̌",
	"\\hat": "̂",
	"\\textcircumdot": "̂̇",
	"\\~": "̃",
	"\\tilde": "̃",
	"\\texttildedot": "̃̇",
	"\\=": "̄",
	"\\bar": "̄",
	"\\overline": "̅",
	"\\u": "̆",
	"\\breve": "̆",
	"\\textbrevemacron": "̆̄",
	"\\.": "̇",
	"\\dot": "̇",
	"\\textdotacute": "̇́",
	"\\\"": "̈",
	"\\ddot": "̈",
	"\\ovhook": "̉",
	"\\r": "̊",
	"\\mathring": "̊",
	"\\textringmacron": "̊̄",
	"\\H": "̋",
	"\\check": "̌",
	"\\v": "̌",
	"\\textvbaraccent": "̍",
	"\\textdoublevbaraccent": "̎",
	"\\textdoublegrave": "̏",
	"\\textdotbreve": "̐",
	"{\\fontencoding{LECO}\\selectfont\\char177}": "̑",
	"\\oturnedcomma": "̒",
	"\\ocommatopright": "̕",
	"\\textsubgrave": "̖",
	"\\textadvancing": "̘",
	"\\textretracting": "̙",
	"\\droang": "̚",
	"\\textcorner": "̚",
	"\\textsublhalfring": "̜",
	"\\textraising": "̝",
	"\\textlowering": "̞",
	"\\textsubplus": "̟",
	"\\Elzpalh": "̡",
	"\\Elzrh": "̢",
	"\\d": "̣",
	"\\textsubumlaut": "̤",
	"\\textsubring": "̥",
	"\\c": "̧",
	"\\k": "̨",
	"\\textsyllabic": "̩",
	"\\Elzsbbrg": "̪",
	"\\textsubbridge": "̪",
	"{\\fontencoding{LECO}\\selectfont\\char203}": "̫",
	"\\textsubwedge": "̬",
	"\\textsubarch": "̯",
	"\\utilde": "̰",
	"\\textsubtilde": "̰",
	"\\textsubbar": "̱",
	"\\underbar": "̱",
	"\\underline": "̲",
	"\\textsuperimposetilde": "̴",
	"\\Elzxl": "̵",
	"\\Elzbar": "̶",
	"{\\fontencoding{LECO}\\selectfont\\char215}": "̷",
	"\\not": "̸",
	"\\textsubrhalfring": "̹",
	"\\textinvsubbridge": "̺",
	"\\textsubsquare": "̻",
	"\\textseagull": "̼",
	"\\textovercross": "̽",
	"{\\fontencoding{LECO}\\selectfont\\char225}": "͡",
	"\\'H": "Ή",
	"{\\'{}I}": "Ί",
	"{\\'{}O}": "Ό",
	"\\mathrm{'Y}": "Ύ",
	"\\mathrm{'\\Omega}": "Ώ",
	"\\acute{\\ddot{\\iota}}": "ΐ",
	"\\Gamma": "Γ",
	"\\varGamma": "Γ",
	"\\Delta": "Δ",
	"\\Theta": "Θ",
	"\\Lambda": "Λ",
	"\\Xi": "Ξ",
	"\\Pi": "Π",
	"\\Sigma": "Σ",
	"\\Upsilon": "Υ",
	"\\Phi": "Φ",
	"\\Psi": "Ψ",
	"\\Omega": "Ω",
	"\\mathrm{\\ddot{I}}": "Ϊ",
	"\\mathrm{\\ddot{Y}}": "Ϋ",
	"{\\'$\\alpha$}": "ά",
	"\\acute{\\epsilon}": "έ",
	"\\acute{\\eta}": "ή",
	"\\acute{\\iota}": "ί",
	"\\acute{\\ddot{\\upsilon}}": "ΰ",
	"\\alpha": "α",
	"\\beta": "β",
	"\\gamma": "γ",
	"\\delta": "δ",
	"\\zeta": "ζ",
	"\\eta": "η",
	"\\texttheta": "θ",
	"\\theta": "θ",
	"\\iota": "ι",
	"\\kappa": "κ",
	"\\lambda": "λ",
	"\\nu": "ν",
	"\\xi": "ξ",
	"\\pi": "π",
	"\\rho": "ρ",
	"\\varsigma": "ς",
	"\\sigma": "σ",
	"\\tau": "τ",
	"\\upsilon": "υ",
	"\\varphi": "φ",
	"\\chi": "χ",
	"\\psi": "ψ",
	"\\omega": "ω",
	"\\ddot{\\iota}": "ϊ",
	"\\ddot{\\upsilon}": "ϋ",
	"\\acute{\\upsilon}": "ύ",
	"\\acute{\\omega}": "ώ",
	"\\Pisymbol{ppi022}{87}": "ϐ",
	"\\varbeta": "ϐ",
	"\\textvartheta": "ϑ",
	"\\vartheta": "ϑ",
	"\\phi": "ϕ",
	"\\varpi": "ϖ",
	"\\Qoppa": "Ϙ",
	"\\qoppa": "ϙ",
	"\\Stigma": "Ϛ",
	"\\stigma": "ϛ",
	"\\Digamma": "Ϝ",
	"\\digamma": "ϝ",
	"\\Koppa": "Ϟ",
	"\\koppa": "ϟ",
	"\\Sampi": "Ϡ",
	"\\sampi": "ϡ",
	"\\varkappa": "ϰ",
	"\\varrho": "ϱ",
	"\\textTheta": "ϴ",
	"\\upvarTheta": "ϴ",
	"\\epsilon": "ϵ",
	"\\backepsilon": "϶",
	"\\cyrchar\\CYRYO": "Ё",
	"\\cyrchar\\CYRDJE": "Ђ",
	"\\cyrchar{\\'\\CYRG}": "Ѓ",
	"\\cyrchar\\CYRIE": "Є",
	"\\cyrchar\\CYRDZE": "Ѕ",
	"\\cyrchar\\CYRII": "І",
	"\\cyrchar\\CYRYI": "Ї",
	"\\cyrchar\\CYRJE": "Ј",
	"\\cyrchar\\CYRLJE": "Љ",
	"\\cyrchar\\CYRNJE": "Њ",
	"\\cyrchar\\CYRTSHE": "Ћ",
	"\\cyrchar{\\'\\CYRK}": "Ќ",
	"\\cyrchar\\CYRUSHRT": "Ў",
	"\\cyrchar\\CYRDZHE": "Џ",
	"\\cyrchar\\CYRA": "А",
	"\\cyrchar\\CYRB": "Б",
	"\\cyrchar\\CYRV": "В",
	"\\cyrchar\\CYRG": "Г",
	"\\cyrchar\\CYRD": "Д",
	"\\cyrchar\\CYRE": "Е",
	"\\cyrchar\\CYRZH": "Ж",
	"\\cyrchar\\CYRZ": "З",
	"\\cyrchar\\CYRI": "И",
	"\\cyrchar\\CYRISHRT": "Й",
	"\\cyrchar\\CYRK": "К",
	"\\cyrchar\\CYRL": "Л",
	"\\cyrchar\\CYRM": "М",
	"\\cyrchar\\CYRN": "Н",
	"\\cyrchar\\CYRO": "О",
	"\\cyrchar\\CYRP": "П",
	"\\cyrchar\\CYRR": "Р",
	"\\cyrchar\\CYRS": "С",
	"\\cyrchar\\CYRT": "Т",
	"\\cyrchar\\CYRU": "У",
	"\\cyrchar\\CYRF": "Ф",
	"\\cyrchar\\CYRH": "Х",
	"\\cyrchar\\CYRC": "Ц",
	"\\cyrchar\\CYRCH": "Ч",
	"\\cyrchar\\CYRSH": "Ш",
	"\\cyrchar\\CYRSHCH": "Щ",
	"\\cyrchar\\CYRHRDSN": "Ъ",
	"\\bud": "Ъ",
	"\\cdprime": "Ъ",
	"\\cyrchar\\CYRERY": "Ы",
	"\\cyrchar\\CYRSFTSN": "Ь",
	"\\cprime": "Ь",
	"\\cyrchar\\CYREREV": "Э",
	"\\cyrchar\\CYRYU": "Ю",
	"\\cyrchar\\CYRYA": "Я",
	"\\cyrchar\\cyra": "а",
	"\\cyrchar\\cyrb": "б",
	"\\cyrchar\\cyrv": "в",
	"\\cyrchar\\cyrg": "г",
	"\\cyrchar\\cyrd": "д",
	"\\cyrchar\\cyre": "е",
	"\\cyrchar\\cyrzh": "ж",
	"\\cyrchar\\cyrz": "з",
	"\\cyrchar\\cyri": "и",
	"\\cyrchar\\cyrishrt": "й",
	"\\cyrchar\\cyrk": "к",
	"\\cyrchar\\cyrl": "л",
	"\\cyrchar\\cyrm": "м",
	"\\cyrchar\\cyrn": "н",
	"\\cyrchar\\cyro": "о",
	"\\cyrchar\\cyrp": "п",
	"\\cyrchar\\cyrr": "р",
	"\\cyrchar\\cyrs": "с",
	"\\cyrchar\\cyrt": "т",
	"\\cyrchar\\cyru": "у",
	"\\cyrchar\\cyrf": "ф",
	"\\cyrchar\\cyrh": "х",
	"\\cyrchar\\cyrc": "ц",
	"\\cyrchar\\cyrch": "ч",
	"\\cyrchar\\cyrsh": "ш",
	"\\cyrchar\\cyrshch": "щ",
	"\\cyrchar\\cyrhrdsn": "ъ",
	"\\cyrchar\\cyrery": "ы",
	"\\cyrchar\\cyrsftsn": "ь",
	"\\cyrchar\\cyrerev": "э",
	"\\cyrchar\\cyryu": "ю",
	"\\cyrchar\\cyrya": "я",
	"\\cyrchar\\cyryo": "ё",
	"\\cyrchar\\cyrdje": "ђ",
	"\\cyrchar{\\'\\cyrg}": "ѓ",
	"\\cyrchar\\cyrie": "є",
	"\\cyrchar\\cyrdze": "ѕ",
	"\\cyrchar\\cyrii": "і",
	"\\cyrchar\\cyryi": "ї",
	"\\cyrchar\\cyrje": "ј",
	"\\cyrchar\\cyrlje": "љ",
	"\\cyrchar\\cyrnje": "њ",
	"\\cyrchar\\cyrtshe": "ћ",
	"\\cyrchar{\\'\\cyrk}": "ќ",
	"\\cyrchar\\cyrushrt": "ў",
	"\\cyrchar\\cyrdzhe": "џ",
	"\\cyrchar\\CYROMEGA": "Ѡ",
	"\\cyrchar\\cyromega": "ѡ",
	"\\cyrchar\\CYRYAT": "Ѣ",
	"\\cyrchar\\CYRIOTE": "Ѥ",
	"\\cyrchar\\cyriote": "ѥ",
	"\\cyrchar\\CYRLYUS": "Ѧ",
	"\\cyrchar\\cyrlyus": "ѧ",
	"\\cyrchar\\CYRIOTLYUS": "Ѩ",
	"\\cyrchar\\cyriotlyus": "ѩ",
	"\\cyrchar\\CYRBYUS": "Ѫ",
	"\\cyrchar\\CYRIOTBYUS": "Ѭ",
	"\\cyrchar\\cyriotbyus": "ѭ",
	"\\cyrchar\\CYRKSI": "Ѯ",
	"\\cyrchar\\cyrksi": "ѯ",
	"\\cyrchar\\CYRPSI": "Ѱ",
	"\\cyrchar\\cyrpsi": "ѱ",
	"\\cyrchar\\CYRFITA": "Ѳ",
	"\\cyrchar\\CYRIZH": "Ѵ",
	"\\cyrchar\\CYRUK": "Ѹ",
	"\\cyrchar\\cyruk": "ѹ",
	"\\cyrchar\\CYROMEGARND": "Ѻ",
	"\\cyrchar\\cyromegarnd": "ѻ",
	"\\cyrchar\\CYROMEGATITLO": "Ѽ",
	"\\cyrchar\\cyromegatitlo": "ѽ",
	"\\cyrchar\\CYROT": "Ѿ",
	"\\cyrchar\\cyrot": "ѿ",
	"\\cyrchar\\CYRKOPPA": "Ҁ",
	"\\cyrchar\\cyrkoppa": "ҁ",
	"\\cyrchar\\cyrthousands": "҂",
	"\\cyrchar\\cyrhundredthousands": "҈",
	"\\cyrchar\\cyrmillions": "҉",
	"\\cyrchar\\CYRSEMISFTSN": "Ҍ",
	"\\cyrchar\\cyrsemisftsn": "ҍ",
	"\\cyrchar\\CYRRTICK": "Ҏ",
	"\\cyrchar\\cyrrtick": "ҏ",
	"\\cyrchar\\CYRGUP": "Ґ",
	"\\cyrchar\\cyrgup": "ґ",
	"\\cyrchar\\CYRGHCRS": "Ғ",
	"\\cyrchar\\cyrghcrs": "ғ",
	"\\cyrchar\\CYRGHK": "Ҕ",
	"\\cyrchar\\cyrghk": "ҕ",
	"\\cyrchar\\CYRZHDSC": "Җ",
	"\\cyrchar\\cyrzhdsc": "җ",
	"\\cyrchar\\CYRZDSC": "Ҙ",
	"\\cyrchar\\cyrzdsc": "ҙ",
	"\\cyrchar\\CYRKDSC": "Қ",
	"\\cyrchar\\cyrkdsc": "қ",
	"\\cyrchar\\CYRKVCRS": "Ҝ",
	"\\cyrchar\\cyrkvcrs": "ҝ",
	"\\cyrchar\\CYRKHCRS": "Ҟ",
	"\\cyrchar\\cyrkhcrs": "ҟ",
	"\\cyrchar\\CYRKBEAK": "Ҡ",
	"\\cyrchar\\cyrkbeak": "ҡ",
	"\\cyrchar\\CYRNDSC": "Ң",
	"\\cyrchar\\cyrndsc": "ң",
	"\\cyrchar\\CYRNG": "Ҥ",
	"\\cyrchar\\cyrng": "ҥ",
	"\\cyrchar\\CYRPHK": "Ҧ",
	"\\cyrchar\\cyrphk": "ҧ",
	"\\cyrchar\\CYRABHHA": "Ҩ",
	"\\cyrchar\\cyrabhha": "ҩ",
	"\\cyrchar\\CYRSDSC": "Ҫ",
	"\\cyrchar\\cyrsdsc": "ҫ",
	"\\cyrchar\\CYRTDSC": "Ҭ",
	"\\cyrchar\\cyrtdsc": "ҭ",
	"\\cyrchar\\CYRY": "Ү",
	"\\cyrchar\\cyry": "ү",
	"\\cyrchar\\CYRYHCRS": "Ұ",
	"\\cyrchar\\cyryhcrs": "ұ",
	"\\cyrchar\\CYRHDSC": "Ҳ",
	"\\cyrchar\\cyrhdsc": "ҳ",
	"\\cyrchar\\CYRTETSE": "Ҵ",
	"\\cyrchar\\cyrtetse": "ҵ",
	"\\cyrchar\\CYRCHRDSC": "Ҷ",
	"\\cyrchar\\cyrchrdsc": "ҷ",
	"\\cyrchar\\CYRCHVCRS": "Ҹ",
	"\\cyrchar\\cyrchvcrs": "ҹ",
	"\\cyrchar\\CYRSHHA": "Һ",
	"\\cyrchar\\cyrshha": "һ",
	"\\cyrchar\\CYRABHCH": "Ҽ",
	"\\cyrchar\\cyrabhch": "ҽ",
	"\\cyrchar\\CYRABHCHDSC": "Ҿ",
	"\\cyrchar\\cyrabhchdsc": "ҿ",
	"\\cyrchar\\CYRpalochka": "Ӏ",
	"\\cyrchar\\CYRKHK": "Ӄ",
	"\\cyrchar\\cyrkhk": "ӄ",
	"\\cyrchar\\CYRNHK": "Ӈ",
	"\\cyrchar\\cyrnhk": "ӈ",
	"\\cyrchar\\CYRCHLDSC": "Ӌ",
	"\\cyrchar\\cyrchldsc": "ӌ",
	"\\cyrchar\\CYRAE": "Ӕ",
	"\\cyrchar\\cyrae": "ӕ",
	"\\cyrchar\\CYRSCHWA": "Ә",
	"\\cyrchar\\cyrschwa": "ә",
	"\\cyrchar\\CYRABHDZE": "Ӡ",
	"\\cyrchar\\cyrabhdze": "ӡ",
	"\\cyrchar\\CYROTLD": "Ө",
	"\\cyrchar\\cyrotld": "ө",
	"\\\\backslash": "ࡱ",
	"\\textsuperscript{a}": "ᵃ",
	"^{a}": "ᵃ",
	"\\textsuperscript{b}": "ᵇ",
	"^{b}": "ᵇ",
	"\\textsuperscript{d}": "ᵈ",
	"^{d}": "ᵈ",
	"\\textsuperscript{e}": "ᵉ",
	"^{e}": "ᵉ",
	"\\textsuperscript{g}": "ᵍ",
	"^{g}": "ᵍ",
	"\\textsuperscript{k}": "ᵏ",
	"^{k}": "ᵏ",
	"\\textsuperscript{m}": "ᵐ",
	"^{m}": "ᵐ",
	"\\textsuperscript{o}": "ᵒ",
	"^{o}": "ᵒ",
	"\\textsuperscript{p}": "ᵖ",
	"^{p}": "ᵖ",
	"\\textsuperscript{t}": "ᵗ",
	"^{t}": "ᵗ",
	"\\textsuperscript{u}": "ᵘ",
	"^{u}": "ᵘ",
	"\\textsuperscript{v}": "ᵛ",
	"^{v}": "ᵛ",
	"\\textsuperscript{c}": "ᶜ",
	"^{c}": "ᶜ",
	"\\textsuperscript{f}": "ᶠ",
	"^{f}": "ᶠ",
	"\\textsuperscript{z}": "ᶻ",
	"^{z}": "ᶻ",
	"\\.B": "Ḃ",
	"\\.b": "ḃ",
	"\\d{B}": "Ḅ",
	"\\d{b}": "ḅ",
	"\\b{B}": "Ḇ",
	"\\b{b}": "ḇ",
	"\\.D": "Ḋ",
	"\\.d": "ḋ",
	"\\d{D}": "Ḍ",
	"\\d{d}": "ḍ",
	"\\b{D}": "Ḏ",
	"\\b{d}": "ḏ",
	"\\c{D}": "Ḑ",
	"\\c{d}": "ḑ",
	"\\c{\\u{E}}": "Ḝ",
	"\\c{\\u{e}}": "ḝ",
	"\\.F": "Ḟ",
	"\\.f": "ḟ",
	"\\=G": "Ḡ",
	"\\=g": "ḡ",
	"\\.H": "Ḣ",
	"\\.h": "ḣ",
	"\\d{H}": "Ḥ",
	"\\d{h}": "ḥ",
	"\\\"H": "Ḧ",
	"\\\"h": "ḧ",
	"\\c{H}": "Ḩ",
	"\\c{h}": "ḩ",
	"\\'K": "Ḱ",
	"\\'k": "ḱ",
	"\\d{K}": "Ḳ",
	"\\d{k}": "ḳ",
	"\\b{K}": "Ḵ",
	"\\b{k}": "ḵ",
	"\\d{L}": "Ḷ",
	"\\d{l}": "ḷ",
	"\\b{L}": "Ḻ",
	"\\b{l}": "ḻ",
	"\\'M": "Ḿ",
	"\\'m": "ḿ",
	"\\.M": "Ṁ",
	"\\.m": "ṁ",
	"\\d{M}": "Ṃ",
	"\\d{m}": "ṃ",
	"\\.N": "Ṅ",
	"\\.n": "ṅ",
	"\\d{N}": "Ṇ",
	"\\d{n}": "ṇ",
	"\\b{N}": "Ṉ",
	"\\b{n}": "ṉ",
	"\\'P": "Ṕ",
	"\\'p": "ṕ",
	"\\.P": "Ṗ",
	"\\.p": "ṗ",
	"\\.R": "Ṙ",
	"\\.r": "ṙ",
	"\\d{R}": "Ṛ",
	"\\d{r}": "ṛ",
	"\\b{R}": "Ṟ",
	"\\b{r}": "ṟ",
	"\\.S": "Ṡ",
	"\\.s": "ṡ",
	"\\d{S}": "Ṣ",
	"\\d{s}": "ṣ",
	"\\.T": "Ṫ",
	"\\.t": "ṫ",
	"\\d{T}": "Ṭ",
	"\\d{t}": "ṭ",
	"\\b{T}": "Ṯ",
	"\\b{t}": "ṯ",
	"\\~V": "Ṽ",
	"\\~v": "ṽ",
	"\\d{V}": "Ṿ",
	"\\d{v}": "ṿ",
	"\\`W": "Ẁ",
	"\\`w": "ẁ",
	"\\'W": "Ẃ",
	"\\'w": "ẃ",
	"\\\"W": "Ẅ",
	"\\\"w": "ẅ",
	"\\.W": "Ẇ",
	"\\.w": "ẇ",
	"\\d{W}": "Ẉ",
	"\\d{w}": "ẉ",
	"\\.X": "Ẋ",
	"\\.x": "ẋ",
	"\\\"X": "Ẍ",
	"\\\"x": "ẍ",
	"\\.Y": "Ẏ",
	"\\.y": "ẏ",
	"\\^Z": "Ẑ",
	"\\^z": "ẑ",
	"\\d{Z}": "Ẓ",
	"\\d{z}": "ẓ",
	"\\b{Z}": "Ẕ",
	"\\b{z}": "ẕ",
	"\\b{h}": "ẖ",
	"\\\"t": "ẗ",
	"\\r{w}": "ẘ",
	"\\r{y}": "ẙ",
	"\\d{A}": "Ạ",
	"\\d{a}": "ạ",
	"\\d{E}": "Ẹ",
	"\\d{e}": "ẹ",
	"\\~E": "Ẽ",
	"\\~e": "ẽ",
	"\\d{I}": "Ị",
	"\\d{i}": "ị",
	"\\d{O}": "Ọ",
	"\\d{o}": "ọ",
	"\\d{U}": "Ụ",
	"\\d{u}": "ụ",
	"\\`Y": "Ỳ",
	"\\`y": "ỳ",
	"\\d{Y}": "Ỵ",
	"\\d{y}": "ỵ",
	"\\~Y": "Ỹ",
	"\\~y": "ỹ",
	"\\hspace{0.6em}": " ",
	"\\hspace{1em}": " ",
	"\\quad": " ",
	"\\;": " ",
	"\\hspace{0.25em}": " ",
	"\\hspace{0.166em}": " ",
	"\\hphantom{0}": " ",
	"\\hphantom{,}": " ",
	"\\,": " ",
	"\\mkern1mu": " ",
	"\\mbox": "​",
	"{\\aftergroup\\ignorespaces}": "‌",
	"\\textendash": "–",
	"\\textemdash": "—",
	"\\rule{1em}{1pt}": "―",
	"\\horizbar": "―",
	"\\Vert": "‖",
	"\\twolowline": "‗",
	"\\textquoteleft": "‘",
	"\\textquoteright": "’",
	"\\Elzreapos": "‛",
	"\\textquotedblleft": "“",
	"\\textquotedblright": "”",
	"\\quotedblbase": "‟",
	"\\textdagger": "†",
	"\\dagger": "†",
	"\\textdaggerdbl": "‡",
	"\\ddagger": "‡",
	"\\textbullet": "•",
	"\\enleadertwodots": "‥",
	"\\ldots": "…",
	"\\textperthousand": "‰",
	"\\textpertenthousand": "‱",
	"{'}": "′",
	"{''}": "″",
	"{'''}": "‴",
	"\\backprime": "‵",
	"\\backdprime": "‶",
	"\\backtrprime": "‷",
	"\\caretinsert": "‸",
	"\\guilsinglleft": "‹",
	"\\guilsinglright": "›",
	"\\Exclam": "‼",
	"\\hyphenbullet": "⁃",
	"\\fracslash": "⁄",
	"\\Question": "⁇",
	"\\closure": "⁐",
	"\\:": " ",
	"\\nolinebreak": "⁠",
	"^{0}": "⁰",
	"\\textsuperscript{i}": "ⁱ",
	"^{i}": "ⁱ",
	"^{4}": "⁴",
	"^{5}": "⁵",
	"^{6}": "⁶",
	"^{7}": "⁷",
	"^{8}": "⁸",
	"^{9}": "⁹",
	"^{+}": "⁺",
	"^{-}": "⁻",
	"^{=}": "⁼",
	"^{(}": "⁽",
	"^{)}": "⁾",
	"\\textsuperscript{n}": "ⁿ",
	"^{n}": "ⁿ",
	"_{0}": "₀",
	"_{1}": "₁",
	"_{2}": "₂",
	"_{3}": "₃",
	"_{4}": "₄",
	"_{5}": "₅",
	"_{6}": "₆",
	"_{7}": "₇",
	"_{8}": "₈",
	"_{9}": "₉",
	"_{+}": "₊",
	"_{-}": "₋",
	"_{=}": "₌",
	"_{(}": "₍",
	"_{)}": "₎",
	"\\textsubscript{a}": "ₐ",
	"_{a}": "ₐ",
	"\\textsubscript{e}": "ₑ",
	"_{e}": "ₑ",
	"\\textsubscript{o}": "ₒ",
	"_{o}": "ₒ",
	"\\textsubscript{x}": "ₓ",
	"_{x}": "ₓ",
	"\\textsubscript{\\textschwa}": "ₔ",
	"\\textsubscript{h}": "ₕ",
	"_{h}": "ₕ",
	"\\textsubscript{k}": "ₖ",
	"_{k}": "ₖ",
	"\\textsubscript{l}": "ₗ",
	"_{l}": "ₗ",
	"\\textsubscript{m}": "ₘ",
	"_{m}": "ₘ",
	"\\textsubscript{n}": "ₙ",
	"_{n}": "ₙ",
	"\\textsubscript{p}": "ₚ",
	"_{p}": "ₚ",
	"\\textsubscript{s}": "ₛ",
	"_{s}": "ₛ",
	"\\textsubscript{t}": "ₜ",
	"_{t}": "ₜ",
	"\\ensuremath{\\Elzpes}": "₧",
	"\\texteuro": "€",
	"\\euro": "€",
	"\\lvec": "⃐",
	"\\vertoverlay": "⃒",
	"\\LVec": "⃖",
	"\\vec": "⃗",
	"\\dddot": "⃛",
	"\\ddddot": "⃜",
	"\\enclosecircle": "⃝",
	"\\enclosesquare": "⃞",
	"\\enclosediamond": "⃟",
	"\\overleftrightarrow": "⃡",
	"\\enclosetriangle": "⃤",
	"\\annuity": "⃧",
	"\\threeunderdot": "⃨",
	"\\widebridgeabove": "⃩",
	"\\underrightharpoondown": "⃬",
	"\\underleftharpoondown": "⃭",
	"\\underleftarrow": "⃮",
	"\\underrightarrow": "⃯",
	"\\asteraccent": "⃰",
	"\\mathbb{C}": "ℂ",
	"\\textcelsius": "℃",
	"\\Euler": "ℇ",
	"\\mathscr{g}": "ℊ",
	"\\mathscr{H}": "ℋ",
	"\\mathfrak{H}": "ℌ",
	"\\mathbb{H}": "ℍ",
	"\\Planckconst": "ℎ",
	"\\hslash": "ℏ",
	"\\mathscr{I}": "ℐ",
	"\\mathfrak{I}": "ℑ",
	"\\mathscr{L}": "ℒ",
	"\\mathscr{l}": "ℓ",
	"\\mathbb{N}": "ℕ",
	"\\cyrchar\\textnumero": "№",
	"\\textcircledP": "℗",
	"\\wp": "℘",
	"\\mathbb{P}": "ℙ",
	"\\mathbb{Q}": "ℚ",
	"\\mathscr{R}": "ℛ",
	"\\mathfrak{R}": "ℜ",
	"\\mathbb{R}": "ℝ",
	"\\Elzxrat": "℞",
	"\\textservicemark": "℠",
	"\\texttrademark": "™",
	"\\mathbb{Z}": "ℤ",
	"\\mho": "℧",
	"\\mathfrak{Z}": "ℨ",
	"\\textriota": "℩",
	"\\Angstroem": "Å",
	"\\mathscr{B}": "ℬ",
	"\\mathfrak{C}": "ℭ",
	"\\textestimated": "℮",
	"\\mathscr{e}": "ℯ",
	"\\mathscr{E}": "ℰ",
	"\\mathscr{F}": "ℱ",
	"\\Finv": "Ⅎ",
	"\\mathscr{M}": "ℳ",
	"\\mathscr{o}": "ℴ",
	"\\aleph": "ℵ",
	"\\beth": "ℶ",
	"\\gimel": "ℷ",
	"\\daleth": "ℸ",
	"\\mathbb{\\pi}": "ℼ",
	"\\mathbb{\\gamma}": "ℽ",
	"\\mathbb{\\Gamma}": "ℾ",
	"\\mathbb{\\Pi}": "ℿ",
	"\\mathbb{\\Sigma}": "⅀",
	"\\Game": "⅁",
	"\\sansLturned": "⅂",
	"\\sansLmirrored": "⅃",
	"\\Yup": "⅄",
	"\\CapitalDifferentialD": "ⅅ",
	"\\DifferentialD": "ⅆ",
	"\\ExponetialE": "ⅇ",
	"\\ComplexI": "ⅈ",
	"\\ComplexJ": "ⅉ",
	"\\PropertyLine": "⅊",
	"\\invamp": "⅋",
	"\\frac{1}{7}": "⅐",
	"\\textfrac{1}{7}": "⅐",
	"\\frac{1}{9}": "⅑",
	"\\textfrac{1}{9}": "⅑",
	"\\frac{1}{10}": "⅒",
	"\\textfrac{1}{10}": "⅒",
	"\\frac{1}{3}": "⅓",
	"\\textfrac{1}{3}": "⅓",
	"\\frac{2}{3}": "⅔",
	"\\textfrac{2}{3}": "⅔",
	"\\frac{1}{5}": "⅕",
	"\\textfrac{1}{5}": "⅕",
	"\\frac{2}{5}": "⅖",
	"\\textfrac{2}{5}": "⅖",
	"\\frac{3}{5}": "⅗",
	"\\textfrac{3}{5}": "⅗",
	"\\frac{4}{5}": "⅘",
	"\\textfrac{4}{5}": "⅘",
	"\\frac{1}{6}": "⅙",
	"\\textfrac{1}{6}": "⅙",
	"\\frac{5}{6}": "⅚",
	"\\textfrac{5}{6}": "⅚",
	"\\frac{1}{8}": "⅛",
	"\\textfrac{1}{8}": "⅛",
	"\\frac{3}{8}": "⅜",
	"\\textfrac{3}{8}": "⅜",
	"\\frac{5}{8}": "⅝",
	"\\textfrac{5}{8}": "⅝",
	"\\frac{7}{8}": "⅞",
	"\\textfrac{7}{8}": "⅞",
	"\\frac{1}": "⅟",
	"\\textfrac{1}": "⅟",
	"\\frac{0}{3}": "↉",
	"\\textfrac{0}{3}": "↉",
	"\\leftarrow": "←",
	"\\uparrow": "↑",
	"\\textrightarrow": "→",
	"\\rightarrow": "→",
	"\\to": "→",
	"\\downarrow": "↓",
	"\\leftrightarrow": "↔",
	"\\updownarrow": "↕",
	"\\nwarrow": "↖",
	"\\nearrow": "↗",
	"\\searrow": "↘",
	"\\swarrow": "↙",
	"\\nleftarrow": "↚",
	"\\nrightarrow": "↛",
	"\\arrowwaveleft": "↜",
	"\\arrowwaveright": "↝",
	"\\twoheadleftarrow": "↞",
	"\\twoheaduparrow": "↟",
	"\\twoheadrightarrow": "↠",
	"\\twoheaddownarrow": "↡",
	"\\leftarrowtail": "↢",
	"\\rightarrowtail": "↣",
	"\\mapsfrom": "↤",
	"\\MapsUp": "↥",
	"\\mapsto": "↦",
	"\\MapsDown": "↧",
	"\\updownarrowbar": "↨",
	"\\hookleftarrow": "↩",
	"\\hookrightarrow": "↪",
	"\\looparrowleft": "↫",
	"\\looparrowright": "↬",
	"\\leftrightsquigarrow": "↭",
	"\\nleftrightarrow": "↮",
	"\\lightning": "↯",
	"\\Lsh": "↰",
	"\\Rsh": "↱",
	"\\dlsh": "↲",
	"\\reflectbox{\\carriagereturn}": "↳",
	"\\linefeed": "↴",
	"\\carriagereturn": "↵",
	"\\curvearrowleft": "↶",
	"\\curvearrowright": "↷",
	"\\barovernorthwestarrow": "↸",
	"\\barleftarrowrightarrowba": "↹",
	"\\circlearrowleft": "↺",
	"\\circlearrowright": "↻",
	"\\leftharpoonup": "↼",
	"\\leftharpoondown": "↽",
	"\\upharpoonright": "↾",
	"\\upharpoonleft": "↿",
	"\\rightharpoonup": "⇀",
	"\\rightharpoondown": "⇁",
	"\\downharpoonright": "⇂",
	"\\downharpoonleft": "⇃",
	"\\rightleftarrows": "⇄",
	"\\dblarrowupdown": "⇅",
	"\\leftrightarrows": "⇆",
	"\\leftleftarrows": "⇇",
	"\\upuparrows": "⇈",
	"\\rightrightarrows": "⇉",
	"\\downdownarrows": "⇊",
	"\\leftrightharpoons": "⇋",
	"\\rightleftharpoons": "⇌",
	"\\nLeftarrow": "⇍",
	"\\nLeftrightarrow": "⇎",
	"\\nRightarrow": "⇏",
	"\\Leftarrow": "⇐",
	"\\Uparrow": "⇑",
	"\\Rightarrow": "⇒",
	"\\Downarrow": "⇓",
	"\\Leftrightarrow": "⇔",
	"\\Updownarrow": "⇕",
	"\\Nwarrow": "⇖",
	"\\Nearrow": "⇗",
	"\\Searrow": "⇘",
	"\\Swarrow": "⇙",
	"\\Lleftarrow": "⇚",
	"\\Rrightarrow": "⇛",
	"\\leftsquigarrow": "⇜",
	"\\rightsquigarrow": "⇝",
	"\\nHuparrow": "⇞",
	"\\nHdownarrow": "⇟",
	"\\dashleftarrow": "⇠",
	"\\updasharrow": "⇡",
	"\\dashrightarrow": "⇢",
	"\\downdasharrow": "⇣",
	"\\LeftArrowBar": "⇤",
	"\\RightArrowBar": "⇥",
	"\\leftwhitearrow": "⇦",
	"\\upwhitearrow": "⇧",
	"\\rightwhitearrow": "⇨",
	"\\downwhitearrow": "⇩",
	"\\whitearrowupfrombar": "⇪",
	"\\circleonrightarrow": "⇴",
	"\\DownArrowUpArrow": "⇵",
	"\\rightthreearrows": "⇶",
	"\\nvleftarrow": "⇷",
	"\\pfun": "⇸",
	"\\nvleftrightarrow": "⇹",
	"\\nVleftarrow": "⇺",
	"\\ffun": "⇻",
	"\\nVleftrightarrow": "⇼",
	"\\leftarrowtriangle": "⇽",
	"\\rightarrowtriangle": "⇾",
	"\\leftrightarrowtriangle": "⇿",
	"\\forall": "∀",
	"\\complement": "∁",
	"\\partial": "∂",
	"\\exists": "∃",
	"\\nexists": "∄",
	"\\varnothing": "∅",
	"\\increment": "∆",
	"\\nabla": "∇",
	"\\in": "∈",
	"\\not\\in": "∉",
	"\\smallin": "∊",
	"\\ni": "∋",
	"\\not\\ni": "∌",
	"\\smallni": "∍",
	"\\QED": "∎",
	"\\prod": "∏",
	"\\coprod": "∐",
	"\\sum": "∑",
	"\\mp": "∓",
	"\\dotplus": "∔",
	"\\setminus": "∖",
	"{_\\ast}": "∗",
	"\\circ": "∘",
	"\\bullet": "∙",
	"\\surd": "√",
	"\\sqrt[3]": "∛",
	"\\sqrt[4]": "∜",
	"\\propto": "∝",
	"\\infty": "∞",
	"\\rightangle": "∟",
	"\\angle": "∠",
	"\\measuredangle": "∡",
	"\\sphericalangle": "∢",
	"\\mid": "∣",
	"\\nmid": "∤",
	"\\parallel": "∥",
	"\\nparallel": "∦",
	"\\wedge": "∧",
	"\\vee": "∨",
	"\\cap": "∩",
	"\\cup": "∪",
	"\\int": "∫",
	"{\\int\\!\\int}": "∬",
	"{\\int\\!\\int\\!\\int}": "∭",
	"\\oint": "∮",
	"\\surfintegral": "∯",
	"\\volintegral": "∰",
	"\\clwintegral": "∱",
	"\\lcirclerightint": "∲",
	"\\rcirclerightint": "∳",
	"\\therefore": "∴",
	"\\because": "∵",
	"\\Colon": "∷",
	"\\dotdiv": "∸",
	"\\eqcolon": "∹",
	"\\mathbin{{:}\\!\\!{-}\\!\\!{:}}": "∺",
	"\\homothetic": "∻",
	"\\sim": "∼",
	"\\backsim": "∽",
	"\\lazysinv": "∾",
	"\\AC": "∿",
	"\\wr": "≀",
	"\\not\\sim": "≁",
	"\\texteqsim": "≂",
	"\\NotEqualTilde": "≂̸",
	"\\simeq": "≃",
	"\\not\\simeq": "≄",
	"\\cong": "≅",
	"\\approxnotequal": "≆",
	"\\not\\cong": "≇",
	"\\approx": "≈",
	"\\not\\approx": "≉",
	"\\approxeq": "≊",
	"\\tildetrpl": "≋",
	"\\not\\apid": "≋̸",
	"\\allequal": "≌",
	"\\asymp": "≍",
	"\\Bumpeq": "≎",
	"\\NotHumpDownHump": "≎̸",
	"\\bumpeq": "≏",
	"\\NotHumpEqual": "≏̸",
	"\\doteq": "≐",
	"\\not\\doteq": "≐̸",
	"\\doteqdot": "≑",
	"\\fallingdotseq": "≒",
	"\\risingdotseq": "≓",
	"\\coloneq": "≔",
	"\\eqcirc": "≖",
	"\\circeq": "≗",
	"\\arceq": "≘",
	"\\estimates": "≙",
	"\\starequal": "≛",
	"\\triangleq": "≜",
	"\\eqdef": "≝",
	"\\measeq": "≞",
	"\\neq": "≠",
	"\\equiv": "≡",
	"\\not\\equiv": "≢",
	"\\Equiv": "≣",
	"\\leq": "≤",
	"\\le": "≤",
	"\\geq": "≥",
	"\\leqq": "≦",
	"\\geqq": "≧",
	"\\lneqq": "≨",
	"\\lvertneqq": "≨︀",
	"\\gneqq": "≩",
	"\\gvertneqq": "≩︀",
	"\\ll": "≪",
	"\\NotLessLess": "≪̸",
	"\\gg": "≫",
	"\\NotGreaterGreater": "≫̸",
	"\\between": "≬",
	"{\\not\\kern-0.3em\\times}": "≭",
	"\\not<": "≮",
	"\\not>": "≯",
	"\\not\\leq": "≰",
	"\\not\\geq": "≱",
	"\\lessequivlnt": "≲",
	"\\greaterequivlnt": "≳",
	"\\lessgtr": "≶",
	"\\gtrless": "≷",
	"\\notlessgreater": "≸",
	"\\notgreaterless": "≹",
	"\\prec": "≺",
	"\\succ": "≻",
	"\\preccurlyeq": "≼",
	"\\succcurlyeq": "≽",
	"\\NotPrecedesTilde": "≾̸",
	"\\NotSucceedsTilde": "≿̸",
	"\\not\\prec": "⊀",
	"\\not\\succ": "⊁",
	"\\subset": "⊂",
	"\\supset": "⊃",
	"\\not\\subset": "⊄",
	"\\not\\supset": "⊅",
	"\\subseteq": "⊆",
	"\\supseteq": "⊇",
	"\\not\\subseteq": "⊈",
	"\\not\\supseteq": "⊉",
	"\\subsetneq": "⊊",
	"\\varsubsetneqq": "⊊︀",
	"\\supsetneq": "⊋",
	"\\varsupsetneq": "⊋︀",
	"\\cupleftarrow": "⊌",
	"\\cupdot": "⊍",
	"\\uplus": "⊎",
	"\\sqsubset": "⊏",
	"\\NotSquareSubset": "⊏̸",
	"\\sqsupset": "⊐",
	"\\NotSquareSuperset": "⊐̸",
	"\\sqsubseteq": "⊑",
	"\\sqsupseteq": "⊒",
	"\\sqcap": "⊓",
	"\\sqcup": "⊔",
	"\\oplus": "⊕",
	"\\ominus": "⊖",
	"\\otimes": "⊗",
	"\\oslash": "⊘",
	"\\odot": "⊙",
	"\\circledcirc": "⊚",
	"\\circledast": "⊛",
	"\\circledequal": "⊜",
	"\\circleddash": "⊝",
	"\\boxplus": "⊞",
	"\\boxminus": "⊟",
	"\\boxtimes": "⊠",
	"\\boxdot": "⊡",
	"\\vdash": "⊢",
	"\\dashv": "⊣",
	"\\top": "⊤",
	"\\assert": "⊦",
	"\\truestate": "⊧",
	"\\forcesextra": "⊨",
	"\\Vdash": "⊩",
	"\\Vvdash": "⊪",
	"\\VDash": "⊫",
	"\\nvdash": "⊬",
	"\\nvDash": "⊭",
	"\\nVdash": "⊮",
	"\\nVDash": "⊯",
	"\\prurel": "⊰",
	"\\scurel": "⊱",
	"\\vartriangleleft": "⊲",
	"\\vartriangleright": "⊳",
	"\\trianglelefteq": "⊴",
	"\\trianglerighteq": "⊵",
	"\\original": "⊶",
	"\\image": "⊷",
	"\\multimap": "⊸",
	"\\hermitconjmatrix": "⊹",
	"\\intercal": "⊺",
	"\\veebar": "⊻",
	"\\barvee": "⊽",
	"\\rightanglearc": "⊾",
	"\\varlrtriangle": "⊿",
	"\\bigcap": "⋂",
	"\\bigcup": "⋃",
	"\\diamond": "⋄",
	"\\cdot": "⋅",
	"\\star": "⋆",
	"\\divideontimes": "⋇",
	"\\bowtie": "⋈",
	"\\ltimes": "⋉",
	"\\rtimes": "⋊",
	"\\leftthreetimes": "⋋",
	"\\rightthreetimes": "⋌",
	"\\backsimeq": "⋍",
	"\\curlyvee": "⋎",
	"\\curlywedge": "⋏",
	"\\Subset": "⋐",
	"\\Supset": "⋑",
	"\\Cap": "⋒",
	"\\Cup": "⋓",
	"\\pitchfork": "⋔",
	"\\hash": "⋕",
	"\\lessdot": "⋖",
	"\\gtrdot": "⋗",
	"\\verymuchless": "⋘",
	"\\verymuchgreater": "⋙",
	"\\lesseqgtr": "⋚",
	"\\gtreqless": "⋛",
	"\\eqless": "⋜",
	"\\eqgtr": "⋝",
	"\\curlyeqprec": "⋞",
	"\\curlyeqsucc": "⋟",
	"\\npreceq": "⋠",
	"\\nsucceq": "⋡",
	"\\not\\sqsubseteq": "⋢",
	"\\not\\sqsupseteq": "⋣",
	"\\sqsubsetneq": "⋤",
	"\\Elzsqspne": "⋥",
	"\\lnsim": "⋦",
	"\\gnsim": "⋧",
	"\\precedesnotsimilar": "⋨",
	"\\succnsim": "⋩",
	"\\ntriangleleft": "⋪",
	"\\ntriangleright": "⋫",
	"\\ntrianglelefteq": "⋬",
	"\\ntrianglerighteq": "⋭",
	"\\vdots": "⋮",
	"\\cdots": "⋯",
	"\\upslopeellipsis": "⋰",
	"\\downslopeellipsis": "⋱",
	"\\disin": "⋲",
	"\\varisins": "⋳",
	"\\isins": "⋴",
	"\\isindot": "⋵",
	"\\barin": "⋶",
	"\\isinobar": "⋷",
	"\\isinvb": "⋸",
	"\\isinE": "⋹",
	"\\nisd": "⋺",
	"\\varnis": "⋻",
	"\\nis": "⋼",
	"\\varniobar": "⋽",
	"\\niobar": "⋾",
	"\\bagmember": "⋿",
	"\\diameter": "⌀",
	"\\house": "⌂",
	"\\barwedge": "⌅",
	"\\varbarwedge": "⌅",
	"\\perspcorrespond": "⌆",
	"\\lceil": "⌈",
	"\\rceil": "⌉",
	"\\lfloor": "⌊",
	"\\rfloor": "⌋",
	"\\invneg": "⌐",
	"\\wasylozenge": "⌑",
	"\\profline": "⌒",
	"\\profsurf": "⌓",
	"\\recorder": "⌕",
	"{\\mathchar\"2208}": "⌖",
	"\\viewdata": "⌗",
	"\\turnednot": "⌙",
	"\\ulcorner": "⌜",
	"\\urcorner": "⌝",
	"\\llcorner": "⌞",
	"\\lrcorner": "⌟",
	"\\inttop": "⌠",
	"\\intbottom": "⌡",
	"\\frown": "⌢",
	"\\smile": "⌣",
	"\\varhexagonlrbonds": "⌬",
	"\\conictaper": "⌲",
	"\\topbot": "⌶",
	"\\APLinv": "⌹",
	"\\notslash": "⌿",
	"\\notbackslash": "⍀",
	"\\APLleftarrowbox": "⍇",
	"\\APLrightarrowbox": "⍈",
	"\\invdiameter": "⍉",
	"\\APLuparrowbox": "⍐",
	"\\APLboxupcaret": "⍓",
	"\\APLdownarrowbox": "⍗",
	"\\APLcomment": "⍝",
	"\\APLinput": "⍞",
	"\\APLlog": "⍟",
	"\\APLboxquestion": "⍰",
	"\\rangledownzigzagarrow": "⍼",
	"\\hexagon": "⎔",
	"\\lparenuend": "⎛",
	"\\lparenextender": "⎜",
	"\\lparenlend": "⎝",
	"\\rparenuend": "⎞",
	"\\rparenextender": "⎟",
	"\\rparenlend": "⎠",
	"\\lbrackuend": "⎡",
	"\\lbrackextender": "⎢",
	"\\Elzdlcorn": "⎣",
	"\\rbrackuend": "⎤",
	"\\rbrackextender": "⎥",
	"\\rbracklend": "⎦",
	"\\lbraceuend": "⎧",
	"\\lbracemid": "⎨",
	"\\lbracelend": "⎩",
	"\\vbraceextender": "⎪",
	"\\rbraceuend": "⎫",
	"\\rbracemid": "⎬",
	"\\rbracelend": "⎭",
	"\\intextender": "⎮",
	"\\harrowextender": "⎯",
	"\\lmoustache": "⎰",
	"\\rmoustache": "⎱",
	"\\sumtop": "⎲",
	"\\sumbottom": "⎳",
	"\\overbracket": "⎴",
	"\\underbracket": "⎵",
	"\\bbrktbrk": "⎶",
	"\\sqrtbottom": "⎷",
	"\\lvboxline": "⎸",
	"\\rvboxline": "⎹",
	"\\varcarriagereturn": "⏎",
	"\\overparen": "⏜",
	"\\underparen": "⏝",
	"\\overbrace": "⏞",
	"\\underbrace": "⏟",
	"\\obrbrak": "⏠",
	"\\ubrbrak": "⏡",
	"\\trapezium": "⏢",
	"\\benzenr": "⏣",
	"\\strns": "⏤",
	"\\fltns": "⏥",
	"\\accurrent": "⏦",
	"\\elinters": "⏧",
	"\\textvisiblespace": "␣",
	"\\ding{172}": "①",
	"\\ding{173}": "②",
	"\\ding{174}": "③",
	"\\ding{175}": "④",
	"\\ding{176}": "⑤",
	"\\ding{177}": "⑥",
	"\\ding{178}": "⑦",
	"\\ding{179}": "⑧",
	"\\ding{180}": "⑨",
	"\\ding{181}": "⑩",
	"\\circledS": "Ⓢ",
	"\\Elzdshfnc": "┆",
	"\\Elzsqfnw": "┙",
	"\\diagup": "╱",
	"\\blockuphalf": "▀",
	"\\blocklowhalf": "▄",
	"\\blockfull": "█",
	"\\blocklefthalf": "▌",
	"\\blockrighthalf": "▐",
	"\\blockqtrshaded": "░",
	"\\blockhalfshaded": "▒",
	"\\blockthreeqtrshaded": "▓",
	"\\ding{110}": "■",
	"\\mdlgblksquare": "■",
	"\\square": "□",
	"\\Box": "□",
	"\\squoval": "▢",
	"\\blackinwhitesquare": "▣",
	"\\squarehfill": "▤",
	"\\squarevfill": "▥",
	"\\squarehvfill": "▦",
	"\\squarenwsefill": "▧",
	"\\squareneswfill": "▨",
	"\\squarecrossfill": "▩",
	"\\smwhtsquare": "▫",
	"\\hrectangleblack": "▬",
	"\\fbox{~~}": "▭",
	"\\vrectangleblack": "▮",
	"\\Elzvrecto": "▯",
	"\\parallelogramblack": "▰",
	"\\ding{115}": "▲",
	"\\bigblacktriangleup": "▲",
	"\\bigtriangleup": "△",
	"\\blacktriangle": "▴",
	"\\vartriangle": "▵",
	"\\RHD": "▶",
	"\\rhd": "▷",
	"\\blacktriangleright": "▸",
	"\\triangleright": "▹",
	"\\blackpointerright": "►",
	"\\whitepointerright": "▻",
	"\\ding{116}": "▼",
	"\\bigblacktriangledown": "▼",
	"\\bigtriangledown": "▽",
	"\\blacktriangledown": "▾",
	"\\triangledown": "▿",
	"\\LHD": "◀",
	"\\lhd": "◁",
	"\\blacktriangleleft": "◂",
	"\\triangleleft": "◃",
	"\\blackpointerleft": "◄",
	"\\whitepointerleft": "◅",
	"\\ding{117}": "◆",
	"\\Diamondblack": "◆",
	"\\Diamond": "◇",
	"\\blackinwhitediamond": "◈",
	"\\fisheye": "◉",
	"\\lozenge": "◊",
	"\\dottedcircle": "◌",
	"\\circlevertfill": "◍",
	"\\bullseye": "◎",
	"\\ding{108}": "●",
	"\\CIRCLE": "●",
	"\\Elzcirfl": "◐",
	"\\Elzcirfr": "◑",
	"\\Elzcirfb": "◒",
	"\\circletophalfblack": "◓",
	"\\circleurquadblack": "◔",
	"\\blackcircleulquadwhite": "◕",
	"\\LEFTCIRCLE": "◖",
	"\\ding{119}": "◗",
	"\\RIGHTCIRCLE": "◗",
	"\\Elzrvbull": "◘",
	"\\inversewhitecircle": "◙",
	"\\invwhiteupperhalfcircle": "◚",
	"\\invwhitelowerhalfcircle": "◛",
	"\\ularc": "◜",
	"\\urarc": "◝",
	"\\lrarc": "◞",
	"\\llarc": "◟",
	"\\topsemicircle": "◠",
	"\\botsemicircle": "◡",
	"\\lrblacktriangle": "◢",
	"\\llblacktriangle": "◣",
	"\\ulblacktriangle": "◤",
	"\\urblacktriangle": "◥",
	"\\smwhtcircle": "◦",
	"\\Elzsqfl": "◧",
	"\\Elzsqfr": "◨",
	"\\squareulblack": "◩",
	"\\Elzsqfse": "◪",
	"\\boxbar": "◫",
	"\\trianglecdot": "◬",
	"\\triangleleftblack": "◭",
	"\\trianglerightblack": "◮",
	"\\bigcirc": "◯",
	"\\squareulquad": "◰",
	"\\squarellquad": "◱",
	"\\squarelrquad": "◲",
	"\\squareurquad": "◳",
	"\\circleulquad": "◴",
	"\\circlellquad": "◵",
	"\\circlelrquad": "◶",
	"\\circleurquad": "◷",
	"\\ultriangle": "◸",
	"\\urtriangle": "◹",
	"\\lltriangle": "◺",
	"\\mdsmwhtsquare": "◽",
	"\\mdsmblksquare": "◾",
	"\\lrtriangle": "◿",
	"\\ding{72}": "★",
	"\\bigstar": "★",
	"\\ding{73}": "☆",
	"\\bigwhitestar": "☆",
	"\\Sun": "☉",
	"\\ding{37}": "☎",
	"\\Square": "☐",
	"\\CheckedBox": "☑",
	"\\XBox": "☒",
	"\\steaming": "☕",
	"\\ding{42}": "☛",
	"\\ding{43}": "☞",
	"\\pointright": "☞",
	"\\skull": "☠",
	"\\danger": "☡",
	"\\radiation": "☢",
	"\\biohazard": "☣",
	"\\yinyang": "☯",
	"\\frownie": "☹",
	"\\smiley": "☺",
	"\\blacksmiley": "☻",
	"\\sun": "☼",
	"\\rightmoon": "☽",
	"\\leftmoon": "☾",
	"\\mercury": "☿",
	"\\venus": "♀",
	"\\female": "♀",
	"\\earth": "♁",
	"\\male": "♂",
	"\\jupiter": "♃",
	"\\saturn": "♄",
	"\\uranus": "♅",
	"\\neptune": "♆",
	"\\pluto": "♇",
	"\\aries": "♈",
	"\\taurus": "♉",
	"\\gemini": "♊",
	"\\cancer": "♋",
	"\\leo": "♌",
	"\\virgo": "♍",
	"\\libra": "♎",
	"\\scorpio": "♏",
	"\\sagittarius": "♐",
	"\\capricornus": "♑",
	"\\aquarius": "♒",
	"\\pisces": "♓",
	"\\ding{171}": "♠",
	"\\spadesuit": "♠",
	"\\heartsuit": "♡",
	"\\ding{168}": "♣",
	"\\clubsuit": "♣",
	"\\varspadesuit": "♤",
	"\\ding{170}": "♥",
	"\\varheartsuit": "♥",
	"\\ding{169}": "♦",
	"\\vardiamondsuit": "♦",
	"\\varclubsuit": "♧",
	"\\quarternote": "♩",
	"\\eighthnote": "♪",
	"\\twonotes": "♫",
	"\\sixteenthnote": "♬",
	"\\flat": "♭",
	"\\natural": "♮",
	"\\sharp": "♯",
	"\\recycle": "♻",
	"\\acidfree": "♾",
	"\\dicei": "⚀",
	"\\diceii": "⚁",
	"\\diceiii": "⚂",
	"\\diceiv": "⚃",
	"\\dicev": "⚄",
	"\\dicevi": "⚅",
	"\\circledrightdot": "⚆",
	"\\circledtwodots": "⚇",
	"\\blackcircledrightdot": "⚈",
	"\\blackcircledtwodots": "⚉",
	"\\anchor": "⚓",
	"\\swords": "⚔",
	"\\warning": "⚠",
	"\\Hermaphrodite": "⚥",
	"\\medcirc": "⚪",
	"\\medbullet": "⚫",
	"\\mdsmwhtcircle": "⚬",
	"\\neuter": "⚲",
	"\\ding{33}": "✁",
	"\\ding{34}": "✂",
	"\\ding{35}": "✃",
	"\\ding{36}": "✄",
	"\\ding{38}": "✆",
	"\\ding{39}": "✇",
	"\\ding{40}": "✈",
	"\\ding{41}": "✉",
	"\\ding{44}": "✌",
	"\\ding{45}": "✍",
	"\\ding{46}": "✎",
	"\\pencil": "✎",
	"\\ding{47}": "✏",
	"\\ding{48}": "✐",
	"\\ding{49}": "✑",
	"\\ding{50}": "✒",
	"\\ding{51}": "✓",
	"\\checkmark": "✓",
	"\\ding{52}": "✔",
	"\\ding{53}": "✕",
	"\\ding{54}": "✖",
	"\\ding{55}": "✗",
	"\\ballotx": "✗",
	"\\ding{56}": "✘",
	"\\ding{57}": "✙",
	"\\ding{58}": "✚",
	"\\ding{59}": "✛",
	"\\ding{60}": "✜",
	"\\ding{61}": "✝",
	"\\ding{62}": "✞",
	"\\ding{63}": "✟",
	"\\ding{64}": "✠",
	"\\maltese": "✠",
	"\\ding{65}": "✡",
	"\\ding{66}": "✢",
	"\\ding{67}": "✣",
	"\\ding{68}": "✤",
	"\\ding{69}": "✥",
	"\\ding{70}": "✦",
	"\\ding{71}": "✧",
	"\\ding{74}": "✪",
	"\\circledstar": "✪",
	"\\ding{75}": "✫",
	"\\ding{76}": "✬",
	"\\ding{77}": "✭",
	"\\ding{78}": "✮",
	"\\ding{79}": "✯",
	"\\ding{80}": "✰",
	"\\ding{81}": "✱",
	"\\ding{82}": "✲",
	"\\ding{83}": "✳",
	"\\ding{84}": "✴",
	"\\ding{85}": "✵",
	"\\ding{86}": "✶",
	"\\varstar": "✶",
	"\\ding{87}": "✷",
	"\\ding{88}": "✸",
	"\\ding{89}": "✹",
	"\\ding{90}": "✺",
	"\\ding{91}": "✻",
	"\\ding{92}": "✼",
	"\\ding{93}": "✽",
	"\\dingasterisk": "✽",
	"\\ding{94}": "✾",
	"\\ding{95}": "✿",
	"\\ding{96}": "❀",
	"\\ding{97}": "❁",
	"\\ding{98}": "❂",
	"\\ding{99}": "❃",
	"\\ding{100}": "❄",
	"\\ding{101}": "❅",
	"\\ding{102}": "❆",
	"\\ding{103}": "❇",
	"\\ding{104}": "❈",
	"\\ding{105}": "❉",
	"\\ding{106}": "❊",
	"\\ding{107}": "❋",
	"\\ding{109}": "❍",
	"\\ding{111}": "❏",
	"\\ding{112}": "❐",
	"\\ding{113}": "❑",
	"\\ding{114}": "❒",
	"\\ding{118}": "❖",
	"\\ding{120}": "❘",
	"\\ding{121}": "❙",
	"\\ding{122}": "❚",
	"\\ding{123}": "❛",
	"\\ding{124}": "❜",
	"\\ding{125}": "❝",
	"\\ding{126}": "❞",
	"\\ding{161}": "❡",
	"\\ding{162}": "❢",
	"\\ding{163}": "❣",
	"\\ding{164}": "❤",
	"\\ding{165}": "❥",
	"\\ding{166}": "❦",
	"\\ding{167}": "❧",
	"\\ding{182}": "❶",
	"\\ding{183}": "❷",
	"\\ding{184}": "❸",
	"\\ding{185}": "❹",
	"\\ding{186}": "❺",
	"\\ding{187}": "❻",
	"\\ding{188}": "❼",
	"\\ding{189}": "❽",
	"\\ding{190}": "❾",
	"\\ding{191}": "❿",
	"\\ding{192}": "➀",
	"\\ding{193}": "➁",
	"\\ding{194}": "➂",
	"\\ding{195}": "➃",
	"\\ding{196}": "➄",
	"\\ding{197}": "➅",
	"\\ding{198}": "➆",
	"\\ding{199}": "➇",
	"\\ding{200}": "➈",
	"\\ding{201}": "➉",
	"\\ding{202}": "➊",
	"\\ding{203}": "➋",
	"\\ding{204}": "➌",
	"\\ding{205}": "➍",
	"\\ding{206}": "➎",
	"\\ding{207}": "➏",
	"\\ding{208}": "➐",
	"\\ding{209}": "➑",
	"\\ding{210}": "➒",
	"\\ding{211}": "➓",
	"\\ding{212}": "➔",
	"\\ding{216}": "➘",
	"\\ding{217}": "➙",
	"\\ding{218}": "➚",
	"\\ding{219}": "➛",
	"\\draftingarrow": "➛",
	"\\ding{220}": "➜",
	"\\ding{221}": "➝",
	"\\ding{222}": "➞",
	"\\ding{223}": "➟",
	"\\ding{224}": "➠",
	"\\ding{225}": "➡",
	"\\ding{226}": "➢",
	"\\arrowbullet": "➢",
	"\\ding{227}": "➣",
	"\\ding{228}": "➤",
	"\\ding{229}": "➥",
	"\\ding{230}": "➦",
	"\\ding{231}": "➧",
	"\\ding{232}": "➨",
	"\\ding{233}": "➩",
	"\\ding{234}": "➪",
	"\\ding{235}": "➫",
	"\\ding{236}": "➬",
	"\\ding{237}": "➭",
	"\\ding{238}": "➮",
	"\\ding{239}": "➯",
	"\\ding{241}": "➱",
	"\\ding{242}": "➲",
	"\\ding{243}": "➳",
	"\\ding{244}": "➴",
	"\\ding{245}": "➵",
	"\\ding{246}": "➶",
	"\\ding{247}": "➷",
	"\\ding{248}": "➸",
	"\\ding{249}": "➹",
	"\\ding{250}": "➺",
	"\\ding{251}": "➻",
	"\\ding{252}": "➼",
	"\\ding{253}": "➽",
	"\\ding{254}": "➾",
	"\\threedangle": "⟀",
	"\\whiteinwhitetriangle": "⟁",
	"\\perp": "⟂",
	"\\subsetcirc": "⟃",
	"\\supsetcirc": "⟄",
	"\\Lbag": "⟅",
	"\\Rbag": "⟆",
	"\\veedot": "⟇",
	"\\bsolhsub": "⟈",
	"\\suphsol": "⟉",
	"\\longdivision": "⟌",
	"\\Diamonddot": "⟐",
	"\\wedgedot": "⟑",
	"\\upin": "⟒",
	"\\pullback": "⟓",
	"\\pushout": "⟔",
	"\\leftouterjoin": "⟕",
	"\\rightouterjoin": "⟖",
	"\\fullouterjoin": "⟗",
	"\\bigbot": "⟘",
	"\\bigtop": "⟙",
	"\\DashVDash": "⟚",
	"\\dashVdash": "⟛",
	"\\multimapinv": "⟜",
	"\\vlongdash": "⟝",
	"\\longdashv": "⟞",
	"\\cirbot": "⟟",
	"\\lozengeminus": "⟠",
	"\\concavediamond": "⟡",
	"\\concavediamondtickleft": "⟢",
	"\\concavediamondtickright": "⟣",
	"\\whitesquaretickleft": "⟤",
	"\\whitesquaretickright": "⟥",
	"\\llbracket": "⟦",
	"\\rrbracket": "⟧",
	"\\langle": "⟨",
	"\\rangle": "⟩",
	"\\lang": "⟪",
	"\\rang": "⟫",
	"\\Lbrbrak": "⟬",
	"\\Rbrbrak": "⟭",
	"\\lgroup": "⟮",
	"\\rgroup": "⟯",
	"\\UUparrow": "⟰",
	"\\DDownarrow": "⟱",
	"\\acwgapcirclearrow": "⟲",
	"\\cwgapcirclearrow": "⟳",
	"\\rightarrowonoplus": "⟴",
	"\\longleftarrow": "⟵",
	"\\longrightarrow": "⟶",
	"\\longleftrightarrow": "⟷",
	"\\Longleftarrow": "⟸",
	"\\Longrightarrow": "⟹",
	"\\Longleftrightarrow": "⟺",
	"\\longmapsfrom": "⟻",
	"\\longmapsto": "⟼",
	"\\Longmapsfrom": "⟽",
	"\\Longmapsto": "⟾",
	"\\sim\\joinrel\\leadsto": "⟿",
	"\\psur": "⤀",
	"\\nVtwoheadrightarrow": "⤁",
	"\\nvLeftarrow": "⤂",
	"\\nvRightarrow": "⤃",
	"\\nvLeftrightarrow": "⤄",
	"\\Mapsfrom": "⤆",
	"\\Mapsto": "⤇",
	"\\downarrowbarred": "⤈",
	"\\uparrowbarred": "⤉",
	"\\Uuparrow": "⤊",
	"\\Ddownarrow": "⤋",
	"\\leftbkarrow": "⤌",
	"\\rightbkarrow": "⤍",
	"\\leftdbkarrow": "⤎",
	"\\dbkarow": "⤏",
	"\\drbkarow": "⤐",
	"\\rightdotarrow": "⤑",
	"\\UpArrowBar": "⤒",
	"\\DownArrowBar": "⤓",
	"\\pinj": "⤔",
	"\\finj": "⤕",
	"\\bij": "⤖",
	"\\nvtwoheadrightarrowtail": "⤗",
	"\\nVtwoheadrightarrowtail": "⤘",
	"\\lefttail": "⤙",
	"\\righttail": "⤚",
	"\\leftdbltail": "⤛",
	"\\rightdbltail": "⤜",
	"\\diamondleftarrow": "⤝",
	"\\rightarrowdiamond": "⤞",
	"\\diamondleftarrowbar": "⤟",
	"\\barrightarrowdiamond": "⤠",
	"\\nwsearrow": "⤡",
	"\\neswarrow": "⤢",
	"\\rdiagovfdiag": "⤫",
	"\\fdiagovrdiag": "⤬",
	"\\seovnearrow": "⤭",
	"\\neovsearrow": "⤮",
	"\\fdiagovnearrow": "⤯",
	"\\rdiagovsearrow": "⤰",
	"\\neovnwarrow": "⤱",
	"\\nwovnearrow": "⤲",
	"\\uprightcurvearrow": "⤴",
	"\\downrightcurvedarrow": "⤵",
	"\\cwrightarcarrow": "⤸",
	"\\acwleftarcarrow": "⤹",
	"\\acwoverarcarrow": "⤺",
	"\\acwunderarcarrow": "⤻",
	"\\curvearrowrightminus": "⤼",
	"\\curvearrowleftplus": "⤽",
	"\\cwundercurvearrow": "⤾",
	"\\ccwundercurvearrow": "⤿",
	"\\Elolarr": "⥀",
	"\\Elorarr": "⥁",
	"\\ElzRlarr": "⥂",
	"\\leftarrowshortrightarrow": "⥃",
	"\\ElzrLarr": "⥄",
	"\\rightarrowplus": "⥅",
	"\\leftarrowplus": "⥆",
	"\\Elzrarrx": "⥇",
	"\\leftrightarrowcircle": "⥈",
	"\\twoheaduparrowcircle": "⥉",
	"\\leftrightharpoon": "⥊",
	"\\rightleftharpoon": "⥋",
	"\\updownharpoonrightleft": "⥌",
	"\\updownharpoonleftright": "⥍",
	"\\LeftRightVector": "⥎",
	"\\RightUpDownVector": "⥏",
	"\\DownLeftRightVector": "⥐",
	"\\LeftUpDownVector": "⥑",
	"\\LeftVectorBar": "⥒",
	"\\RightVectorBar": "⥓",
	"\\RightUpVectorBar": "⥔",
	"\\RightDownVectorBar": "⥕",
	"\\DownLeftVectorBar": "⥖",
	"\\DownRightVectorBar": "⥗",
	"\\LeftUpVectorBar": "⥘",
	"\\LeftDownVectorBar": "⥙",
	"\\LeftTeeVector": "⥚",
	"\\RightTeeVector": "⥛",
	"\\RightUpTeeVector": "⥜",
	"\\RightDownTeeVector": "⥝",
	"\\DownLeftTeeVector": "⥞",
	"\\DownRightTeeVector": "⥟",
	"\\LeftUpTeeVector": "⥠",
	"\\LeftDownTeeVector": "⥡",
	"\\leftleftharpoons": "⥢",
	"\\upupharpoons": "⥣",
	"\\rightrightharpoons": "⥤",
	"\\downdownharpoons": "⥥",
	"\\leftrightharpoonsup": "⥦",
	"\\leftrightharpoonsdown": "⥧",
	"\\rightleftharpoonsup": "⥨",
	"\\rightleftharpoonsdown": "⥩",
	"\\leftbarharpoon": "⥪",
	"\\barleftharpoon": "⥫",
	"\\rightbarharpoon": "⥬",
	"\\barrightharpoon": "⥭",
	"\\UpEquilibrium": "⥮",
	"\\ReverseUpEquilibrium": "⥯",
	"\\RoundImplies": "⥰",
	"\\equalrightarrow": "⥱",
	"\\similarrightarrow": "⥲",
	"\\leftarrowsimilar": "⥳",
	"\\rightarrowsimilar": "⥴",
	"\\rightarrowapprox": "⥵",
	"\\ltlarr": "⥶",
	"\\leftarrowless": "⥷",
	"\\gtrarr": "⥸",
	"\\subrarr": "⥹",
	"\\leftarrowsubset": "⥺",
	"\\suplarr": "⥻",
	"\\upfishtail": "⥾",
	"\\downfishtail": "⥿",
	"\\Elztfnc": "⦀",
	"\\spot": "⦁",
	"\\typecolon": "⦂",
	"\\lBrace": "⦃",
	"\\rBrace": "⦄",
	"\\Elroang": "⦆",
	"\\limg": "⦇",
	"\\rimg": "⦈",
	"\\lblot": "⦉",
	"\\rblot": "⦊",
	"\\lbrackubar": "⦋",
	"\\rbrackubar": "⦌",
	"\\lbrackultick": "⦍",
	"\\rbracklrtick": "⦎",
	"\\lbracklltick": "⦏",
	"\\rbrackurtick": "⦐",
	"\\langledot": "⦑",
	"\\rangledot": "⦒",
	"<\\kern-0.58em(": "⦓",
	"\\Lparengtr": "⦕",
	"\\Rparenless": "⦖",
	"\\lblkbrbrak": "⦗",
	"\\rblkbrbrak": "⦘",
	"\\Elzddfnc": "⦙",
	"\\vzigzag": "⦚",
	"\\measuredangleleft": "⦛",
	"\\Angle": "⦜",
	"\\rightanglemdot": "⦝",
	"\\angles": "⦞",
	"\\angdnr": "⦟",
	"\\Elzlpargt": "⦠",
	"\\sphericalangleup": "⦡",
	"\\turnangle": "⦢",
	"\\revangle": "⦣",
	"\\angleubar": "⦤",
	"\\revangleubar": "⦥",
	"\\wideangledown": "⦦",
	"\\wideangleup": "⦧",
	"\\measanglerutone": "⦨",
	"\\measanglelutonw": "⦩",
	"\\measanglerdtose": "⦪",
	"\\measangleldtosw": "⦫",
	"\\measangleurtone": "⦬",
	"\\measangleultonw": "⦭",
	"\\measangledrtose": "⦮",
	"\\measangledltosw": "⦯",
	"\\revemptyset": "⦰",
	"\\emptysetobar": "⦱",
	"\\emptysetocirc": "⦲",
	"\\emptysetoarr": "⦳",
	"\\emptysetoarrl": "⦴",
	"\\circledparallel": "⦷",
	"\\circledbslash": "⦸",
	"\\operp": "⦹",
	"\\obot": "⦺",
	"\\olcross": "⦻",
	"\\odotslashdot": "⦼",
	"\\uparrowoncircle": "⦽",
	"\\circledwhitebullet": "⦾",
	"\\circledbullet": "⦿",
	"\\circledless": "⧀",
	"\\circledgtr": "⧁",
	"\\cirscir": "⧂",
	"\\cirE": "⧃",
	"\\boxslash": "⧄",
	"\\boxbslash": "⧅",
	"\\boxast": "⧆",
	"\\boxcircle": "⧇",
	"\\boxbox": "⧈",
	"\\boxonbox": "⧉",
	"\\ElzLap": "⧊",
	"\\Elzdefas": "⧋",
	"\\triangles": "⧌",
	"\\triangleserifs": "⧍",
	"\\rtriltri": "⧎",
	"\\LeftTriangleBar": "⧏",
	"\\NotLeftTriangleBar": "⧏̸",
	"\\RightTriangleBar": "⧐",
	"\\NotRightTriangleBar": "⧐̸",
	"\\lfbowtie": "⧑",
	"\\rfbowtie": "⧒",
	"\\fbowtie": "⧓",
	"\\lftimes": "⧔",
	"\\rftimes": "⧕",
	"\\hourglass": "⧖",
	"\\blackhourglass": "⧗",
	"\\lvzigzag": "⧘",
	"\\rvzigzag": "⧙",
	"\\Lvzigzag": "⧚",
	"\\Rvzigzag": "⧛",
	"\\tieinfty": "⧝",
	"\\nvinfty": "⧞",
	"\\multimapboth": "⧟",
	"\\laplac": "⧠",
	"\\lrtriangleeq": "⧡",
	"\\shuffle": "⧢",
	"\\eparsl": "⧣",
	"\\smeparsl": "⧤",
	"\\eqvparsl": "⧥",
	"\\gleichstark": "⧦",
	"\\thermod": "⧧",
	"\\downtriangleleftblack": "⧨",
	"\\downtrianglerightblack": "⧩",
	"\\blackdiamonddownarrow": "⧪",
	"\\blacklozenge": "⧫",
	"\\circledownarrow": "⧬",
	"\\blackcircledownarrow": "⧭",
	"\\errbarsquare": "⧮",
	"\\errbarblacksquare": "⧯",
	"\\errbardiamond": "⧰",
	"\\errbarblackdiamond": "⧱",
	"\\errbarcircle": "⧲",
	"\\errbarblackcircle": "⧳",
	"\\RuleDelayed": "⧴",
	"\\dsol": "⧶",
	"\\rsolbar": "⧷",
	"\\xsol": "⧸",
	"\\zhide": "⧹",
	"\\doubleplus": "⧺",
	"\\tripleplus": "⧻",
	"\\lcurvyangle": "⧼",
	"\\rcurvyangle": "⧽",
	"\\tplus": "⧾",
	"\\tminus": "⧿",
	"\\bigodot": "⨀",
	"\\bigoplus": "⨁",
	"\\bigotimes": "⨂",
	"\\bigcupdot": "⨃",
	"\\Elxuplus": "⨄",
	"\\ElzThr": "⨅",
	"\\Elxsqcup": "⨆",
	"\\ElzInf": "⨇",
	"\\ElzSup": "⨈",
	"\\varprod": "⨉",
	"\\modtwosum": "⨊",
	"\\sumint": "⨋",
	"\\iiiint": "⨌",
	"\\ElzCint": "⨍",
	"\\intBar": "⨎",
	"\\clockoint": "⨏",
	"\\awint": "⨑",
	"\\rppolint": "⨒",
	"\\scpolint": "⨓",
	"\\npolint": "⨔",
	"\\pointint": "⨕",
	"\\sqrint": "⨖",
	"\\intlarhk": "⨗",
	"\\intx": "⨘",
	"\\intcap": "⨙",
	"\\intcup": "⨚",
	"\\upint": "⨛",
	"\\lowint": "⨜",
	"\\Join": "⨝",
	"\\bigtriangleleft": "⨞",
	"\\zcmp": "⨟",
	"\\zpipe": "⨠",
	"\\zproject": "⨡",
	"\\ringplus": "⨢",
	"\\plushat": "⨣",
	"\\simplus": "⨤",
	"\\plussim": "⨦",
	"\\plussubtwo": "⨧",
	"\\plustrif": "⨨",
	"\\commaminus": "⨩",
	"\\minusfdots": "⨫",
	"\\minusrdots": "⨬",
	"\\ElzTimes": "⨯",
	"\\dottimes": "⨰",
	"\\timesbar": "⨱",
	"\\btimes": "⨲",
	"\\smashtimes": "⨳",
	"\\otimeshat": "⨶",
	"\\Otimes": "⨷",
	"\\odiv": "⨸",
	"\\triangleplus": "⨹",
	"\\triangleminus": "⨺",
	"\\triangletimes": "⨻",
	"\\intprodr": "⨽",
	"\\fcmp": "⨾",
	"\\amalg": "⨿",
	"\\capdot": "⩀",
	"\\uminus": "⩁",
	"\\barcup": "⩂",
	"\\barcap": "⩃",
	"\\capwedge": "⩄",
	"\\cupvee": "⩅",
	"\\cupovercap": "⩆",
	"\\capovercup": "⩇",
	"\\cupbarcap": "⩈",
	"\\capbarcup": "⩉",
	"\\twocups": "⩊",
	"\\twocaps": "⩋",
	"\\closedvarcup": "⩌",
	"\\closedvarcap": "⩍",
	"\\Sqcap": "⩎",
	"\\Sqcup": "⩏",
	"\\closedvarcupsmashprod": "⩐",
	"\\wedgeodot": "⩑",
	"\\veeodot": "⩒",
	"\\ElzAnd": "⩓",
	"\\ElzOr": "⩔",
	"\\ElOr": "⩖",
	"\\bigslopedvee": "⩗",
	"\\bigslopedwedge": "⩘",
	"\\veeonwedge": "⩙",
	"\\wedgemidvert": "⩚",
	"\\veemidvert": "⩛",
	"\\midbarwedge": "⩜",
	"\\midbarvee": "⩝",
	"\\Elzminhat": "⩟",
	"\\wedgedoublebar": "⩠",
	"\\varveebar": "⩡",
	"\\doublebarvee": "⩢",
	"\\dsub": "⩤",
	"\\rsub": "⩥",
	"\\eqdot": "⩦",
	"\\dotequiv": "⩧",
	"\\equivVert": "⩨",
	"\\equivVvert": "⩩",
	"\\dotsim": "⩪",
	"\\simrdots": "⩫",
	"\\simminussim": "⩬",
	"\\congdot": "⩭",
	"\\stackrel{*}{=}": "⩮",
	"\\hatapprox": "⩯",
	"\\approxeqq": "⩰",
	"\\eqqplus": "⩱",
	"\\pluseqq": "⩲",
	"\\eqqsim": "⩳",
	"\\Coloneqq": "⩴",
	"\\Equal": "⩵",
	"\\Same": "⩶",
	"\\ddotseq": "⩷",
	"\\equivDD": "⩸",
	"\\ltcir": "⩹",
	"\\gtcir": "⩺",
	"\\ltquest": "⩻",
	"\\gtquest": "⩼",
	"\\leqslant": "⩽",
	"\\nleqslant": "⩽̸",
	"\\geqslant": "⩾",
	"\\ngeqslant": "⩾̸",
	"\\lesdot": "⩿",
	"\\gesdot": "⪀",
	"\\lesdoto": "⪁",
	"\\gesdoto": "⪂",
	"\\lesdotor": "⪃",
	"\\gesdotol": "⪄",
	"\\lessapprox": "⪅",
	"\\gtrapprox": "⪆",
	"\\lneq": "⪇",
	"\\gneq": "⪈",
	"\\lnapprox": "⪉",
	"\\gnapprox": "⪊",
	"\\lesseqqgtr": "⪋",
	"\\gtreqqless": "⪌",
	"\\lsime": "⪍",
	"\\gsime": "⪎",
	"\\lsimg": "⪏",
	"\\gsiml": "⪐",
	"\\lgE": "⪑",
	"\\glE": "⪒",
	"\\lesges": "⪓",
	"\\gesles": "⪔",
	"\\eqslantless": "⪕",
	"\\eqslantgtr": "⪖",
	"\\elsdot": "⪗",
	"\\egsdot": "⪘",
	"\\eqqless": "⪙",
	"\\eqqgtr": "⪚",
	"\\eqqslantless": "⪛",
	"\\eqqslantgtr": "⪜",
	"\\Pisymbol{ppi020}{117}": "⪝",
	"\\Pisymbol{ppi020}{105}": "⪞",
	"\\simlE": "⪟",
	"\\simgE": "⪠",
	"\\NestedLessLess": "⪡",
	"\\NotNestedLessLess": "⪡̸",
	"\\NestedGreaterGreater": "⪢",
	"\\NotNestedGreaterGreater": "⪢̸",
	"\\partialmeetcontraction": "⪣",
	"\\glj": "⪤",
	"\\gla": "⪥",
	"\\leftslice": "⪦",
	"\\rightslice": "⪧",
	"\\lescc": "⪨",
	"\\gescc": "⪩",
	"\\smt": "⪪",
	"\\lat": "⪫",
	"\\smte": "⪬",
	"\\late": "⪭",
	"\\bumpeqq": "⪮",
	"\\preceq": "⪯",
	"\\not\\preceq": "⪯̸",
	"\\succeq": "⪰",
	"\\not\\succeq": "⪰̸",
	"\\precneq": "⪱",
	"\\succneq": "⪲",
	"\\preceqq": "⪳",
	"\\succeqq": "⪴",
	"\\precneqq": "⪵",
	"\\succneqq": "⪶",
	"\\precapprox": "⪷",
	"\\succapprox": "⪸",
	"\\precnapprox": "⪹",
	"\\succnapprox": "⪺",
	"\\llcurly": "⪻",
	"\\ggcurly": "⪼",
	"\\subsetdot": "⪽",
	"\\supsetdot": "⪾",
	"\\subsetplus": "⪿",
	"\\supsetplus": "⫀",
	"\\submult": "⫁",
	"\\supmult": "⫂",
	"\\subedot": "⫃",
	"\\supedot": "⫄",
	"\\subseteqq": "⫅",
	"\\nsubseteqq": "⫅̸",
	"\\supseteqq": "⫆",
	"\\nsupseteqq": "⫆̸",
	"\\subsim": "⫇",
	"\\supsim": "⫈",
	"\\subsetapprox": "⫉",
	"\\supsetapprox": "⫊",
	"\\subsetneqq": "⫋",
	"\\supsetneqq": "⫌",
	"\\lsqhook": "⫍",
	"\\rsqhook": "⫎",
	"\\csub": "⫏",
	"\\csup": "⫐",
	"\\csube": "⫑",
	"\\csupe": "⫒",
	"\\subsup": "⫓",
	"\\supsub": "⫔",
	"\\subsub": "⫕",
	"\\supsup": "⫖",
	"\\suphsub": "⫗",
	"\\supdsub": "⫘",
	"\\forkv": "⫙",
	"\\topfork": "⫚",
	"\\mlcp": "⫛",
	"\\forks": "⫝̸",
	"\\forksnot": "⫝",
	"\\shortlefttack": "⫞",
	"\\shortdowntack": "⫟",
	"\\shortuptack": "⫠",
	"\\perps": "⫡",
	"\\vDdash": "⫢",
	"\\dashV": "⫣",
	"\\Dashv": "⫤",
	"\\DashV": "⫥",
	"\\varVdash": "⫦",
	"\\Barv": "⫧",
	"\\vBar": "⫨",
	"\\vBarv": "⫩",
	"\\Top": "⫪",
	"\\Not": "⫬",
	"\\bNot": "⫭",
	"\\revnmid": "⫮",
	"\\cirmid": "⫯",
	"\\midcir": "⫰",
	"\\topcir": "⫱",
	"\\nhpar": "⫲",
	"\\parsim": "⫳",
	"\\interleave": "⫴",
	"\\nhVvert": "⫵",
	"\\Elztdcol": "⫶",
	"\\lllnest": "⫷",
	"\\gggnest": "⫸",
	"\\leqqslant": "⫹",
	"\\geqqslant": "⫺",
	"\\trslash": "⫻",
	"\\biginterleave": "⫼",
	"{{/}\\!\\!{/}}": "⫽",
	"{\\rlap{\\textbackslash}{{/}\\!\\!{/}}}": "⫽⃥",
	"\\talloblong": "⫾",
	"\\bigtalloblong": "⫿",
	"\\squaretopblack": "⬒",
	"\\squarebotblack": "⬓",
	"\\squareurblack": "⬔",
	"\\squarellblack": "⬕",
	"\\diamondleftblack": "⬖",
	"\\diamondrightblack": "⬗",
	"\\diamondtopblack": "⬘",
	"\\diamondbotblack": "⬙",
	"\\dottedsquare": "⬚",
	"\\blacksquare": "⬛",
	"\\vysmblksquare": "⬝",
	"\\vysmwhtsquare": "⬞",
	"\\pentagonblack": "⬟",
	"\\pentagon": "⬠",
	"\\varhexagon": "⬡",
	"\\varhexagonblack": "⬢",
	"\\hexagonblack": "⬣",
	"\\lgblkcircle": "⬤",
	"\\mdblkdiamond": "⬥",
	"\\mdwhtdiamond": "⬦",
	"\\mdblklozenge": "⬧",
	"\\mdwhtlozenge": "⬨",
	"\\smblkdiamond": "⬩",
	"\\smblklozenge": "⬪",
	"\\smwhtlozenge": "⬫",
	"\\blkhorzoval": "⬬",
	"\\whthorzoval": "⬭",
	"\\blkvertoval": "⬮",
	"\\whtvertoval": "⬯",
	"\\circleonleftarrow": "⬰",
	"\\leftthreearrows": "⬱",
	"\\leftarrowonoplus": "⬲",
	"\\longleftsquigarrow": "⬳",
	"\\nvtwoheadleftarrow": "⬴",
	"\\nVtwoheadleftarrow": "⬵",
	"\\twoheadmapsfrom": "⬶",
	"\\twoheadleftdbkarrow": "⬷",
	"\\leftdotarrow": "⬸",
	"\\nvleftarrowtail": "⬹",
	"\\nVleftarrowtail": "⬺",
	"\\twoheadleftarrowtail": "⬻",
	"\\nvtwoheadleftarrowtail": "⬼",
	"\\nVtwoheadleftarrowtail": "⬽",
	"\\leftarrowx": "⬾",
	"\\leftcurvedarrow": "⬿",
	"\\equalleftarrow": "⭀",
	"\\bsimilarleftarrow": "⭁",
	"\\leftarrowbackapprox": "⭂",
	"\\rightarrowgtr": "⭃",
	"\\rightarrowsupset": "⭄",
	"\\LLeftarrow": "⭅",
	"\\RRightarrow": "⭆",
	"\\bsimilarrightarrow": "⭇",
	"\\rightarrowbackapprox": "⭈",
	"\\similarleftarrow": "⭉",
	"\\leftarrowapprox": "⭊",
	"\\leftarrowbsimilar": "⭋",
	"\\rightarrowbsimilar": "⭌",
	"\\medwhitestar": "⭐",
	"\\medblackstar": "⭑",
	"\\smwhitestar": "⭒",
	"\\rightpentagonblack": "⭓",
	"\\rightpentagon": "⭔",
	"\\postalmark": "〒",
	"\\lbrbrak": "〔",
	"\\rbrbrak": "〕",
	"\\openbracketleft": "〚",
	"\\openbracketright": "〛",
	"\\hzigzag": "〰",
	"\\dbend": "�",
	"\\mathbf{A}": "𝐀",
	"\\mathbf{B}": "𝐁",
	"\\mathbf{C}": "𝐂",
	"\\mathbf{D}": "𝐃",
	"\\mathbf{E}": "𝐄",
	"\\mathbf{F}": "𝐅",
	"\\mathbf{G}": "𝐆",
	"\\mathbf{H}": "𝐇",
	"\\mathbf{I}": "𝐈",
	"\\mathbf{J}": "𝐉",
	"\\mathbf{K}": "𝐊",
	"\\mathbf{L}": "𝐋",
	"\\mathbf{M}": "𝐌",
	"\\mathbf{N}": "𝐍",
	"\\mathbf{O}": "𝐎",
	"\\mathbf{P}": "𝐏",
	"\\mathbf{Q}": "𝐐",
	"\\mathbf{R}": "𝐑",
	"\\mathbf{S}": "𝐒",
	"\\mathbf{T}": "𝐓",
	"\\mathbf{U}": "𝐔",
	"\\mathbf{V}": "𝐕",
	"\\mathbf{W}": "𝐖",
	"\\mathbf{X}": "𝐗",
	"\\mathbf{Y}": "𝐘",
	"\\mathbf{Z}": "𝐙",
	"\\mathbf{a}": "𝐚",
	"\\mathbf{b}": "𝐛",
	"\\mathbf{c}": "𝐜",
	"\\mathbf{d}": "𝐝",
	"\\mathbf{e}": "𝐞",
	"\\mathbf{f}": "𝐟",
	"\\mathbf{g}": "𝐠",
	"\\mathbf{h}": "𝐡",
	"\\mathbf{i}": "𝐢",
	"\\mathbf{j}": "𝐣",
	"\\mathbf{k}": "𝐤",
	"\\mathbf{l}": "𝐥",
	"\\mathbf{m}": "𝐦",
	"\\mathbf{n}": "𝐧",
	"\\mathbf{o}": "𝐨",
	"\\mathbf{p}": "𝐩",
	"\\mathbf{q}": "𝐪",
	"\\mathbf{r}": "𝐫",
	"\\mathbf{s}": "𝐬",
	"\\mathbf{t}": "𝐭",
	"\\mathbf{u}": "𝐮",
	"\\mathbf{v}": "𝐯",
	"\\mathbf{w}": "𝐰",
	"\\mathbf{x}": "𝐱",
	"\\mathbf{y}": "𝐲",
	"\\mathbf{z}": "𝐳",
	"\\mathsl{A}": "𝐴",
	"\\mathsl{B}": "𝐵",
	"\\mathsl{C}": "𝐶",
	"\\mathsl{D}": "𝐷",
	"\\mathsl{E}": "𝐸",
	"\\mathsl{F}": "𝐹",
	"\\mathsl{G}": "𝐺",
	"\\mathsl{H}": "𝐻",
	"\\mathsl{I}": "𝐼",
	"\\mathsl{J}": "𝐽",
	"\\mathsl{K}": "𝐾",
	"\\mathsl{L}": "𝐿",
	"\\mathsl{M}": "𝑀",
	"\\mathsl{N}": "𝑁",
	"\\mathsl{O}": "𝑂",
	"\\mathsl{P}": "𝑃",
	"\\mathsl{Q}": "𝑄",
	"\\mathsl{R}": "𝑅",
	"\\mathsl{S}": "𝑆",
	"\\mathsl{T}": "𝑇",
	"\\mathsl{U}": "𝑈",
	"\\mathsl{V}": "𝑉",
	"\\mathsl{W}": "𝑊",
	"\\mathsl{X}": "𝑋",
	"\\mathsl{Y}": "𝑌",
	"\\mathsl{Z}": "𝑍",
	"\\mathsl{a}": "𝑎",
	"\\mathsl{b}": "𝑏",
	"\\mathsl{c}": "𝑐",
	"\\mathsl{d}": "𝑑",
	"\\mathsl{e}": "𝑒",
	"\\mathsl{f}": "𝑓",
	"\\mathsl{g}": "𝑔",
	"\\mathsl{i}": "𝑖",
	"\\mathsl{j}": "𝑗",
	"\\mathsl{k}": "𝑘",
	"\\mathsl{l}": "𝑙",
	"\\mathsl{m}": "𝑚",
	"\\mathsl{n}": "𝑛",
	"\\mathsl{o}": "𝑜",
	"\\mathsl{p}": "𝑝",
	"\\mathsl{q}": "𝑞",
	"\\mathsl{r}": "𝑟",
	"\\mathsl{s}": "𝑠",
	"\\mathsl{t}": "𝑡",
	"\\mathsl{u}": "𝑢",
	"\\mathsl{v}": "𝑣",
	"\\mathsl{w}": "𝑤",
	"\\mathsl{x}": "𝑥",
	"\\mathsl{y}": "𝑦",
	"\\mathsl{z}": "𝑧",
	"\\mathbit{A}": "𝑨",
	"\\mathbit{B}": "𝑩",
	"\\mathbit{C}": "𝑪",
	"\\mathbit{D}": "𝑫",
	"\\mathbit{E}": "𝑬",
	"\\mathbit{F}": "𝑭",
	"\\mathbit{G}": "𝑮",
	"\\mathbit{H}": "𝑯",
	"\\mathbit{I}": "𝑰",
	"\\mathbit{J}": "𝑱",
	"\\mathbit{K}": "𝑲",
	"\\mathbit{L}": "𝑳",
	"\\mathbit{M}": "𝑴",
	"\\mathbit{N}": "𝑵",
	"\\mathbit{O}": "𝑶",
	"\\mathbit{P}": "𝑷",
	"\\mathbit{Q}": "𝑸",
	"\\mathbit{R}": "𝑹",
	"\\mathbit{S}": "𝑺",
	"\\mathbit{T}": "𝑻",
	"\\mathbit{U}": "𝑼",
	"\\mathbit{V}": "𝑽",
	"\\mathbit{W}": "𝑾",
	"\\mathbit{X}": "𝑿",
	"\\mathbit{Y}": "𝒀",
	"\\mathbit{Z}": "𝒁",
	"\\mathbit{a}": "𝒂",
	"\\mathbit{b}": "𝒃",
	"\\mathbit{c}": "𝒄",
	"\\mathbit{d}": "𝒅",
	"\\mathbit{e}": "𝒆",
	"\\mathbit{f}": "𝒇",
	"\\mathbit{g}": "𝒈",
	"\\mathbit{h}": "𝒉",
	"\\mathbit{i}": "𝒊",
	"\\mathbit{j}": "𝒋",
	"\\mathbit{k}": "𝒌",
	"\\mathbit{l}": "𝒍",
	"\\mathbit{m}": "𝒎",
	"\\mathbit{n}": "𝒏",
	"\\mathbit{o}": "𝒐",
	"\\mathbit{p}": "𝒑",
	"\\mathbit{q}": "𝒒",
	"\\mathbit{r}": "𝒓",
	"\\mathbit{s}": "𝒔",
	"\\mathbit{t}": "𝒕",
	"\\mathbit{u}": "𝒖",
	"\\mathbit{v}": "𝒗",
	"\\mathbit{w}": "𝒘",
	"\\mathbit{x}": "𝒙",
	"\\mathbit{y}": "𝒚",
	"\\mathbit{z}": "𝒛",
	"\\mathscr{A}": "𝒜",
	"\\mathscr{C}": "𝒞",
	"\\mathscr{D}": "𝒟",
	"\\mathscr{G}": "𝒢",
	"\\mathscr{J}": "𝒥",
	"\\mathscr{K}": "𝒦",
	"\\mathscr{N}": "𝒩",
	"\\mathscr{O}": "𝒪",
	"\\mathscr{P}": "𝒫",
	"\\mathscr{Q}": "𝒬",
	"\\mathscr{S}": "𝒮",
	"\\mathscr{T}": "𝒯",
	"\\mathscr{U}": "𝒰",
	"\\mathscr{V}": "𝒱",
	"\\mathscr{W}": "𝒲",
	"\\mathscr{X}": "𝒳",
	"\\mathscr{Y}": "𝒴",
	"\\mathscr{Z}": "𝒵",
	"\\mathscr{a}": "𝒶",
	"\\mathscr{b}": "𝒷",
	"\\mathscr{c}": "𝒸",
	"\\mathscr{d}": "𝒹",
	"\\mathscr{f}": "𝒻",
	"\\mathscr{h}": "𝒽",
	"\\mathscr{i}": "𝒾",
	"\\mathscr{j}": "𝒿",
	"\\mathscr{k}": "𝓀",
	"\\mathscr{m}": "𝓂",
	"\\mathscr{n}": "𝓃",
	"\\mathscr{p}": "𝓅",
	"\\mathscr{q}": "𝓆",
	"\\mathscr{r}": "𝓇",
	"\\mathscr{s}": "𝓈",
	"\\mathscr{t}": "𝓉",
	"\\mathscr{u}": "𝓊",
	"\\mathscr{v}": "𝓋",
	"\\mathscr{w}": "𝓌",
	"\\mathscr{x}": "𝓍",
	"\\mathscr{y}": "𝓎",
	"\\mathscr{z}": "𝓏",
	"\\mathmit{A}": "𝓐",
	"\\mathmit{B}": "𝓑",
	"\\mathmit{C}": "𝓒",
	"\\mathmit{D}": "𝓓",
	"\\mathmit{E}": "𝓔",
	"\\mathmit{F}": "𝓕",
	"\\mathmit{G}": "𝓖",
	"\\mathmit{H}": "𝓗",
	"\\mathmit{I}": "𝓘",
	"\\mathmit{J}": "𝓙",
	"\\mathmit{K}": "𝓚",
	"\\mathmit{L}": "𝓛",
	"\\mathmit{M}": "𝓜",
	"\\mathmit{N}": "𝓝",
	"\\mathmit{O}": "𝓞",
	"\\mathmit{P}": "𝓟",
	"\\mathmit{Q}": "𝓠",
	"\\mathmit{R}": "𝓡",
	"\\mathmit{S}": "𝓢",
	"\\mathmit{T}": "𝓣",
	"\\mathmit{U}": "𝓤",
	"\\mathmit{V}": "𝓥",
	"\\mathmit{W}": "𝓦",
	"\\mathmit{X}": "𝓧",
	"\\mathmit{Y}": "𝓨",
	"\\mathmit{Z}": "𝓩",
	"\\mathmit{a}": "𝓪",
	"\\mathmit{b}": "𝓫",
	"\\mathmit{c}": "𝓬",
	"\\mathmit{d}": "𝓭",
	"\\mathmit{e}": "𝓮",
	"\\mathmit{f}": "𝓯",
	"\\mathmit{g}": "𝓰",
	"\\mathmit{h}": "𝓱",
	"\\mathmit{i}": "𝓲",
	"\\mathmit{j}": "𝓳",
	"\\mathmit{k}": "𝓴",
	"\\mathmit{l}": "𝓵",
	"\\mathmit{m}": "𝓶",
	"\\mathmit{n}": "𝓷",
	"\\mathmit{o}": "𝓸",
	"\\mathmit{p}": "𝓹",
	"\\mathmit{q}": "𝓺",
	"\\mathmit{r}": "𝓻",
	"\\mathmit{s}": "𝓼",
	"\\mathmit{t}": "𝓽",
	"\\mathmit{u}": "𝓾",
	"\\mathmit{v}": "𝓿",
	"\\mathmit{w}": "𝔀",
	"\\mathmit{x}": "𝔁",
	"\\mathmit{y}": "𝔂",
	"\\mathmit{z}": "𝔃",
	"\\mathfrak{A}": "𝔄",
	"\\mathfrak{B}": "𝔅",
	"\\mathfrak{D}": "𝔇",
	"\\mathfrak{E}": "𝔈",
	"\\mathfrak{F}": "𝔉",
	"\\mathfrak{G}": "𝔊",
	"\\mathfrak{J}": "𝔍",
	"\\mathfrak{K}": "𝔎",
	"\\mathfrak{L}": "𝔏",
	"\\mathfrak{M}": "𝔐",
	"\\mathfrak{N}": "𝔑",
	"\\mathfrak{O}": "𝔒",
	"\\mathfrak{P}": "𝔓",
	"\\mathfrak{Q}": "𝔔",
	"\\mathfrak{S}": "𝔖",
	"\\mathfrak{T}": "𝔗",
	"\\mathfrak{U}": "𝔘",
	"\\mathfrak{V}": "𝔙",
	"\\mathfrak{W}": "𝔚",
	"\\mathfrak{X}": "𝔛",
	"\\mathfrak{Y}": "𝔜",
	"\\mathfrak{a}": "𝔞",
	"\\mathfrak{b}": "𝔟",
	"\\mathfrak{c}": "𝔠",
	"\\mathfrak{d}": "𝔡",
	"\\mathfrak{e}": "𝔢",
	"\\mathfrak{f}": "𝔣",
	"\\mathfrak{g}": "𝔤",
	"\\mathfrak{h}": "𝔥",
	"\\mathfrak{i}": "𝔦",
	"\\mathfrak{j}": "𝔧",
	"\\mathfrak{k}": "𝔨",
	"\\mathfrak{l}": "𝔩",
	"\\mathfrak{m}": "𝔪",
	"\\mathfrak{n}": "𝔫",
	"\\mathfrak{o}": "𝔬",
	"\\mathfrak{p}": "𝔭",
	"\\mathfrak{q}": "𝔮",
	"\\mathfrak{r}": "𝔯",
	"\\mathfrak{s}": "𝔰",
	"\\mathfrak{t}": "𝔱",
	"\\mathfrak{u}": "𝔲",
	"\\mathfrak{v}": "𝔳",
	"\\mathfrak{w}": "𝔴",
	"\\mathfrak{x}": "𝔵",
	"\\mathfrak{y}": "𝔶",
	"\\mathfrak{z}": "𝔷",
	"\\mathbb{A}": "𝔸",
	"\\mathbb{B}": "𝔹",
	"\\mathbb{D}": "𝔻",
	"\\mathbb{E}": "𝔼",
	"\\mathbb{F}": "𝔽",
	"\\mathbb{G}": "𝔾",
	"\\mathbb{I}": "𝕀",
	"\\mathbb{J}": "𝕁",
	"\\mathbb{K}": "𝕂",
	"\\mathbb{L}": "𝕃",
	"\\mathbb{M}": "𝕄",
	"\\mathbb{O}": "𝕆",
	"\\mathbb{S}": "𝕊",
	"\\mathbb{T}": "𝕋",
	"\\mathbb{U}": "𝕌",
	"\\mathbb{V}": "𝕍",
	"\\mathbb{W}": "𝕎",
	"\\mathbb{X}": "𝕏",
	"\\mathbb{Y}": "𝕐",
	"\\mathbb{a}": "𝕒",
	"\\mathbb{b}": "𝕓",
	"\\mathbb{c}": "𝕔",
	"\\mathbb{d}": "𝕕",
	"\\mathbb{e}": "𝕖",
	"\\mathbb{f}": "𝕗",
	"\\mathbb{g}": "𝕘",
	"\\mathbb{h}": "𝕙",
	"\\mathbb{i}": "𝕚",
	"\\mathbb{j}": "𝕛",
	"\\mathbb{k}": "𝕜",
	"\\mathbb{l}": "𝕝",
	"\\mathbb{m}": "𝕞",
	"\\mathbb{n}": "𝕟",
	"\\mathbb{o}": "𝕠",
	"\\mathbb{p}": "𝕡",
	"\\mathbb{q}": "𝕢",
	"\\mathbb{r}": "𝕣",
	"\\mathbb{s}": "𝕤",
	"\\mathbb{t}": "𝕥",
	"\\mathbb{u}": "𝕦",
	"\\mathbb{v}": "𝕧",
	"\\mathbb{w}": "𝕨",
	"\\mathbb{x}": "𝕩",
	"\\mathbb{y}": "𝕪",
	"\\mathbb{z}": "𝕫",
	"\\mathslbb{A}": "𝕬",
	"\\mathslbb{B}": "𝕭",
	"\\mathslbb{C}": "𝕮",
	"\\mathslbb{D}": "𝕯",
	"\\mathslbb{E}": "𝕰",
	"\\mathslbb{F}": "𝕱",
	"\\mathslbb{G}": "𝕲",
	"\\mathslbb{H}": "𝕳",
	"\\mathslbb{I}": "𝕴",
	"\\mathslbb{J}": "𝕵",
	"\\mathslbb{K}": "𝕶",
	"\\mathslbb{L}": "𝕷",
	"\\mathslbb{M}": "𝕸",
	"\\mathslbb{N}": "𝕹",
	"\\mathslbb{O}": "𝕺",
	"\\mathslbb{P}": "𝕻",
	"\\mathslbb{Q}": "𝕼",
	"\\mathslbb{R}": "𝕽",
	"\\mathslbb{S}": "𝕾",
	"\\mathslbb{T}": "𝕿",
	"\\mathslbb{U}": "𝖀",
	"\\mathslbb{V}": "𝖁",
	"\\mathslbb{W}": "𝖂",
	"\\mathslbb{X}": "𝖃",
	"\\mathslbb{Y}": "𝖄",
	"\\mathslbb{Z}": "𝖅",
	"\\mathslbb{a}": "𝖆",
	"\\mathslbb{b}": "𝖇",
	"\\mathslbb{c}": "𝖈",
	"\\mathslbb{d}": "𝖉",
	"\\mathslbb{e}": "𝖊",
	"\\mathslbb{f}": "𝖋",
	"\\mathslbb{g}": "𝖌",
	"\\mathslbb{h}": "𝖍",
	"\\mathslbb{i}": "𝖎",
	"\\mathslbb{j}": "𝖏",
	"\\mathslbb{k}": "𝖐",
	"\\mathslbb{l}": "𝖑",
	"\\mathslbb{m}": "𝖒",
	"\\mathslbb{n}": "𝖓",
	"\\mathslbb{o}": "𝖔",
	"\\mathslbb{p}": "𝖕",
	"\\mathslbb{q}": "𝖖",
	"\\mathslbb{r}": "𝖗",
	"\\mathslbb{s}": "𝖘",
	"\\mathslbb{t}": "𝖙",
	"\\mathslbb{u}": "𝖚",
	"\\mathslbb{v}": "𝖛",
	"\\mathslbb{w}": "𝖜",
	"\\mathslbb{x}": "𝖝",
	"\\mathslbb{y}": "𝖞",
	"\\mathslbb{z}": "𝖟",
	"\\mathsf{A}": "𝖠",
	"\\mathsf{B}": "𝖡",
	"\\mathsf{C}": "𝖢",
	"\\mathsf{D}": "𝖣",
	"\\mathsf{E}": "𝖤",
	"\\mathsf{F}": "𝖥",
	"\\mathsf{G}": "𝖦",
	"\\mathsf{H}": "𝖧",
	"\\mathsf{I}": "𝖨",
	"\\mathsf{J}": "𝖩",
	"\\mathsf{K}": "𝖪",
	"\\mathsf{L}": "𝖫",
	"\\mathsf{M}": "𝖬",
	"\\mathsf{N}": "𝖭",
	"\\mathsf{O}": "𝖮",
	"\\mathsf{P}": "𝖯",
	"\\mathsf{Q}": "𝖰",
	"\\mathsf{R}": "𝖱",
	"\\mathsf{S}": "𝖲",
	"\\mathsf{T}": "𝖳",
	"\\mathsf{U}": "𝖴",
	"\\mathsf{V}": "𝖵",
	"\\mathsf{W}": "𝖶",
	"\\mathsf{X}": "𝖷",
	"\\mathsf{Y}": "𝖸",
	"\\mathsf{Z}": "𝖹",
	"\\mathsf{a}": "𝖺",
	"\\mathsf{b}": "𝖻",
	"\\mathsf{c}": "𝖼",
	"\\mathsf{d}": "𝖽",
	"\\mathsf{e}": "𝖾",
	"\\mathsf{f}": "𝖿",
	"\\mathsf{g}": "𝗀",
	"\\mathsf{h}": "𝗁",
	"\\mathsf{i}": "𝗂",
	"\\mathsf{j}": "𝗃",
	"\\mathsf{k}": "𝗄",
	"\\mathsf{l}": "𝗅",
	"\\mathsf{m}": "𝗆",
	"\\mathsf{n}": "𝗇",
	"\\mathsf{o}": "𝗈",
	"\\mathsf{p}": "𝗉",
	"\\mathsf{q}": "𝗊",
	"\\mathsf{r}": "𝗋",
	"\\mathsf{s}": "𝗌",
	"\\mathsf{t}": "𝗍",
	"\\mathsf{u}": "𝗎",
	"\\mathsf{v}": "𝗏",
	"\\mathsf{w}": "𝗐",
	"\\mathsf{x}": "𝗑",
	"\\mathsf{y}": "𝗒",
	"\\mathsf{z}": "𝗓",
	"\\mathsfbf{A}": "𝗔",
	"\\mathsfbf{B}": "𝗕",
	"\\mathsfbf{C}": "𝗖",
	"\\mathsfbf{D}": "𝗗",
	"\\mathsfbf{E}": "𝗘",
	"\\mathsfbf{F}": "𝗙",
	"\\mathsfbf{G}": "𝗚",
	"\\mathsfbf{H}": "𝗛",
	"\\mathsfbf{I}": "𝗜",
	"\\mathsfbf{J}": "𝗝",
	"\\mathsfbf{K}": "𝗞",
	"\\mathsfbf{L}": "𝗟",
	"\\mathsfbf{M}": "𝗠",
	"\\mathsfbf{N}": "𝗡",
	"\\mathsfbf{O}": "𝗢",
	"\\mathsfbf{P}": "𝗣",
	"\\mathsfbf{Q}": "𝗤",
	"\\mathsfbf{R}": "𝗥",
	"\\mathsfbf{S}": "𝗦",
	"\\mathsfbf{T}": "𝗧",
	"\\mathsfbf{U}": "𝗨",
	"\\mathsfbf{V}": "𝗩",
	"\\mathsfbf{W}": "𝗪",
	"\\mathsfbf{X}": "𝗫",
	"\\mathsfbf{Y}": "𝗬",
	"\\mathsfbf{Z}": "𝗭",
	"\\mathsfbf{a}": "𝗮",
	"\\mathsfbf{b}": "𝗯",
	"\\mathsfbf{c}": "𝗰",
	"\\mathsfbf{d}": "𝗱",
	"\\mathsfbf{e}": "𝗲",
	"\\mathsfbf{f}": "𝗳",
	"\\mathsfbf{g}": "𝗴",
	"\\mathsfbf{h}": "𝗵",
	"\\mathsfbf{i}": "𝗶",
	"\\mathsfbf{j}": "𝗷",
	"\\mathsfbf{k}": "𝗸",
	"\\mathsfbf{l}": "𝗹",
	"\\mathsfbf{m}": "𝗺",
	"\\mathsfbf{n}": "𝗻",
	"\\mathsfbf{o}": "𝗼",
	"\\mathsfbf{p}": "𝗽",
	"\\mathsfbf{q}": "𝗾",
	"\\mathsfbf{r}": "𝗿",
	"\\mathsfbf{s}": "𝘀",
	"\\mathsfbf{t}": "𝘁",
	"\\mathsfbf{u}": "𝘂",
	"\\mathsfbf{v}": "𝘃",
	"\\mathsfbf{w}": "𝘄",
	"\\mathsfbf{x}": "𝘅",
	"\\mathsfbf{y}": "𝘆",
	"\\mathsfbf{z}": "𝘇",
	"\\mathsfsl{A}": "𝘈",
	"\\mathsfsl{B}": "𝘉",
	"\\mathsfsl{C}": "𝘊",
	"\\mathsfsl{D}": "𝘋",
	"\\mathsfsl{E}": "𝘌",
	"\\mathsfsl{F}": "𝘍",
	"\\mathsfsl{G}": "𝘎",
	"\\mathsfsl{H}": "𝘏",
	"\\mathsfsl{I}": "𝘐",
	"\\mathsfsl{J}": "𝘑",
	"\\mathsfsl{K}": "𝘒",
	"\\mathsfsl{L}": "𝘓",
	"\\mathsfsl{M}": "𝘔",
	"\\mathsfsl{N}": "𝘕",
	"\\mathsfsl{O}": "𝘖",
	"\\mathsfsl{P}": "𝘗",
	"\\mathsfsl{Q}": "𝘘",
	"\\mathsfsl{R}": "𝘙",
	"\\mathsfsl{S}": "𝘚",
	"\\mathsfsl{T}": "𝘛",
	"\\mathsfsl{U}": "𝘜",
	"\\mathsfsl{V}": "𝘝",
	"\\mathsfsl{W}": "𝘞",
	"\\mathsfsl{X}": "𝘟",
	"\\mathsfsl{Y}": "𝘠",
	"\\mathsfsl{Z}": "𝘡",
	"\\mathsfsl{a}": "𝘢",
	"\\mathsfsl{b}": "𝘣",
	"\\mathsfsl{c}": "𝘤",
	"\\mathsfsl{d}": "𝘥",
	"\\mathsfsl{e}": "𝘦",
	"\\mathsfsl{f}": "𝘧",
	"\\mathsfsl{g}": "𝘨",
	"\\mathsfsl{h}": "𝘩",
	"\\mathsfsl{i}": "𝘪",
	"\\mathsfsl{j}": "𝘫",
	"\\mathsfsl{k}": "𝘬",
	"\\mathsfsl{l}": "𝘭",
	"\\mathsfsl{m}": "𝘮",
	"\\mathsfsl{n}": "𝘯",
	"\\mathsfsl{o}": "𝘰",
	"\\mathsfsl{p}": "𝘱",
	"\\mathsfsl{q}": "𝘲",
	"\\mathsfsl{r}": "𝘳",
	"\\mathsfsl{s}": "𝘴",
	"\\mathsfsl{t}": "𝘵",
	"\\mathsfsl{u}": "𝘶",
	"\\mathsfsl{v}": "𝘷",
	"\\mathsfsl{w}": "𝘸",
	"\\mathsfsl{x}": "𝘹",
	"\\mathsfsl{y}": "𝘺",
	"\\mathsfsl{z}": "𝘻",
	"\\mathsfbfsl{A}": "𝘼",
	"\\mathsfbfsl{B}": "𝘽",
	"\\mathsfbfsl{C}": "𝘾",
	"\\mathsfbfsl{D}": "𝘿",
	"\\mathsfbfsl{E}": "𝙀",
	"\\mathsfbfsl{F}": "𝙁",
	"\\mathsfbfsl{G}": "𝙂",
	"\\mathsfbfsl{H}": "𝙃",
	"\\mathsfbfsl{I}": "𝙄",
	"\\mathsfbfsl{J}": "𝙅",
	"\\mathsfbfsl{K}": "𝙆",
	"\\mathsfbfsl{L}": "𝙇",
	"\\mathsfbfsl{M}": "𝙈",
	"\\mathsfbfsl{N}": "𝙉",
	"\\mathsfbfsl{O}": "𝙊",
	"\\mathsfbfsl{P}": "𝙋",
	"\\mathsfbfsl{Q}": "𝙌",
	"\\mathsfbfsl{R}": "𝙍",
	"\\mathsfbfsl{S}": "𝙎",
	"\\mathsfbfsl{T}": "𝙏",
	"\\mathsfbfsl{U}": "𝙐",
	"\\mathsfbfsl{V}": "𝙑",
	"\\mathsfbfsl{W}": "𝙒",
	"\\mathsfbfsl{X}": "𝙓",
	"\\mathsfbfsl{Y}": "𝙔",
	"\\mathsfbfsl{Z}": "𝙕",
	"\\mathsfbfsl{a}": "𝙖",
	"\\mathsfbfsl{b}": "𝙗",
	"\\mathsfbfsl{c}": "𝙘",
	"\\mathsfbfsl{d}": "𝙙",
	"\\mathsfbfsl{e}": "𝙚",
	"\\mathsfbfsl{f}": "𝙛",
	"\\mathsfbfsl{g}": "𝙜",
	"\\mathsfbfsl{h}": "𝙝",
	"\\mathsfbfsl{i}": "𝙞",
	"\\mathsfbfsl{j}": "𝙟",
	"\\mathsfbfsl{k}": "𝙠",
	"\\mathsfbfsl{l}": "𝙡",
	"\\mathsfbfsl{m}": "𝙢",
	"\\mathsfbfsl{n}": "𝙣",
	"\\mathsfbfsl{o}": "𝙤",
	"\\mathsfbfsl{p}": "𝙥",
	"\\mathsfbfsl{q}": "𝙦",
	"\\mathsfbfsl{r}": "𝙧",
	"\\mathsfbfsl{s}": "𝙨",
	"\\mathsfbfsl{t}": "𝙩",
	"\\mathsfbfsl{u}": "𝙪",
	"\\mathsfbfsl{v}": "𝙫",
	"\\mathsfbfsl{w}": "𝙬",
	"\\mathsfbfsl{x}": "𝙭",
	"\\mathsfbfsl{y}": "𝙮",
	"\\mathsfbfsl{z}": "𝙯",
	"\\mathtt{A}": "𝙰",
	"\\mathtt{B}": "𝙱",
	"\\mathtt{C}": "𝙲",
	"\\mathtt{D}": "𝙳",
	"\\mathtt{E}": "𝙴",
	"\\mathtt{F}": "𝙵",
	"\\mathtt{G}": "𝙶",
	"\\mathtt{H}": "𝙷",
	"\\mathtt{I}": "𝙸",
	"\\mathtt{J}": "𝙹",
	"\\mathtt{K}": "𝙺",
	"\\mathtt{L}": "𝙻",
	"\\mathtt{M}": "𝙼",
	"\\mathtt{N}": "𝙽",
	"\\mathtt{O}": "𝙾",
	"\\mathtt{P}": "𝙿",
	"\\mathtt{Q}": "𝚀",
	"\\mathtt{R}": "𝚁",
	"\\mathtt{S}": "𝚂",
	"\\mathtt{T}": "𝚃",
	"\\mathtt{U}": "𝚄",
	"\\mathtt{V}": "𝚅",
	"\\mathtt{W}": "𝚆",
	"\\mathtt{X}": "𝚇",
	"\\mathtt{Y}": "𝚈",
	"\\mathtt{Z}": "𝚉",
	"\\mathtt{a}": "𝚊",
	"\\mathtt{b}": "𝚋",
	"\\mathtt{c}": "𝚌",
	"\\mathtt{d}": "𝚍",
	"\\mathtt{e}": "𝚎",
	"\\mathtt{f}": "𝚏",
	"\\mathtt{g}": "𝚐",
	"\\mathtt{h}": "𝚑",
	"\\mathtt{i}": "𝚒",
	"\\mathtt{j}": "𝚓",
	"\\mathtt{k}": "𝚔",
	"\\mathtt{l}": "𝚕",
	"\\mathtt{m}": "𝚖",
	"\\mathtt{n}": "𝚗",
	"\\mathtt{o}": "𝚘",
	"\\mathtt{p}": "𝚙",
	"\\mathtt{q}": "𝚚",
	"\\mathtt{r}": "𝚛",
	"\\mathtt{s}": "𝚜",
	"\\mathtt{t}": "𝚝",
	"\\mathtt{u}": "𝚞",
	"\\mathtt{v}": "𝚟",
	"\\mathtt{w}": "𝚠",
	"\\mathtt{x}": "𝚡",
	"\\mathtt{y}": "𝚢",
	"\\mathtt{z}": "𝚣",
	"\\mathbf{\\Gamma}": "𝚪",
	"\\mathbf{\\Delta}": "𝚫",
	"\\mathbf{\\Theta}": "𝚯",
	"\\mathbf{\\Lambda}": "𝚲",
	"\\mathbf{\\Xi}": "𝚵",
	"\\mathbf{\\Pi}": "𝚷",
	"\\mathbf{\\vartheta}": "𝚹",
	"\\mathbf{\\Sigma}": "𝚺",
	"\\mathbf{\\Upsilon}": "𝚼",
	"\\mathbf{\\Phi}": "𝚽",
	"\\mathbf{\\Psi}": "𝚿",
	"\\mathbf{\\Omega}": "𝛀",
	"\\mathbf{\\nabla}": "𝛁",
	"\\mathbf{\\alpha}": "𝛂",
	"\\mathbf{\\beta}": "𝛃",
	"\\mathbf{\\gamma}": "𝛄",
	"\\mathbf{\\delta}": "𝛅",
	"\\mathbf{\\epsilon}": "𝛆",
	"\\mathbf{\\zeta}": "𝛇",
	"\\mathbf{\\eta}": "𝛈",
	"\\mathbf{\\theta}": "𝛉",
	"\\mathbf{\\lambda}": "𝛌",
	"\\mathbf{\\xi}": "𝛏",
	"\\mathbf{\\pi}": "𝛑",
	"\\mathbf{\\varsigma}": "𝛓",
	"\\mathbf{\\sigma}": "𝛔",
	"\\mathbf{\\upsilon}": "𝛖",
	"\\mathbf{\\phi}": "𝛗",
	"\\mathbf{\\psi}": "𝛙",
	"\\mathbf{\\omega}": "𝛚",
	"\\mathbf{\\varkappa}": "𝛞",
	"\\mathbf{\\varrho}": "𝛠",
	"\\mathbf{\\varpi}": "𝛡",
	"\\mathsl{\\Gamma}": "𝛤",
	"\\mathsl{\\Delta}": "𝛥",
	"\\mathsl{\\Lambda}": "𝛬",
	"\\mathsl{\\Xi}": "𝛯",
	"\\mathsl{\\Pi}": "𝛱",
	"\\mathsl{\\Theta}": "𝛳",
	"\\mathsl{\\Sigma}": "𝛴",
	"\\mathsl{\\Upsilon}": "𝛶",
	"\\mathsl{\\Phi}": "𝛷",
	"\\mathsl{\\Psi}": "𝛹",
	"\\mathsl{\\Omega}": "𝛺",
	"\\mathsl{\\nabla}": "𝛻",
	"\\mathsl{\\gamma}": "𝛾",
	"\\mathsl{\\delta}": "𝛿",
	"\\mathsl{\\theta}": "𝜃",
	"\\mathsl{\\lambda}": "𝜆",
	"\\mu": "𝜇",
	"\\mathsl{\\xi}": "𝜉",
	"\\mathsl{\\pi}": "𝜋",
	"\\mathsl{\\varsigma}": "𝜍",
	"\\mathsl{\\sigma}": "𝜎",
	"\\mathsl{\\upsilon}": "𝜐",
	"\\mathsl{\\varphi}": "𝜑",
	"\\mathsl{\\psi}": "𝜓",
	"\\mathsl{\\omega}": "𝜔",
	"\\mathsl{\\vartheta}": "𝜗",
	"\\mathsl{\\varkappa}": "𝜘",
	"\\mathsl{\\phi}": "𝜙",
	"\\mathsl{\\varrho}": "𝜚",
	"\\mathsl{\\varpi}": "𝜛",
	"\\mathbit{\\Gamma}": "𝜞",
	"\\mathbit{\\Delta}": "𝜟",
	"\\mathbit{\\Theta}": "𝜣",
	"\\mathbit{\\Lambda}": "𝜦",
	"\\mathbit{\\Xi}": "𝜩",
	"\\mathbit{\\Pi}": "𝜫",
	"\\mathbit{\\Sigma}": "𝜮",
	"\\mathbit{\\Upsilon}": "𝜰",
	"\\mathbit{\\Phi}": "𝜱",
	"\\mathbit{\\Psi}": "𝜳",
	"\\mathbit{\\Omega}": "𝜴",
	"\\mathbit{\\nabla}": "𝜵",
	"\\mathbit{\\alpha}": "𝜶",
	"\\mathbit{\\beta}": "𝜷",
	"\\mathbit{\\gamma}": "𝜸",
	"\\mathbit{\\delta}": "𝜹",
	"\\mathbit{\\epsilon}": "𝜺",
	"\\mathbit{\\zeta}": "𝜻",
	"\\mathbit{\\eta}": "𝜼",
	"\\mathbit{\\theta}": "𝜽",
	"\\mathbit{\\imath}": "𝜾",
	"\\mathbit{\\kappa}": "𝜿",
	"\\mathbit{\\lambda}": "𝝀",
	"\\mathbit{\\xi}": "𝝃",
	"\\mathbit{\\pi}": "𝝅",
	"\\mathbit{\\rho}": "𝝆",
	"\\mathbit{\\varsigma}": "𝝇",
	"\\mathbit{\\sigma}": "𝝈",
	"\\mathbit{\\tau}": "𝝉",
	"\\mathbit{\\upsilon}": "𝝊",
	"\\mathbit{\\varphi}": "𝝋",
	"\\mathbit{\\chi}": "𝝌",
	"\\mathbit{\\psi}": "𝝍",
	"\\mathbit{\\omega}": "𝝎",
	"\\mathbit{\\vartheta}": "𝝑",
	"\\mathbit{\\varkappa}": "𝝒",
	"\\mathbit{\\phi}": "𝝓",
	"\\mathbit{\\varrho}": "𝝔",
	"\\mathbit{\\varpi}": "𝝕",
	"\\mathsfbf{\\Gamma}": "𝝘",
	"\\mathsfbf{\\Delta}": "𝝙",
	"\\mathsfbf{\\Theta}": "𝝝",
	"\\mathsfbf{\\Lambda}": "𝝠",
	"\\mathsfbf{\\Xi}": "𝝣",
	"\\mathsfbf{\\Pi}": "𝝥",
	"\\mathsfbf{\\Sigma}": "𝝨",
	"\\mathsfbf{\\Upsilon}": "𝝪",
	"\\mathsfbf{\\Phi}": "𝝫",
	"\\mathsfbf{\\Psi}": "𝝭",
	"\\mathsfbf{\\Omega}": "𝝮",
	"\\mathsfbf{\\nabla}": "𝝯",
	"\\mathsfbf{\\alpha}": "𝝰",
	"\\mathsfbf{\\beta}": "𝝱",
	"\\mathsfbf{\\gamma}": "𝝲",
	"\\mathsfbf{\\delta}": "𝝳",
	"\\mathsfbf{\\varepsilon}": "𝝴",
	"\\mathsfbf{\\zeta}": "𝝵",
	"\\mathsfbf{\\eta}": "𝝶",
	"\\mathsfbf{\\theta}": "𝝷",
	"\\mathsfbf{\\imath}": "𝝸",
	"\\mathsfbf{\\kappa}": "𝝹",
	"\\mathsfbf{\\lambda}": "𝝺",
	"\\mathsfbf{\\xi}": "𝝽",
	"\\mathsfbf{\\pi}": "𝝿",
	"\\mathsfbf{\\rho}": "𝞀",
	"\\mathsfbf{\\varsigma}": "𝞁",
	"\\mathsfbf{\\sigma}": "𝞂",
	"\\mathsfbf{\\tau}": "𝞃",
	"\\mathsfbf{\\upsilon}": "𝞄",
	"\\mathsfbf{\\varphi}": "𝞅",
	"\\mathsfbf{\\chi}": "𝞆",
	"\\mathsfbf{\\psi}": "𝞇",
	"\\mathsfbf{\\omega}": "𝞈",
	"\\mathsfbf{\\vartheta}": "𝞋",
	"\\mathsfbf{\\varkappa}": "𝞌",
	"\\mathsfbf{\\phi}": "𝞍",
	"\\mathsfbf{\\varrho}": "𝞎",
	"\\mathsfbf{\\varpi}": "𝞏",
	"\\mathsfbfsl{\\Gamma}": "𝞒",
	"\\mathsfbfsl{\\Delta}": "𝞓",
	"\\mathsfbfsl{\\Theta}": "𝞗",
	"\\mathsfbfsl{\\Lambda}": "𝞚",
	"\\mathsfbfsl{\\Xi}": "𝞝",
	"\\mathsfbfsl{\\Pi}": "𝞟",
	"\\mathsfbfsl{\\Sigma}": "𝞢",
	"\\mathsfbfsl{\\Upsilon}": "𝞤",
	"\\mathsfbfsl{\\Phi}": "𝞥",
	"\\mathsfbfsl{\\Psi}": "𝞧",
	"\\mathsfbfsl{\\Omega}": "𝞨",
	"\\mathsfbfsl{\\nabla}": "𝞩",
	"\\mathsfbfsl{\\alpha}": "𝞪",
	"\\mathsfbfsl{\\beta}": "𝞫",
	"\\mathsfbfsl{\\gamma}": "𝞬",
	"\\mathsfbfsl{\\delta}": "𝞭",
	"\\mathsfbfsl{\\varepsilon}": "𝞮",
	"\\mathsfbfsl{\\zeta}": "𝞯",
	"\\mathsfbfsl{\\eta}": "𝞰",
	"\\mathsfbfsl{\\theta}": "𝞱",
	"\\mathsfbfsl{\\imath}": "𝞲",
	"\\mathsfbfsl{\\kappa}": "𝞳",
	"\\mathsfbfsl{\\lambda}": "𝞴",
	"\\mathsfbfsl{\\xi}": "𝞷",
	"\\mathsfbfsl{\\pi}": "𝞹",
	"\\mathsfbfsl{\\rho}": "𝞺",
	"\\mathsfbfsl{\\varsigma}": "𝞻",
	"\\mathsfbfsl{\\sigma}": "𝞼",
	"\\mathsfbfsl{\\tau}": "𝞽",
	"\\mathsfbfsl{\\upsilon}": "𝞾",
	"\\mathsfbfsl{\\varphi}": "𝞿",
	"\\mathsfbfsl{\\chi}": "𝟀",
	"\\mathsfbfsl{\\psi}": "𝟁",
	"\\mathsfbfsl{\\omega}": "𝟂",
	"\\mathsfbfsl{\\vartheta}": "𝟅",
	"\\mathsfbfsl{\\varkappa}": "𝟆",
	"\\mathsfbfsl{\\phi}": "𝟇",
	"\\mathsfbfsl{\\varrho}": "𝟈",
	"\\mathsfbfsl{\\varpi}": "𝟉",
	"\\mbfDigamma": "𝟊",
	"\\mbfdigamma": "𝟋",
	"\\mathbf{0}": "𝟎",
	"\\mathbf{1}": "𝟏",
	"\\mathbf{2}": "𝟐",
	"\\mathbf{3}": "𝟑",
	"\\mathbf{4}": "𝟒",
	"\\mathbf{5}": "𝟓",
	"\\mathbf{6}": "𝟔",
	"\\mathbf{7}": "𝟕",
	"\\mathbf{8}": "𝟖",
	"\\mathbf{9}": "𝟗",
	"\\mathbb{0}": "𝟘",
	"\\mathbb{1}": "𝟙",
	"\\mathbb{2}": "𝟚",
	"\\mathbb{3}": "𝟛",
	"\\mathbb{4}": "𝟜",
	"\\mathbb{5}": "𝟝",
	"\\mathbb{6}": "𝟞",
	"\\mathbb{7}": "𝟟",
	"\\mathbb{8}": "𝟠",
	"\\mathbb{9}": "𝟡",
	"\\mathsf{0}": "𝟢",
	"\\mathsf{1}": "𝟣",
	"\\mathsf{2}": "𝟤",
	"\\mathsf{3}": "𝟥",
	"\\mathsf{4}": "𝟦",
	"\\mathsf{5}": "𝟧",
	"\\mathsf{6}": "𝟨",
	"\\mathsf{7}": "𝟩",
	"\\mathsf{8}": "𝟪",
	"\\mathsf{9}": "𝟫",
	"\\mathsfbf{0}": "𝟬",
	"\\mathsfbf{1}": "𝟭",
	"\\mathsfbf{2}": "𝟮",
	"\\mathsfbf{3}": "𝟯",
	"\\mathsfbf{4}": "𝟰",
	"\\mathsfbf{5}": "𝟱",
	"\\mathsfbf{6}": "𝟲",
	"\\mathsfbf{7}": "𝟳",
	"\\mathsfbf{8}": "𝟴",
	"\\mathsfbf{9}": "𝟵",
	"\\mathtt{0}": "𝟶",
	"\\mathtt{1}": "𝟷",
	"\\mathtt{2}": "𝟸",
	"\\mathtt{3}": "𝟹",
	"\\mathtt{4}": "𝟺",
	"\\mathtt{5}": "𝟻",
	"\\mathtt{6}": "𝟼",
	"\\mathtt{7}": "𝟽",
	"\\mathtt{8}": "𝟾",
	"\\mathtt{9}": "𝟿"
};

var commands = [
	"acute",
	"bar",
	"breve",
	"c",
	"d",
	"ddot",
	"dot",
	"grave",
	"hat",
	"k",
	"mathring",
	"overline",
	"r",
	"textacutemacron",
	"textacutewedge",
	"textadvancing",
	"textbrevemacron",
	"textcircumdot",
	"textcorner",
	"textdotacute",
	"textdotbreve",
	"textdoublegrave",
	"textdoublevbaraccent",
	"textgravedot",
	"textgravemacron",
	"textinvsubbridge",
	"textlowering",
	"textovercross",
	"textraising",
	"textretracting",
	"textringmacron",
	"textseagull",
	"textsubarch",
	"textsubbar",
	"textsubbridge",
	"textsubgrave",
	"textsublhalfring",
	"textsubplus",
	"textsubrhalfring",
	"textsubring",
	"textsubsquare",
	"textsubtilde",
	"textsubumlaut",
	"textsubwedge",
	"textsuperimposetilde",
	"textsyllabic",
	"texttildedot",
	"textvbaraccent",
	"tilde",
	"u",
	"underbar",
	"v"
];
var tolatex = {
	"̀": {
		command: "`",
		mode: "text"
	},
	"̀̄": {
		command: "textgravemacron",
		mode: "text"
	},
	"̀̇": {
		command: "textgravedot",
		mode: "text"
	},
	"́": {
		command: "'",
		mode: "text"
	},
	"́̄": {
		command: "textacutemacron",
		mode: "text"
	},
	"́̇": {
		command: "textdotacute",
		mode: "text"
	},
	"́̌": {
		command: "textacutewedge",
		mode: "text"
	},
	"̂": {
		command: "^",
		mode: "text"
	},
	"̂̇": {
		command: "textcircumdot",
		mode: "text"
	},
	"̃": {
		command: "~",
		mode: "text"
	},
	"̃̇": {
		command: "texttildedot",
		mode: "text"
	},
	"̄": {
		command: "=",
		mode: "text"
	},
	"̄̀": {
		command: "textgravemacron",
		mode: "text"
	},
	"̄́": {
		command: "textacutemacron",
		mode: "text"
	},
	"̄̆": {
		command: "textbrevemacron",
		mode: "text"
	},
	"̄̊": {
		command: "textringmacron",
		mode: "text"
	},
	"̅": {
		command: "overline",
		mode: "math"
	},
	"̆": {
		command: "u",
		mode: "text"
	},
	"̆̄": {
		command: "textbrevemacron",
		mode: "text"
	},
	"̆̇": {
		command: "textdotbreve",
		mode: "text"
	},
	"̇": {
		command: ".",
		mode: "text"
	},
	"̇̀": {
		command: "textgravedot",
		mode: "text"
	},
	"̇́": {
		command: "textdotacute",
		mode: "text"
	},
	"̇̂": {
		command: "textcircumdot",
		mode: "text"
	},
	"̇̃": {
		command: "texttildedot",
		mode: "text"
	},
	"̇̆": {
		command: "textdotbreve",
		mode: "text"
	},
	"̈": {
		command: "\"",
		mode: "text"
	},
	"̊": {
		command: "r",
		mode: "text"
	},
	"̊̄": {
		command: "textringmacron",
		mode: "text"
	},
	"̋": {
		command: "H",
		mode: "text"
	},
	"̌": {
		command: "v",
		mode: "text"
	},
	"̌́": {
		command: "textacutewedge",
		mode: "text"
	},
	"̍": {
		command: "textvbaraccent",
		mode: "text"
	},
	"̎": {
		command: "textdoublevbaraccent",
		mode: "text"
	},
	"̏": {
		command: "textdoublegrave",
		mode: "text"
	},
	"̐": {
		command: "textdotbreve",
		mode: "text"
	},
	"̖": {
		command: "textsubgrave",
		mode: "text"
	},
	"̘": {
		command: "textadvancing",
		mode: "text"
	},
	"̙": {
		command: "textretracting",
		mode: "text"
	},
	"̚": {
		command: "textcorner",
		mode: "text"
	},
	"̜": {
		command: "textsublhalfring",
		mode: "text"
	},
	"̝": {
		command: "textraising",
		mode: "text"
	},
	"̞": {
		command: "textlowering",
		mode: "text"
	},
	"̟": {
		command: "textsubplus",
		mode: "text"
	},
	"̣": {
		command: "d",
		mode: "text"
	},
	"̤": {
		command: "textsubumlaut",
		mode: "text"
	},
	"̥": {
		command: "textsubring",
		mode: "text"
	},
	"̧": {
		command: "c",
		mode: "text"
	},
	"̨": {
		command: "k",
		mode: "text"
	},
	"̩": {
		command: "textsyllabic",
		mode: "text"
	},
	"̪": {
		command: "textsubbridge",
		mode: "text"
	},
	"̬": {
		command: "textsubwedge",
		mode: "text"
	},
	"̯": {
		command: "textsubarch",
		mode: "text"
	},
	"̰": {
		command: "textsubtilde",
		mode: "text"
	},
	"̱": {
		command: "textsubbar",
		mode: "text"
	},
	"̴": {
		command: "textsuperimposetilde",
		mode: "text"
	},
	"̹": {
		command: "textsubrhalfring",
		mode: "text"
	},
	"̺": {
		command: "textinvsubbridge",
		mode: "text"
	},
	"̻": {
		command: "textsubsquare",
		mode: "text"
	},
	"̼": {
		command: "textseagull",
		mode: "text"
	},
	"̽": {
		command: "textovercross",
		mode: "text"
	}
};
var tounicode = {
	"\"": "̈",
	"'": "́",
	".": "̇",
	"=": "̄",
	H: "̋",
	"^": "̂",
	"`": "̀",
	acute: "́",
	bar: "̄",
	breve: "̆",
	c: "̧",
	d: "̣",
	ddot: "̈",
	dot: "̇",
	grave: "̀",
	hat: "̂",
	k: "̨",
	mathring: "̊",
	overline: "̅",
	r: "̊",
	textacutemacron: "̄́",
	textacutewedge: "̌́",
	textadvancing: "̘",
	textbrevemacron: "̄̆",
	textcircumdot: "̇̂",
	textcorner: "̚",
	textdotacute: "́̇",
	textdotbreve: "̐",
	textdoublegrave: "̏",
	textdoublevbaraccent: "̎",
	textgravedot: "̇̀",
	textgravemacron: "̀̄",
	textinvsubbridge: "̺",
	textlowering: "̞",
	textovercross: "̽",
	textraising: "̝",
	textretracting: "̙",
	textringmacron: "̄̊",
	textseagull: "̼",
	textsubarch: "̯",
	textsubbar: "̱",
	textsubbridge: "̪",
	textsubgrave: "̖",
	textsublhalfring: "̜",
	textsubplus: "̟",
	textsubrhalfring: "̹",
	textsubring: "̥",
	textsubsquare: "̻",
	textsubtilde: "̰",
	textsubumlaut: "̤",
	textsubwedge: "̬",
	textsuperimposetilde: "̴",
	textsyllabic: "̩",
	texttildedot: "̇̃",
	textvbaraccent: "̍",
	tilde: "̃",
	u: "̆",
	underbar: "̱",
	v: "̌",
	"~": "̃"
};
var require$$4 = {
	commands: commands,
	tolatex: tolatex,
	tounicode: tounicode
};

var unicode2latex = {
  ascii: require$$0$1,
  ascii_bibtex_creator: require$$1,
  unicode: require$$2,
  latex: require$$3,
  diacritics: require$$4,
};

var categories = [
    {
        'name': 'C',
        'alias': 'Other',
        'isBmpLast': true,
        'bmp': '\0-\x1F\x7F-\x9F\xAD\u0378\u0379\u0380-\u0383\u038B\u038D\u03A2\u0530\u0557\u0558\u058B\u058C\u0590\u05C8-\u05CF\u05EB-\u05EE\u05F5-\u0605\u061C\u061D\u06DD\u070E\u070F\u074B\u074C\u07B2-\u07BF\u07FB\u07FC\u082E\u082F\u083F\u085C\u085D\u085F\u086B-\u089F\u08B5\u08C8-\u08D2\u08E2\u0984\u098D\u098E\u0991\u0992\u09A9\u09B1\u09B3-\u09B5\u09BA\u09BB\u09C5\u09C6\u09C9\u09CA\u09CF-\u09D6\u09D8-\u09DB\u09DE\u09E4\u09E5\u09FF\u0A00\u0A04\u0A0B-\u0A0E\u0A11\u0A12\u0A29\u0A31\u0A34\u0A37\u0A3A\u0A3B\u0A3D\u0A43-\u0A46\u0A49\u0A4A\u0A4E-\u0A50\u0A52-\u0A58\u0A5D\u0A5F-\u0A65\u0A77-\u0A80\u0A84\u0A8E\u0A92\u0AA9\u0AB1\u0AB4\u0ABA\u0ABB\u0AC6\u0ACA\u0ACE\u0ACF\u0AD1-\u0ADF\u0AE4\u0AE5\u0AF2-\u0AF8\u0B00\u0B04\u0B0D\u0B0E\u0B11\u0B12\u0B29\u0B31\u0B34\u0B3A\u0B3B\u0B45\u0B46\u0B49\u0B4A\u0B4E-\u0B54\u0B58-\u0B5B\u0B5E\u0B64\u0B65\u0B78-\u0B81\u0B84\u0B8B-\u0B8D\u0B91\u0B96-\u0B98\u0B9B\u0B9D\u0BA0-\u0BA2\u0BA5-\u0BA7\u0BAB-\u0BAD\u0BBA-\u0BBD\u0BC3-\u0BC5\u0BC9\u0BCE\u0BCF\u0BD1-\u0BD6\u0BD8-\u0BE5\u0BFB-\u0BFF\u0C0D\u0C11\u0C29\u0C3A-\u0C3C\u0C45\u0C49\u0C4E-\u0C54\u0C57\u0C5B-\u0C5F\u0C64\u0C65\u0C70-\u0C76\u0C8D\u0C91\u0CA9\u0CB4\u0CBA\u0CBB\u0CC5\u0CC9\u0CCE-\u0CD4\u0CD7-\u0CDD\u0CDF\u0CE4\u0CE5\u0CF0\u0CF3-\u0CFF\u0D0D\u0D11\u0D45\u0D49\u0D50-\u0D53\u0D64\u0D65\u0D80\u0D84\u0D97-\u0D99\u0DB2\u0DBC\u0DBE\u0DBF\u0DC7-\u0DC9\u0DCB-\u0DCE\u0DD5\u0DD7\u0DE0-\u0DE5\u0DF0\u0DF1\u0DF5-\u0E00\u0E3B-\u0E3E\u0E5C-\u0E80\u0E83\u0E85\u0E8B\u0EA4\u0EA6\u0EBE\u0EBF\u0EC5\u0EC7\u0ECE\u0ECF\u0EDA\u0EDB\u0EE0-\u0EFF\u0F48\u0F6D-\u0F70\u0F98\u0FBD\u0FCD\u0FDB-\u0FFF\u10C6\u10C8-\u10CC\u10CE\u10CF\u1249\u124E\u124F\u1257\u1259\u125E\u125F\u1289\u128E\u128F\u12B1\u12B6\u12B7\u12BF\u12C1\u12C6\u12C7\u12D7\u1311\u1316\u1317\u135B\u135C\u137D-\u137F\u139A-\u139F\u13F6\u13F7\u13FE\u13FF\u169D-\u169F\u16F9-\u16FF\u170D\u1715-\u171F\u1737-\u173F\u1754-\u175F\u176D\u1771\u1774-\u177F\u17DE\u17DF\u17EA-\u17EF\u17FA-\u17FF\u180E\u180F\u181A-\u181F\u1879-\u187F\u18AB-\u18AF\u18F6-\u18FF\u191F\u192C-\u192F\u193C-\u193F\u1941-\u1943\u196E\u196F\u1975-\u197F\u19AC-\u19AF\u19CA-\u19CF\u19DB-\u19DD\u1A1C\u1A1D\u1A5F\u1A7D\u1A7E\u1A8A-\u1A8F\u1A9A-\u1A9F\u1AAE\u1AAF\u1AC1-\u1AFF\u1B4C-\u1B4F\u1B7D-\u1B7F\u1BF4-\u1BFB\u1C38-\u1C3A\u1C4A-\u1C4C\u1C89-\u1C8F\u1CBB\u1CBC\u1CC8-\u1CCF\u1CFB-\u1CFF\u1DFA\u1F16\u1F17\u1F1E\u1F1F\u1F46\u1F47\u1F4E\u1F4F\u1F58\u1F5A\u1F5C\u1F5E\u1F7E\u1F7F\u1FB5\u1FC5\u1FD4\u1FD5\u1FDC\u1FF0\u1FF1\u1FF5\u1FFF\u200B-\u200F\u202A-\u202E\u2060-\u206F\u2072\u2073\u208F\u209D-\u209F\u20C0-\u20CF\u20F1-\u20FF\u218C-\u218F\u2427-\u243F\u244B-\u245F\u2B74\u2B75\u2B96\u2C2F\u2C5F\u2CF4-\u2CF8\u2D26\u2D28-\u2D2C\u2D2E\u2D2F\u2D68-\u2D6E\u2D71-\u2D7E\u2D97-\u2D9F\u2DA7\u2DAF\u2DB7\u2DBF\u2DC7\u2DCF\u2DD7\u2DDF\u2E53-\u2E7F\u2E9A\u2EF4-\u2EFF\u2FD6-\u2FEF\u2FFC-\u2FFF\u3040\u3097\u3098\u3100-\u3104\u3130\u318F\u31E4-\u31EF\u321F\u9FFD-\u9FFF\uA48D-\uA48F\uA4C7-\uA4CF\uA62C-\uA63F\uA6F8-\uA6FF\uA7C0\uA7C1\uA7CB-\uA7F4\uA82D-\uA82F\uA83A-\uA83F\uA878-\uA87F\uA8C6-\uA8CD\uA8DA-\uA8DF\uA954-\uA95E\uA97D-\uA97F\uA9CE\uA9DA-\uA9DD\uA9FF\uAA37-\uAA3F\uAA4E\uAA4F\uAA5A\uAA5B\uAAC3-\uAADA\uAAF7-\uAB00\uAB07\uAB08\uAB0F\uAB10\uAB17-\uAB1F\uAB27\uAB2F\uAB6C-\uAB6F\uABEE\uABEF\uABFA-\uABFF\uD7A4-\uD7AF\uD7C7-\uD7CA\uD7FC-\uF8FF\uFA6E\uFA6F\uFADA-\uFAFF\uFB07-\uFB12\uFB18-\uFB1C\uFB37\uFB3D\uFB3F\uFB42\uFB45\uFBC2-\uFBD2\uFD40-\uFD4F\uFD90\uFD91\uFDC8-\uFDEF\uFDFE\uFDFF\uFE1A-\uFE1F\uFE53\uFE67\uFE6C-\uFE6F\uFE75\uFEFD-\uFF00\uFFBF-\uFFC1\uFFC8\uFFC9\uFFD0\uFFD1\uFFD8\uFFD9\uFFDD-\uFFDF\uFFE7\uFFEF-\uFFFB\uFFFE\uFFFF',
        'astral': '\uD800[\uDC0C\uDC27\uDC3B\uDC3E\uDC4E\uDC4F\uDC5E-\uDC7F\uDCFB-\uDCFF\uDD03-\uDD06\uDD34-\uDD36\uDD8F\uDD9D-\uDD9F\uDDA1-\uDDCF\uDDFE-\uDE7F\uDE9D-\uDE9F\uDED1-\uDEDF\uDEFC-\uDEFF\uDF24-\uDF2C\uDF4B-\uDF4F\uDF7B-\uDF7F\uDF9E\uDFC4-\uDFC7\uDFD6-\uDFFF]|\uD801[\uDC9E\uDC9F\uDCAA-\uDCAF\uDCD4-\uDCD7\uDCFC-\uDCFF\uDD28-\uDD2F\uDD64-\uDD6E\uDD70-\uDDFF\uDF37-\uDF3F\uDF56-\uDF5F\uDF68-\uDFFF]|\uD802[\uDC06\uDC07\uDC09\uDC36\uDC39-\uDC3B\uDC3D\uDC3E\uDC56\uDC9F-\uDCA6\uDCB0-\uDCDF\uDCF3\uDCF6-\uDCFA\uDD1C-\uDD1E\uDD3A-\uDD3E\uDD40-\uDD7F\uDDB8-\uDDBB\uDDD0\uDDD1\uDE04\uDE07-\uDE0B\uDE14\uDE18\uDE36\uDE37\uDE3B-\uDE3E\uDE49-\uDE4F\uDE59-\uDE5F\uDEA0-\uDEBF\uDEE7-\uDEEA\uDEF7-\uDEFF\uDF36-\uDF38\uDF56\uDF57\uDF73-\uDF77\uDF92-\uDF98\uDF9D-\uDFA8\uDFB0-\uDFFF]|\uD803[\uDC49-\uDC7F\uDCB3-\uDCBF\uDCF3-\uDCF9\uDD28-\uDD2F\uDD3A-\uDE5F\uDE7F\uDEAA\uDEAE\uDEAF\uDEB2-\uDEFF\uDF28-\uDF2F\uDF5A-\uDFAF\uDFCC-\uDFDF\uDFF7-\uDFFF]|\uD804[\uDC4E-\uDC51\uDC70-\uDC7E\uDCBD\uDCC2-\uDCCF\uDCE9-\uDCEF\uDCFA-\uDCFF\uDD35\uDD48-\uDD4F\uDD77-\uDD7F\uDDE0\uDDF5-\uDDFF\uDE12\uDE3F-\uDE7F\uDE87\uDE89\uDE8E\uDE9E\uDEAA-\uDEAF\uDEEB-\uDEEF\uDEFA-\uDEFF\uDF04\uDF0D\uDF0E\uDF11\uDF12\uDF29\uDF31\uDF34\uDF3A\uDF45\uDF46\uDF49\uDF4A\uDF4E\uDF4F\uDF51-\uDF56\uDF58-\uDF5C\uDF64\uDF65\uDF6D-\uDF6F\uDF75-\uDFFF]|\uD805[\uDC5C\uDC62-\uDC7F\uDCC8-\uDCCF\uDCDA-\uDD7F\uDDB6\uDDB7\uDDDE-\uDDFF\uDE45-\uDE4F\uDE5A-\uDE5F\uDE6D-\uDE7F\uDEB9-\uDEBF\uDECA-\uDEFF\uDF1B\uDF1C\uDF2C-\uDF2F\uDF40-\uDFFF]|\uD806[\uDC3C-\uDC9F\uDCF3-\uDCFE\uDD07\uDD08\uDD0A\uDD0B\uDD14\uDD17\uDD36\uDD39\uDD3A\uDD47-\uDD4F\uDD5A-\uDD9F\uDDA8\uDDA9\uDDD8\uDDD9\uDDE5-\uDDFF\uDE48-\uDE4F\uDEA3-\uDEBF\uDEF9-\uDFFF]|\uD807[\uDC09\uDC37\uDC46-\uDC4F\uDC6D-\uDC6F\uDC90\uDC91\uDCA8\uDCB7-\uDCFF\uDD07\uDD0A\uDD37-\uDD39\uDD3B\uDD3E\uDD48-\uDD4F\uDD5A-\uDD5F\uDD66\uDD69\uDD8F\uDD92\uDD99-\uDD9F\uDDAA-\uDEDF\uDEF9-\uDFAF\uDFB1-\uDFBF\uDFF2-\uDFFE]|\uD808[\uDF9A-\uDFFF]|\uD809[\uDC6F\uDC75-\uDC7F\uDD44-\uDFFF]|[\uD80A\uD80B\uD80E-\uD810\uD812-\uD819\uD824-\uD82B\uD82D\uD82E\uD830-\uD833\uD837\uD839\uD83F\uD87B-\uD87D\uD87F\uD885-\uDB3F\uDB41-\uDBFF][\uDC00-\uDFFF]|\uD80D[\uDC2F-\uDFFF]|\uD811[\uDE47-\uDFFF]|\uD81A[\uDE39-\uDE3F\uDE5F\uDE6A-\uDE6D\uDE70-\uDECF\uDEEE\uDEEF\uDEF6-\uDEFF\uDF46-\uDF4F\uDF5A\uDF62\uDF78-\uDF7C\uDF90-\uDFFF]|\uD81B[\uDC00-\uDE3F\uDE9B-\uDEFF\uDF4B-\uDF4E\uDF88-\uDF8E\uDFA0-\uDFDF\uDFE5-\uDFEF\uDFF2-\uDFFF]|\uD821[\uDFF8-\uDFFF]|\uD823[\uDCD6-\uDCFF\uDD09-\uDFFF]|\uD82C[\uDD1F-\uDD4F\uDD53-\uDD63\uDD68-\uDD6F\uDEFC-\uDFFF]|\uD82F[\uDC6B-\uDC6F\uDC7D-\uDC7F\uDC89-\uDC8F\uDC9A\uDC9B\uDCA0-\uDFFF]|\uD834[\uDCF6-\uDCFF\uDD27\uDD28\uDD73-\uDD7A\uDDE9-\uDDFF\uDE46-\uDEDF\uDEF4-\uDEFF\uDF57-\uDF5F\uDF79-\uDFFF]|\uD835[\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDFCC\uDFCD]|\uD836[\uDE8C-\uDE9A\uDEA0\uDEB0-\uDFFF]|\uD838[\uDC07\uDC19\uDC1A\uDC22\uDC25\uDC2B-\uDCFF\uDD2D-\uDD2F\uDD3E\uDD3F\uDD4A-\uDD4D\uDD50-\uDEBF\uDEFA-\uDEFE\uDF00-\uDFFF]|\uD83A[\uDCC5\uDCC6\uDCD7-\uDCFF\uDD4C-\uDD4F\uDD5A-\uDD5D\uDD60-\uDFFF]|\uD83B[\uDC00-\uDC70\uDCB5-\uDD00\uDD3E-\uDDFF\uDE04\uDE20\uDE23\uDE25\uDE26\uDE28\uDE33\uDE38\uDE3A\uDE3C-\uDE41\uDE43-\uDE46\uDE48\uDE4A\uDE4C\uDE50\uDE53\uDE55\uDE56\uDE58\uDE5A\uDE5C\uDE5E\uDE60\uDE63\uDE65\uDE66\uDE6B\uDE73\uDE78\uDE7D\uDE7F\uDE8A\uDE9C-\uDEA0\uDEA4\uDEAA\uDEBC-\uDEEF\uDEF2-\uDFFF]|\uD83C[\uDC2C-\uDC2F\uDC94-\uDC9F\uDCAF\uDCB0\uDCC0\uDCD0\uDCF6-\uDCFF\uDDAE-\uDDE5\uDE03-\uDE0F\uDE3C-\uDE3F\uDE49-\uDE4F\uDE52-\uDE5F\uDE66-\uDEFF]|\uD83D[\uDED8-\uDEDF\uDEED-\uDEEF\uDEFD-\uDEFF\uDF74-\uDF7F\uDFD9-\uDFDF\uDFEC-\uDFFF]|\uD83E[\uDC0C-\uDC0F\uDC48-\uDC4F\uDC5A-\uDC5F\uDC88-\uDC8F\uDCAE\uDCAF\uDCB2-\uDCFF\uDD79\uDDCC\uDE54-\uDE5F\uDE6E\uDE6F\uDE75-\uDE77\uDE7B-\uDE7F\uDE87-\uDE8F\uDEA9-\uDEAF\uDEB7-\uDEBF\uDEC3-\uDECF\uDED7-\uDEFF\uDF93\uDFCB-\uDFEF\uDFFA-\uDFFF]|\uD869[\uDEDE-\uDEFF]|\uD86D[\uDF35-\uDF3F]|\uD86E[\uDC1E\uDC1F]|\uD873[\uDEA2-\uDEAF]|\uD87A[\uDFE1-\uDFFF]|\uD87E[\uDE1E-\uDFFF]|\uD884[\uDF4B-\uDFFF]|\uDB40[\uDC00-\uDCFF\uDDF0-\uDFFF]'
    },
    {
        'name': 'Cc',
        'alias': 'Control',
        'bmp': '\0-\x1F\x7F-\x9F'
    },
    {
        'name': 'Cf',
        'alias': 'Format',
        'bmp': '\xAD\u0600-\u0605\u061C\u06DD\u070F\u08E2\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF\uFFF9-\uFFFB',
        'astral': '\uD804[\uDCBD\uDCCD]|\uD80D[\uDC30-\uDC38]|\uD82F[\uDCA0-\uDCA3]|\uD834[\uDD73-\uDD7A]|\uDB40[\uDC01\uDC20-\uDC7F]'
    },
    {
        'name': 'Cn',
        'alias': 'Unassigned',
        'bmp': '\u0378\u0379\u0380-\u0383\u038B\u038D\u03A2\u0530\u0557\u0558\u058B\u058C\u0590\u05C8-\u05CF\u05EB-\u05EE\u05F5-\u05FF\u061D\u070E\u074B\u074C\u07B2-\u07BF\u07FB\u07FC\u082E\u082F\u083F\u085C\u085D\u085F\u086B-\u089F\u08B5\u08C8-\u08D2\u0984\u098D\u098E\u0991\u0992\u09A9\u09B1\u09B3-\u09B5\u09BA\u09BB\u09C5\u09C6\u09C9\u09CA\u09CF-\u09D6\u09D8-\u09DB\u09DE\u09E4\u09E5\u09FF\u0A00\u0A04\u0A0B-\u0A0E\u0A11\u0A12\u0A29\u0A31\u0A34\u0A37\u0A3A\u0A3B\u0A3D\u0A43-\u0A46\u0A49\u0A4A\u0A4E-\u0A50\u0A52-\u0A58\u0A5D\u0A5F-\u0A65\u0A77-\u0A80\u0A84\u0A8E\u0A92\u0AA9\u0AB1\u0AB4\u0ABA\u0ABB\u0AC6\u0ACA\u0ACE\u0ACF\u0AD1-\u0ADF\u0AE4\u0AE5\u0AF2-\u0AF8\u0B00\u0B04\u0B0D\u0B0E\u0B11\u0B12\u0B29\u0B31\u0B34\u0B3A\u0B3B\u0B45\u0B46\u0B49\u0B4A\u0B4E-\u0B54\u0B58-\u0B5B\u0B5E\u0B64\u0B65\u0B78-\u0B81\u0B84\u0B8B-\u0B8D\u0B91\u0B96-\u0B98\u0B9B\u0B9D\u0BA0-\u0BA2\u0BA5-\u0BA7\u0BAB-\u0BAD\u0BBA-\u0BBD\u0BC3-\u0BC5\u0BC9\u0BCE\u0BCF\u0BD1-\u0BD6\u0BD8-\u0BE5\u0BFB-\u0BFF\u0C0D\u0C11\u0C29\u0C3A-\u0C3C\u0C45\u0C49\u0C4E-\u0C54\u0C57\u0C5B-\u0C5F\u0C64\u0C65\u0C70-\u0C76\u0C8D\u0C91\u0CA9\u0CB4\u0CBA\u0CBB\u0CC5\u0CC9\u0CCE-\u0CD4\u0CD7-\u0CDD\u0CDF\u0CE4\u0CE5\u0CF0\u0CF3-\u0CFF\u0D0D\u0D11\u0D45\u0D49\u0D50-\u0D53\u0D64\u0D65\u0D80\u0D84\u0D97-\u0D99\u0DB2\u0DBC\u0DBE\u0DBF\u0DC7-\u0DC9\u0DCB-\u0DCE\u0DD5\u0DD7\u0DE0-\u0DE5\u0DF0\u0DF1\u0DF5-\u0E00\u0E3B-\u0E3E\u0E5C-\u0E80\u0E83\u0E85\u0E8B\u0EA4\u0EA6\u0EBE\u0EBF\u0EC5\u0EC7\u0ECE\u0ECF\u0EDA\u0EDB\u0EE0-\u0EFF\u0F48\u0F6D-\u0F70\u0F98\u0FBD\u0FCD\u0FDB-\u0FFF\u10C6\u10C8-\u10CC\u10CE\u10CF\u1249\u124E\u124F\u1257\u1259\u125E\u125F\u1289\u128E\u128F\u12B1\u12B6\u12B7\u12BF\u12C1\u12C6\u12C7\u12D7\u1311\u1316\u1317\u135B\u135C\u137D-\u137F\u139A-\u139F\u13F6\u13F7\u13FE\u13FF\u169D-\u169F\u16F9-\u16FF\u170D\u1715-\u171F\u1737-\u173F\u1754-\u175F\u176D\u1771\u1774-\u177F\u17DE\u17DF\u17EA-\u17EF\u17FA-\u17FF\u180F\u181A-\u181F\u1879-\u187F\u18AB-\u18AF\u18F6-\u18FF\u191F\u192C-\u192F\u193C-\u193F\u1941-\u1943\u196E\u196F\u1975-\u197F\u19AC-\u19AF\u19CA-\u19CF\u19DB-\u19DD\u1A1C\u1A1D\u1A5F\u1A7D\u1A7E\u1A8A-\u1A8F\u1A9A-\u1A9F\u1AAE\u1AAF\u1AC1-\u1AFF\u1B4C-\u1B4F\u1B7D-\u1B7F\u1BF4-\u1BFB\u1C38-\u1C3A\u1C4A-\u1C4C\u1C89-\u1C8F\u1CBB\u1CBC\u1CC8-\u1CCF\u1CFB-\u1CFF\u1DFA\u1F16\u1F17\u1F1E\u1F1F\u1F46\u1F47\u1F4E\u1F4F\u1F58\u1F5A\u1F5C\u1F5E\u1F7E\u1F7F\u1FB5\u1FC5\u1FD4\u1FD5\u1FDC\u1FF0\u1FF1\u1FF5\u1FFF\u2065\u2072\u2073\u208F\u209D-\u209F\u20C0-\u20CF\u20F1-\u20FF\u218C-\u218F\u2427-\u243F\u244B-\u245F\u2B74\u2B75\u2B96\u2C2F\u2C5F\u2CF4-\u2CF8\u2D26\u2D28-\u2D2C\u2D2E\u2D2F\u2D68-\u2D6E\u2D71-\u2D7E\u2D97-\u2D9F\u2DA7\u2DAF\u2DB7\u2DBF\u2DC7\u2DCF\u2DD7\u2DDF\u2E53-\u2E7F\u2E9A\u2EF4-\u2EFF\u2FD6-\u2FEF\u2FFC-\u2FFF\u3040\u3097\u3098\u3100-\u3104\u3130\u318F\u31E4-\u31EF\u321F\u9FFD-\u9FFF\uA48D-\uA48F\uA4C7-\uA4CF\uA62C-\uA63F\uA6F8-\uA6FF\uA7C0\uA7C1\uA7CB-\uA7F4\uA82D-\uA82F\uA83A-\uA83F\uA878-\uA87F\uA8C6-\uA8CD\uA8DA-\uA8DF\uA954-\uA95E\uA97D-\uA97F\uA9CE\uA9DA-\uA9DD\uA9FF\uAA37-\uAA3F\uAA4E\uAA4F\uAA5A\uAA5B\uAAC3-\uAADA\uAAF7-\uAB00\uAB07\uAB08\uAB0F\uAB10\uAB17-\uAB1F\uAB27\uAB2F\uAB6C-\uAB6F\uABEE\uABEF\uABFA-\uABFF\uD7A4-\uD7AF\uD7C7-\uD7CA\uD7FC-\uD7FF\uFA6E\uFA6F\uFADA-\uFAFF\uFB07-\uFB12\uFB18-\uFB1C\uFB37\uFB3D\uFB3F\uFB42\uFB45\uFBC2-\uFBD2\uFD40-\uFD4F\uFD90\uFD91\uFDC8-\uFDEF\uFDFE\uFDFF\uFE1A-\uFE1F\uFE53\uFE67\uFE6C-\uFE6F\uFE75\uFEFD\uFEFE\uFF00\uFFBF-\uFFC1\uFFC8\uFFC9\uFFD0\uFFD1\uFFD8\uFFD9\uFFDD-\uFFDF\uFFE7\uFFEF-\uFFF8\uFFFE\uFFFF',
        'astral': '\uD800[\uDC0C\uDC27\uDC3B\uDC3E\uDC4E\uDC4F\uDC5E-\uDC7F\uDCFB-\uDCFF\uDD03-\uDD06\uDD34-\uDD36\uDD8F\uDD9D-\uDD9F\uDDA1-\uDDCF\uDDFE-\uDE7F\uDE9D-\uDE9F\uDED1-\uDEDF\uDEFC-\uDEFF\uDF24-\uDF2C\uDF4B-\uDF4F\uDF7B-\uDF7F\uDF9E\uDFC4-\uDFC7\uDFD6-\uDFFF]|\uD801[\uDC9E\uDC9F\uDCAA-\uDCAF\uDCD4-\uDCD7\uDCFC-\uDCFF\uDD28-\uDD2F\uDD64-\uDD6E\uDD70-\uDDFF\uDF37-\uDF3F\uDF56-\uDF5F\uDF68-\uDFFF]|\uD802[\uDC06\uDC07\uDC09\uDC36\uDC39-\uDC3B\uDC3D\uDC3E\uDC56\uDC9F-\uDCA6\uDCB0-\uDCDF\uDCF3\uDCF6-\uDCFA\uDD1C-\uDD1E\uDD3A-\uDD3E\uDD40-\uDD7F\uDDB8-\uDDBB\uDDD0\uDDD1\uDE04\uDE07-\uDE0B\uDE14\uDE18\uDE36\uDE37\uDE3B-\uDE3E\uDE49-\uDE4F\uDE59-\uDE5F\uDEA0-\uDEBF\uDEE7-\uDEEA\uDEF7-\uDEFF\uDF36-\uDF38\uDF56\uDF57\uDF73-\uDF77\uDF92-\uDF98\uDF9D-\uDFA8\uDFB0-\uDFFF]|\uD803[\uDC49-\uDC7F\uDCB3-\uDCBF\uDCF3-\uDCF9\uDD28-\uDD2F\uDD3A-\uDE5F\uDE7F\uDEAA\uDEAE\uDEAF\uDEB2-\uDEFF\uDF28-\uDF2F\uDF5A-\uDFAF\uDFCC-\uDFDF\uDFF7-\uDFFF]|\uD804[\uDC4E-\uDC51\uDC70-\uDC7E\uDCC2-\uDCCC\uDCCE\uDCCF\uDCE9-\uDCEF\uDCFA-\uDCFF\uDD35\uDD48-\uDD4F\uDD77-\uDD7F\uDDE0\uDDF5-\uDDFF\uDE12\uDE3F-\uDE7F\uDE87\uDE89\uDE8E\uDE9E\uDEAA-\uDEAF\uDEEB-\uDEEF\uDEFA-\uDEFF\uDF04\uDF0D\uDF0E\uDF11\uDF12\uDF29\uDF31\uDF34\uDF3A\uDF45\uDF46\uDF49\uDF4A\uDF4E\uDF4F\uDF51-\uDF56\uDF58-\uDF5C\uDF64\uDF65\uDF6D-\uDF6F\uDF75-\uDFFF]|\uD805[\uDC5C\uDC62-\uDC7F\uDCC8-\uDCCF\uDCDA-\uDD7F\uDDB6\uDDB7\uDDDE-\uDDFF\uDE45-\uDE4F\uDE5A-\uDE5F\uDE6D-\uDE7F\uDEB9-\uDEBF\uDECA-\uDEFF\uDF1B\uDF1C\uDF2C-\uDF2F\uDF40-\uDFFF]|\uD806[\uDC3C-\uDC9F\uDCF3-\uDCFE\uDD07\uDD08\uDD0A\uDD0B\uDD14\uDD17\uDD36\uDD39\uDD3A\uDD47-\uDD4F\uDD5A-\uDD9F\uDDA8\uDDA9\uDDD8\uDDD9\uDDE5-\uDDFF\uDE48-\uDE4F\uDEA3-\uDEBF\uDEF9-\uDFFF]|\uD807[\uDC09\uDC37\uDC46-\uDC4F\uDC6D-\uDC6F\uDC90\uDC91\uDCA8\uDCB7-\uDCFF\uDD07\uDD0A\uDD37-\uDD39\uDD3B\uDD3E\uDD48-\uDD4F\uDD5A-\uDD5F\uDD66\uDD69\uDD8F\uDD92\uDD99-\uDD9F\uDDAA-\uDEDF\uDEF9-\uDFAF\uDFB1-\uDFBF\uDFF2-\uDFFE]|\uD808[\uDF9A-\uDFFF]|\uD809[\uDC6F\uDC75-\uDC7F\uDD44-\uDFFF]|[\uD80A\uD80B\uD80E-\uD810\uD812-\uD819\uD824-\uD82B\uD82D\uD82E\uD830-\uD833\uD837\uD839\uD83F\uD87B-\uD87D\uD87F\uD885-\uDB3F\uDB41-\uDB7F][\uDC00-\uDFFF]|\uD80D[\uDC2F\uDC39-\uDFFF]|\uD811[\uDE47-\uDFFF]|\uD81A[\uDE39-\uDE3F\uDE5F\uDE6A-\uDE6D\uDE70-\uDECF\uDEEE\uDEEF\uDEF6-\uDEFF\uDF46-\uDF4F\uDF5A\uDF62\uDF78-\uDF7C\uDF90-\uDFFF]|\uD81B[\uDC00-\uDE3F\uDE9B-\uDEFF\uDF4B-\uDF4E\uDF88-\uDF8E\uDFA0-\uDFDF\uDFE5-\uDFEF\uDFF2-\uDFFF]|\uD821[\uDFF8-\uDFFF]|\uD823[\uDCD6-\uDCFF\uDD09-\uDFFF]|\uD82C[\uDD1F-\uDD4F\uDD53-\uDD63\uDD68-\uDD6F\uDEFC-\uDFFF]|\uD82F[\uDC6B-\uDC6F\uDC7D-\uDC7F\uDC89-\uDC8F\uDC9A\uDC9B\uDCA4-\uDFFF]|\uD834[\uDCF6-\uDCFF\uDD27\uDD28\uDDE9-\uDDFF\uDE46-\uDEDF\uDEF4-\uDEFF\uDF57-\uDF5F\uDF79-\uDFFF]|\uD835[\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDFCC\uDFCD]|\uD836[\uDE8C-\uDE9A\uDEA0\uDEB0-\uDFFF]|\uD838[\uDC07\uDC19\uDC1A\uDC22\uDC25\uDC2B-\uDCFF\uDD2D-\uDD2F\uDD3E\uDD3F\uDD4A-\uDD4D\uDD50-\uDEBF\uDEFA-\uDEFE\uDF00-\uDFFF]|\uD83A[\uDCC5\uDCC6\uDCD7-\uDCFF\uDD4C-\uDD4F\uDD5A-\uDD5D\uDD60-\uDFFF]|\uD83B[\uDC00-\uDC70\uDCB5-\uDD00\uDD3E-\uDDFF\uDE04\uDE20\uDE23\uDE25\uDE26\uDE28\uDE33\uDE38\uDE3A\uDE3C-\uDE41\uDE43-\uDE46\uDE48\uDE4A\uDE4C\uDE50\uDE53\uDE55\uDE56\uDE58\uDE5A\uDE5C\uDE5E\uDE60\uDE63\uDE65\uDE66\uDE6B\uDE73\uDE78\uDE7D\uDE7F\uDE8A\uDE9C-\uDEA0\uDEA4\uDEAA\uDEBC-\uDEEF\uDEF2-\uDFFF]|\uD83C[\uDC2C-\uDC2F\uDC94-\uDC9F\uDCAF\uDCB0\uDCC0\uDCD0\uDCF6-\uDCFF\uDDAE-\uDDE5\uDE03-\uDE0F\uDE3C-\uDE3F\uDE49-\uDE4F\uDE52-\uDE5F\uDE66-\uDEFF]|\uD83D[\uDED8-\uDEDF\uDEED-\uDEEF\uDEFD-\uDEFF\uDF74-\uDF7F\uDFD9-\uDFDF\uDFEC-\uDFFF]|\uD83E[\uDC0C-\uDC0F\uDC48-\uDC4F\uDC5A-\uDC5F\uDC88-\uDC8F\uDCAE\uDCAF\uDCB2-\uDCFF\uDD79\uDDCC\uDE54-\uDE5F\uDE6E\uDE6F\uDE75-\uDE77\uDE7B-\uDE7F\uDE87-\uDE8F\uDEA9-\uDEAF\uDEB7-\uDEBF\uDEC3-\uDECF\uDED7-\uDEFF\uDF93\uDFCB-\uDFEF\uDFFA-\uDFFF]|\uD869[\uDEDE-\uDEFF]|\uD86D[\uDF35-\uDF3F]|\uD86E[\uDC1E\uDC1F]|\uD873[\uDEA2-\uDEAF]|\uD87A[\uDFE1-\uDFFF]|\uD87E[\uDE1E-\uDFFF]|\uD884[\uDF4B-\uDFFF]|\uDB40[\uDC00\uDC02-\uDC1F\uDC80-\uDCFF\uDDF0-\uDFFF]|[\uDBBF\uDBFF][\uDFFE\uDFFF]'
    },
    {
        'name': 'Co',
        'alias': 'Private_Use',
        'bmp': '\uE000-\uF8FF',
        'astral': '[\uDB80-\uDBBE\uDBC0-\uDBFE][\uDC00-\uDFFF]|[\uDBBF\uDBFF][\uDC00-\uDFFD]'
    },
    {
        'name': 'Cs',
        'alias': 'Surrogate',
        'bmp': '\uD800-\uDFFF'
    },
    {
        'name': 'L',
        'alias': 'Letter',
        'bmp': 'A-Za-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08C7\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\u9FFC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA7BF\uA7C2-\uA7CA\uA7F5-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC',
        'astral': '\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF40\uDF42-\uDF49\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDD00-\uDD23\uDE80-\uDEA9\uDEB0\uDEB1\uDF00-\uDF1C\uDF27\uDF30-\uDF45\uDFB0-\uDFC4\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDEB8\uDF00-\uDF1A]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCDF\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDEE0-\uDEF2\uDFB0]|\uD808[\uDC00-\uDF99]|\uD809[\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE7F\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82C[\uDC00-\uDD1E\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD838[\uDD00-\uDD2C\uDD37-\uDD3D\uDD4E\uDEC0-\uDEEB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43\uDD4B]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDEDD\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A]'
    },
    {
        'name': 'LC',
        'alias': 'Cased_Letter',
        'bmp': 'A-Za-z\xB5\xC0-\xD6\xD8-\xF6\xF8-\u01BA\u01BC-\u01BF\u01C4-\u0293\u0295-\u02AF\u0370-\u0373\u0376\u0377\u037B-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0560-\u0588\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FD-\u10FF\u13A0-\u13F5\u13F8-\u13FD\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1D00-\u1D2B\u1D6B-\u1D77\u1D79-\u1D9A\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2134\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2C7B\u2C7E-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\uA640-\uA66D\uA680-\uA69B\uA722-\uA76F\uA771-\uA787\uA78B-\uA78E\uA790-\uA7BF\uA7C2-\uA7CA\uA7F5\uA7F6\uA7FA\uAB30-\uAB5A\uAB60-\uAB68\uAB70-\uABBF\uFB00-\uFB06\uFB13-\uFB17\uFF21-\uFF3A\uFF41-\uFF5A',
        'astral': '\uD801[\uDC00-\uDC4F\uDCB0-\uDCD3\uDCD8-\uDCFB]|\uD803[\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD806[\uDCA0-\uDCDF]|\uD81B[\uDE40-\uDE7F]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDD00-\uDD43]'
    },
    {
        'name': 'Ll',
        'alias': 'Lowercase_Letter',
        'bmp': 'a-z\xB5\xDF-\xF6\xF8-\xFF\u0101\u0103\u0105\u0107\u0109\u010B\u010D\u010F\u0111\u0113\u0115\u0117\u0119\u011B\u011D\u011F\u0121\u0123\u0125\u0127\u0129\u012B\u012D\u012F\u0131\u0133\u0135\u0137\u0138\u013A\u013C\u013E\u0140\u0142\u0144\u0146\u0148\u0149\u014B\u014D\u014F\u0151\u0153\u0155\u0157\u0159\u015B\u015D\u015F\u0161\u0163\u0165\u0167\u0169\u016B\u016D\u016F\u0171\u0173\u0175\u0177\u017A\u017C\u017E-\u0180\u0183\u0185\u0188\u018C\u018D\u0192\u0195\u0199-\u019B\u019E\u01A1\u01A3\u01A5\u01A8\u01AA\u01AB\u01AD\u01B0\u01B4\u01B6\u01B9\u01BA\u01BD-\u01BF\u01C6\u01C9\u01CC\u01CE\u01D0\u01D2\u01D4\u01D6\u01D8\u01DA\u01DC\u01DD\u01DF\u01E1\u01E3\u01E5\u01E7\u01E9\u01EB\u01ED\u01EF\u01F0\u01F3\u01F5\u01F9\u01FB\u01FD\u01FF\u0201\u0203\u0205\u0207\u0209\u020B\u020D\u020F\u0211\u0213\u0215\u0217\u0219\u021B\u021D\u021F\u0221\u0223\u0225\u0227\u0229\u022B\u022D\u022F\u0231\u0233-\u0239\u023C\u023F\u0240\u0242\u0247\u0249\u024B\u024D\u024F-\u0293\u0295-\u02AF\u0371\u0373\u0377\u037B-\u037D\u0390\u03AC-\u03CE\u03D0\u03D1\u03D5-\u03D7\u03D9\u03DB\u03DD\u03DF\u03E1\u03E3\u03E5\u03E7\u03E9\u03EB\u03ED\u03EF-\u03F3\u03F5\u03F8\u03FB\u03FC\u0430-\u045F\u0461\u0463\u0465\u0467\u0469\u046B\u046D\u046F\u0471\u0473\u0475\u0477\u0479\u047B\u047D\u047F\u0481\u048B\u048D\u048F\u0491\u0493\u0495\u0497\u0499\u049B\u049D\u049F\u04A1\u04A3\u04A5\u04A7\u04A9\u04AB\u04AD\u04AF\u04B1\u04B3\u04B5\u04B7\u04B9\u04BB\u04BD\u04BF\u04C2\u04C4\u04C6\u04C8\u04CA\u04CC\u04CE\u04CF\u04D1\u04D3\u04D5\u04D7\u04D9\u04DB\u04DD\u04DF\u04E1\u04E3\u04E5\u04E7\u04E9\u04EB\u04ED\u04EF\u04F1\u04F3\u04F5\u04F7\u04F9\u04FB\u04FD\u04FF\u0501\u0503\u0505\u0507\u0509\u050B\u050D\u050F\u0511\u0513\u0515\u0517\u0519\u051B\u051D\u051F\u0521\u0523\u0525\u0527\u0529\u052B\u052D\u052F\u0560-\u0588\u10D0-\u10FA\u10FD-\u10FF\u13F8-\u13FD\u1C80-\u1C88\u1D00-\u1D2B\u1D6B-\u1D77\u1D79-\u1D9A\u1E01\u1E03\u1E05\u1E07\u1E09\u1E0B\u1E0D\u1E0F\u1E11\u1E13\u1E15\u1E17\u1E19\u1E1B\u1E1D\u1E1F\u1E21\u1E23\u1E25\u1E27\u1E29\u1E2B\u1E2D\u1E2F\u1E31\u1E33\u1E35\u1E37\u1E39\u1E3B\u1E3D\u1E3F\u1E41\u1E43\u1E45\u1E47\u1E49\u1E4B\u1E4D\u1E4F\u1E51\u1E53\u1E55\u1E57\u1E59\u1E5B\u1E5D\u1E5F\u1E61\u1E63\u1E65\u1E67\u1E69\u1E6B\u1E6D\u1E6F\u1E71\u1E73\u1E75\u1E77\u1E79\u1E7B\u1E7D\u1E7F\u1E81\u1E83\u1E85\u1E87\u1E89\u1E8B\u1E8D\u1E8F\u1E91\u1E93\u1E95-\u1E9D\u1E9F\u1EA1\u1EA3\u1EA5\u1EA7\u1EA9\u1EAB\u1EAD\u1EAF\u1EB1\u1EB3\u1EB5\u1EB7\u1EB9\u1EBB\u1EBD\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7\u1EC9\u1ECB\u1ECD\u1ECF\u1ED1\u1ED3\u1ED5\u1ED7\u1ED9\u1EDB\u1EDD\u1EDF\u1EE1\u1EE3\u1EE5\u1EE7\u1EE9\u1EEB\u1EED\u1EEF\u1EF1\u1EF3\u1EF5\u1EF7\u1EF9\u1EFB\u1EFD\u1EFF-\u1F07\u1F10-\u1F15\u1F20-\u1F27\u1F30-\u1F37\u1F40-\u1F45\u1F50-\u1F57\u1F60-\u1F67\u1F70-\u1F7D\u1F80-\u1F87\u1F90-\u1F97\u1FA0-\u1FA7\u1FB0-\u1FB4\u1FB6\u1FB7\u1FBE\u1FC2-\u1FC4\u1FC6\u1FC7\u1FD0-\u1FD3\u1FD6\u1FD7\u1FE0-\u1FE7\u1FF2-\u1FF4\u1FF6\u1FF7\u210A\u210E\u210F\u2113\u212F\u2134\u2139\u213C\u213D\u2146-\u2149\u214E\u2184\u2C30-\u2C5E\u2C61\u2C65\u2C66\u2C68\u2C6A\u2C6C\u2C71\u2C73\u2C74\u2C76-\u2C7B\u2C81\u2C83\u2C85\u2C87\u2C89\u2C8B\u2C8D\u2C8F\u2C91\u2C93\u2C95\u2C97\u2C99\u2C9B\u2C9D\u2C9F\u2CA1\u2CA3\u2CA5\u2CA7\u2CA9\u2CAB\u2CAD\u2CAF\u2CB1\u2CB3\u2CB5\u2CB7\u2CB9\u2CBB\u2CBD\u2CBF\u2CC1\u2CC3\u2CC5\u2CC7\u2CC9\u2CCB\u2CCD\u2CCF\u2CD1\u2CD3\u2CD5\u2CD7\u2CD9\u2CDB\u2CDD\u2CDF\u2CE1\u2CE3\u2CE4\u2CEC\u2CEE\u2CF3\u2D00-\u2D25\u2D27\u2D2D\uA641\uA643\uA645\uA647\uA649\uA64B\uA64D\uA64F\uA651\uA653\uA655\uA657\uA659\uA65B\uA65D\uA65F\uA661\uA663\uA665\uA667\uA669\uA66B\uA66D\uA681\uA683\uA685\uA687\uA689\uA68B\uA68D\uA68F\uA691\uA693\uA695\uA697\uA699\uA69B\uA723\uA725\uA727\uA729\uA72B\uA72D\uA72F-\uA731\uA733\uA735\uA737\uA739\uA73B\uA73D\uA73F\uA741\uA743\uA745\uA747\uA749\uA74B\uA74D\uA74F\uA751\uA753\uA755\uA757\uA759\uA75B\uA75D\uA75F\uA761\uA763\uA765\uA767\uA769\uA76B\uA76D\uA76F\uA771-\uA778\uA77A\uA77C\uA77F\uA781\uA783\uA785\uA787\uA78C\uA78E\uA791\uA793-\uA795\uA797\uA799\uA79B\uA79D\uA79F\uA7A1\uA7A3\uA7A5\uA7A7\uA7A9\uA7AF\uA7B5\uA7B7\uA7B9\uA7BB\uA7BD\uA7BF\uA7C3\uA7C8\uA7CA\uA7F6\uA7FA\uAB30-\uAB5A\uAB60-\uAB68\uAB70-\uABBF\uFB00-\uFB06\uFB13-\uFB17\uFF41-\uFF5A',
        'astral': '\uD801[\uDC28-\uDC4F\uDCD8-\uDCFB]|\uD803[\uDCC0-\uDCF2]|\uD806[\uDCC0-\uDCDF]|\uD81B[\uDE60-\uDE7F]|\uD835[\uDC1A-\uDC33\uDC4E-\uDC54\uDC56-\uDC67\uDC82-\uDC9B\uDCB6-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDCEA-\uDD03\uDD1E-\uDD37\uDD52-\uDD6B\uDD86-\uDD9F\uDDBA-\uDDD3\uDDEE-\uDE07\uDE22-\uDE3B\uDE56-\uDE6F\uDE8A-\uDEA5\uDEC2-\uDEDA\uDEDC-\uDEE1\uDEFC-\uDF14\uDF16-\uDF1B\uDF36-\uDF4E\uDF50-\uDF55\uDF70-\uDF88\uDF8A-\uDF8F\uDFAA-\uDFC2\uDFC4-\uDFC9\uDFCB]|\uD83A[\uDD22-\uDD43]'
    },
    {
        'name': 'Lm',
        'alias': 'Modifier_Letter',
        'bmp': '\u02B0-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0374\u037A\u0559\u0640\u06E5\u06E6\u07F4\u07F5\u07FA\u081A\u0824\u0828\u0971\u0E46\u0EC6\u10FC\u17D7\u1843\u1AA7\u1C78-\u1C7D\u1D2C-\u1D6A\u1D78\u1D9B-\u1DBF\u2071\u207F\u2090-\u209C\u2C7C\u2C7D\u2D6F\u2E2F\u3005\u3031-\u3035\u303B\u309D\u309E\u30FC-\u30FE\uA015\uA4F8-\uA4FD\uA60C\uA67F\uA69C\uA69D\uA717-\uA71F\uA770\uA788\uA7F8\uA7F9\uA9CF\uA9E6\uAA70\uAADD\uAAF3\uAAF4\uAB5C-\uAB5F\uAB69\uFF70\uFF9E\uFF9F',
        'astral': '\uD81A[\uDF40-\uDF43]|\uD81B[\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3]|\uD838[\uDD37-\uDD3D]|\uD83A\uDD4B'
    },
    {
        'name': 'Lo',
        'alias': 'Other_Letter',
        'bmp': '\xAA\xBA\u01BB\u01C0-\u01C3\u0294\u05D0-\u05EA\u05EF-\u05F2\u0620-\u063F\u0641-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u0800-\u0815\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08C7\u0904-\u0939\u093D\u0950\u0958-\u0961\u0972-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E45\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u1100-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17DC\u1820-\u1842\u1844-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C77\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u2135-\u2138\u2D30-\u2D67\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3006\u303C\u3041-\u3096\u309F\u30A1-\u30FA\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\u9FFC\uA000-\uA014\uA016-\uA48C\uA4D0-\uA4F7\uA500-\uA60B\uA610-\uA61F\uA62A\uA62B\uA66E\uA6A0-\uA6E5\uA78F\uA7F7\uA7FB-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9E0-\uA9E4\uA9E7-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA6F\uAA71-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB\uAADC\uAAE0-\uAAEA\uAAF2\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF66-\uFF6F\uFF71-\uFF9D\uFFA0-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC',
        'astral': '\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF40\uDF42-\uDF49\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF]|\uD801[\uDC50-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDD00-\uDD23\uDE80-\uDEA9\uDEB0\uDEB1\uDF00-\uDF1C\uDF27\uDF30-\uDF45\uDFB0-\uDFC4\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDEB8\uDF00-\uDF1A]|\uD806[\uDC00-\uDC2B\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDEE0-\uDEF2\uDFB0]|\uD808[\uDC00-\uDF99]|\uD809[\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF4A\uDF50]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82C[\uDC00-\uDD1E\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD838[\uDD00-\uDD2C\uDD4E\uDEC0-\uDEEB]|\uD83A[\uDC00-\uDCC4]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDEDD\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A]'
    },
    {
        'name': 'Lt',
        'alias': 'Titlecase_Letter',
        'bmp': '\u01C5\u01C8\u01CB\u01F2\u1F88-\u1F8F\u1F98-\u1F9F\u1FA8-\u1FAF\u1FBC\u1FCC\u1FFC'
    },
    {
        'name': 'Lu',
        'alias': 'Uppercase_Letter',
        'bmp': 'A-Z\xC0-\xD6\xD8-\xDE\u0100\u0102\u0104\u0106\u0108\u010A\u010C\u010E\u0110\u0112\u0114\u0116\u0118\u011A\u011C\u011E\u0120\u0122\u0124\u0126\u0128\u012A\u012C\u012E\u0130\u0132\u0134\u0136\u0139\u013B\u013D\u013F\u0141\u0143\u0145\u0147\u014A\u014C\u014E\u0150\u0152\u0154\u0156\u0158\u015A\u015C\u015E\u0160\u0162\u0164\u0166\u0168\u016A\u016C\u016E\u0170\u0172\u0174\u0176\u0178\u0179\u017B\u017D\u0181\u0182\u0184\u0186\u0187\u0189-\u018B\u018E-\u0191\u0193\u0194\u0196-\u0198\u019C\u019D\u019F\u01A0\u01A2\u01A4\u01A6\u01A7\u01A9\u01AC\u01AE\u01AF\u01B1-\u01B3\u01B5\u01B7\u01B8\u01BC\u01C4\u01C7\u01CA\u01CD\u01CF\u01D1\u01D3\u01D5\u01D7\u01D9\u01DB\u01DE\u01E0\u01E2\u01E4\u01E6\u01E8\u01EA\u01EC\u01EE\u01F1\u01F4\u01F6-\u01F8\u01FA\u01FC\u01FE\u0200\u0202\u0204\u0206\u0208\u020A\u020C\u020E\u0210\u0212\u0214\u0216\u0218\u021A\u021C\u021E\u0220\u0222\u0224\u0226\u0228\u022A\u022C\u022E\u0230\u0232\u023A\u023B\u023D\u023E\u0241\u0243-\u0246\u0248\u024A\u024C\u024E\u0370\u0372\u0376\u037F\u0386\u0388-\u038A\u038C\u038E\u038F\u0391-\u03A1\u03A3-\u03AB\u03CF\u03D2-\u03D4\u03D8\u03DA\u03DC\u03DE\u03E0\u03E2\u03E4\u03E6\u03E8\u03EA\u03EC\u03EE\u03F4\u03F7\u03F9\u03FA\u03FD-\u042F\u0460\u0462\u0464\u0466\u0468\u046A\u046C\u046E\u0470\u0472\u0474\u0476\u0478\u047A\u047C\u047E\u0480\u048A\u048C\u048E\u0490\u0492\u0494\u0496\u0498\u049A\u049C\u049E\u04A0\u04A2\u04A4\u04A6\u04A8\u04AA\u04AC\u04AE\u04B0\u04B2\u04B4\u04B6\u04B8\u04BA\u04BC\u04BE\u04C0\u04C1\u04C3\u04C5\u04C7\u04C9\u04CB\u04CD\u04D0\u04D2\u04D4\u04D6\u04D8\u04DA\u04DC\u04DE\u04E0\u04E2\u04E4\u04E6\u04E8\u04EA\u04EC\u04EE\u04F0\u04F2\u04F4\u04F6\u04F8\u04FA\u04FC\u04FE\u0500\u0502\u0504\u0506\u0508\u050A\u050C\u050E\u0510\u0512\u0514\u0516\u0518\u051A\u051C\u051E\u0520\u0522\u0524\u0526\u0528\u052A\u052C\u052E\u0531-\u0556\u10A0-\u10C5\u10C7\u10CD\u13A0-\u13F5\u1C90-\u1CBA\u1CBD-\u1CBF\u1E00\u1E02\u1E04\u1E06\u1E08\u1E0A\u1E0C\u1E0E\u1E10\u1E12\u1E14\u1E16\u1E18\u1E1A\u1E1C\u1E1E\u1E20\u1E22\u1E24\u1E26\u1E28\u1E2A\u1E2C\u1E2E\u1E30\u1E32\u1E34\u1E36\u1E38\u1E3A\u1E3C\u1E3E\u1E40\u1E42\u1E44\u1E46\u1E48\u1E4A\u1E4C\u1E4E\u1E50\u1E52\u1E54\u1E56\u1E58\u1E5A\u1E5C\u1E5E\u1E60\u1E62\u1E64\u1E66\u1E68\u1E6A\u1E6C\u1E6E\u1E70\u1E72\u1E74\u1E76\u1E78\u1E7A\u1E7C\u1E7E\u1E80\u1E82\u1E84\u1E86\u1E88\u1E8A\u1E8C\u1E8E\u1E90\u1E92\u1E94\u1E9E\u1EA0\u1EA2\u1EA4\u1EA6\u1EA8\u1EAA\u1EAC\u1EAE\u1EB0\u1EB2\u1EB4\u1EB6\u1EB8\u1EBA\u1EBC\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6\u1EC8\u1ECA\u1ECC\u1ECE\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u1EDA\u1EDC\u1EDE\u1EE0\u1EE2\u1EE4\u1EE6\u1EE8\u1EEA\u1EEC\u1EEE\u1EF0\u1EF2\u1EF4\u1EF6\u1EF8\u1EFA\u1EFC\u1EFE\u1F08-\u1F0F\u1F18-\u1F1D\u1F28-\u1F2F\u1F38-\u1F3F\u1F48-\u1F4D\u1F59\u1F5B\u1F5D\u1F5F\u1F68-\u1F6F\u1FB8-\u1FBB\u1FC8-\u1FCB\u1FD8-\u1FDB\u1FE8-\u1FEC\u1FF8-\u1FFB\u2102\u2107\u210B-\u210D\u2110-\u2112\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u2130-\u2133\u213E\u213F\u2145\u2183\u2C00-\u2C2E\u2C60\u2C62-\u2C64\u2C67\u2C69\u2C6B\u2C6D-\u2C70\u2C72\u2C75\u2C7E-\u2C80\u2C82\u2C84\u2C86\u2C88\u2C8A\u2C8C\u2C8E\u2C90\u2C92\u2C94\u2C96\u2C98\u2C9A\u2C9C\u2C9E\u2CA0\u2CA2\u2CA4\u2CA6\u2CA8\u2CAA\u2CAC\u2CAE\u2CB0\u2CB2\u2CB4\u2CB6\u2CB8\u2CBA\u2CBC\u2CBE\u2CC0\u2CC2\u2CC4\u2CC6\u2CC8\u2CCA\u2CCC\u2CCE\u2CD0\u2CD2\u2CD4\u2CD6\u2CD8\u2CDA\u2CDC\u2CDE\u2CE0\u2CE2\u2CEB\u2CED\u2CF2\uA640\uA642\uA644\uA646\uA648\uA64A\uA64C\uA64E\uA650\uA652\uA654\uA656\uA658\uA65A\uA65C\uA65E\uA660\uA662\uA664\uA666\uA668\uA66A\uA66C\uA680\uA682\uA684\uA686\uA688\uA68A\uA68C\uA68E\uA690\uA692\uA694\uA696\uA698\uA69A\uA722\uA724\uA726\uA728\uA72A\uA72C\uA72E\uA732\uA734\uA736\uA738\uA73A\uA73C\uA73E\uA740\uA742\uA744\uA746\uA748\uA74A\uA74C\uA74E\uA750\uA752\uA754\uA756\uA758\uA75A\uA75C\uA75E\uA760\uA762\uA764\uA766\uA768\uA76A\uA76C\uA76E\uA779\uA77B\uA77D\uA77E\uA780\uA782\uA784\uA786\uA78B\uA78D\uA790\uA792\uA796\uA798\uA79A\uA79C\uA79E\uA7A0\uA7A2\uA7A4\uA7A6\uA7A8\uA7AA-\uA7AE\uA7B0-\uA7B4\uA7B6\uA7B8\uA7BA\uA7BC\uA7BE\uA7C2\uA7C4-\uA7C7\uA7C9\uA7F5\uFF21-\uFF3A',
        'astral': '\uD801[\uDC00-\uDC27\uDCB0-\uDCD3]|\uD803[\uDC80-\uDCB2]|\uD806[\uDCA0-\uDCBF]|\uD81B[\uDE40-\uDE5F]|\uD835[\uDC00-\uDC19\uDC34-\uDC4D\uDC68-\uDC81\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB5\uDCD0-\uDCE9\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD38\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD6C-\uDD85\uDDA0-\uDDB9\uDDD4-\uDDED\uDE08-\uDE21\uDE3C-\uDE55\uDE70-\uDE89\uDEA8-\uDEC0\uDEE2-\uDEFA\uDF1C-\uDF34\uDF56-\uDF6E\uDF90-\uDFA8\uDFCA]|\uD83A[\uDD00-\uDD21]'
    },
    {
        'name': 'M',
        'alias': 'Mark',
        'bmp': '\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1AC0\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F',
        'astral': '\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD803[\uDD24-\uDD27\uDEAB\uDEAC\uDF46-\uDF50]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC7F-\uDC82\uDCB0-\uDCBA\uDD00-\uDD02\uDD27-\uDD34\uDD45\uDD46\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDDC9-\uDDCC\uDDCE\uDDCF\uDE2C-\uDE37\uDE3E\uDEDF-\uDEEA\uDF00-\uDF03\uDF3B\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC35-\uDC46\uDC5E\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDDDC\uDDDD\uDE30-\uDE40\uDEAB-\uDEB7\uDF1D-\uDF2B]|\uD806[\uDC2C-\uDC3A\uDD30-\uDD35\uDD37\uDD38\uDD3B-\uDD3E\uDD40\uDD42\uDD43\uDDD1-\uDDD7\uDDDA-\uDDE0\uDDE4\uDE01-\uDE0A\uDE33-\uDE39\uDE3B-\uDE3E\uDE47\uDE51-\uDE5B\uDE8A-\uDE99]|\uD807[\uDC2F-\uDC36\uDC38-\uDC3F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD31-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD45\uDD47\uDD8A-\uDD8E\uDD90\uDD91\uDD93-\uDD97\uDEF3-\uDEF6]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF4F\uDF51-\uDF87\uDF8F-\uDF92\uDFE4\uDFF0\uDFF1]|\uD82F[\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDD30-\uDD36\uDEEC-\uDEEF]|\uD83A[\uDCD0-\uDCD6\uDD44-\uDD4A]|\uDB40[\uDD00-\uDDEF]'
    },
    {
        'name': 'Mc',
        'alias': 'Spacing_Mark',
        'bmp': '\u0903\u093B\u093E-\u0940\u0949-\u094C\u094E\u094F\u0982\u0983\u09BE-\u09C0\u09C7\u09C8\u09CB\u09CC\u09D7\u0A03\u0A3E-\u0A40\u0A83\u0ABE-\u0AC0\u0AC9\u0ACB\u0ACC\u0B02\u0B03\u0B3E\u0B40\u0B47\u0B48\u0B4B\u0B4C\u0B57\u0BBE\u0BBF\u0BC1\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCC\u0BD7\u0C01-\u0C03\u0C41-\u0C44\u0C82\u0C83\u0CBE\u0CC0-\u0CC4\u0CC7\u0CC8\u0CCA\u0CCB\u0CD5\u0CD6\u0D02\u0D03\u0D3E-\u0D40\u0D46-\u0D48\u0D4A-\u0D4C\u0D57\u0D82\u0D83\u0DCF-\u0DD1\u0DD8-\u0DDF\u0DF2\u0DF3\u0F3E\u0F3F\u0F7F\u102B\u102C\u1031\u1038\u103B\u103C\u1056\u1057\u1062-\u1064\u1067-\u106D\u1083\u1084\u1087-\u108C\u108F\u109A-\u109C\u17B6\u17BE-\u17C5\u17C7\u17C8\u1923-\u1926\u1929-\u192B\u1930\u1931\u1933-\u1938\u1A19\u1A1A\u1A55\u1A57\u1A61\u1A63\u1A64\u1A6D-\u1A72\u1B04\u1B35\u1B3B\u1B3D-\u1B41\u1B43\u1B44\u1B82\u1BA1\u1BA6\u1BA7\u1BAA\u1BE7\u1BEA-\u1BEC\u1BEE\u1BF2\u1BF3\u1C24-\u1C2B\u1C34\u1C35\u1CE1\u1CF7\u302E\u302F\uA823\uA824\uA827\uA880\uA881\uA8B4-\uA8C3\uA952\uA953\uA983\uA9B4\uA9B5\uA9BA\uA9BB\uA9BE-\uA9C0\uAA2F\uAA30\uAA33\uAA34\uAA4D\uAA7B\uAA7D\uAAEB\uAAEE\uAAEF\uAAF5\uABE3\uABE4\uABE6\uABE7\uABE9\uABEA\uABEC',
        'astral': '\uD804[\uDC00\uDC02\uDC82\uDCB0-\uDCB2\uDCB7\uDCB8\uDD2C\uDD45\uDD46\uDD82\uDDB3-\uDDB5\uDDBF\uDDC0\uDDCE\uDE2C-\uDE2E\uDE32\uDE33\uDE35\uDEE0-\uDEE2\uDF02\uDF03\uDF3E\uDF3F\uDF41-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63]|\uD805[\uDC35-\uDC37\uDC40\uDC41\uDC45\uDCB0-\uDCB2\uDCB9\uDCBB-\uDCBE\uDCC1\uDDAF-\uDDB1\uDDB8-\uDDBB\uDDBE\uDE30-\uDE32\uDE3B\uDE3C\uDE3E\uDEAC\uDEAE\uDEAF\uDEB6\uDF20\uDF21\uDF26]|\uD806[\uDC2C-\uDC2E\uDC38\uDD30-\uDD35\uDD37\uDD38\uDD3D\uDD40\uDD42\uDDD1-\uDDD3\uDDDC-\uDDDF\uDDE4\uDE39\uDE57\uDE58\uDE97]|\uD807[\uDC2F\uDC3E\uDCA9\uDCB1\uDCB4\uDD8A-\uDD8E\uDD93\uDD94\uDD96\uDEF5\uDEF6]|\uD81B[\uDF51-\uDF87\uDFF0\uDFF1]|\uD834[\uDD65\uDD66\uDD6D-\uDD72]'
    },
    {
        'name': 'Me',
        'alias': 'Enclosing_Mark',
        'bmp': '\u0488\u0489\u1ABE\u20DD-\u20E0\u20E2-\u20E4\uA670-\uA672'
    },
    {
        'name': 'Mn',
        'alias': 'Nonspacing_Mark',
        'bmp': '\u0300-\u036F\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0902\u093A\u093C\u0941-\u0948\u094D\u0951-\u0957\u0962\u0963\u0981\u09BC\u09C1-\u09C4\u09CD\u09E2\u09E3\u09FE\u0A01\u0A02\u0A3C\u0A41\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81\u0A82\u0ABC\u0AC1-\u0AC5\u0AC7\u0AC8\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01\u0B3C\u0B3F\u0B41-\u0B44\u0B4D\u0B55\u0B56\u0B62\u0B63\u0B82\u0BC0\u0BCD\u0C00\u0C04\u0C3E-\u0C40\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81\u0CBC\u0CBF\u0CC6\u0CCC\u0CCD\u0CE2\u0CE3\u0D00\u0D01\u0D3B\u0D3C\u0D41-\u0D44\u0D4D\u0D62\u0D63\u0D81\u0DCA\u0DD2-\u0DD4\u0DD6\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F71-\u0F7E\u0F80-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102D-\u1030\u1032-\u1037\u1039\u103A\u103D\u103E\u1058\u1059\u105E-\u1060\u1071-\u1074\u1082\u1085\u1086\u108D\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4\u17B5\u17B7-\u17BD\u17C6\u17C9-\u17D3\u17DD\u180B-\u180D\u1885\u1886\u18A9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193B\u1A17\u1A18\u1A1B\u1A56\u1A58-\u1A5E\u1A60\u1A62\u1A65-\u1A6C\u1A73-\u1A7C\u1A7F\u1AB0-\u1ABD\u1ABF\u1AC0\u1B00-\u1B03\u1B34\u1B36-\u1B3A\u1B3C\u1B42\u1B6B-\u1B73\u1B80\u1B81\u1BA2-\u1BA5\u1BA8\u1BA9\u1BAB-\u1BAD\u1BE6\u1BE8\u1BE9\u1BED\u1BEF-\u1BF1\u1C2C-\u1C33\u1C36\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE0\u1CE2-\u1CE8\u1CED\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302D\u3099\u309A\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA825\uA826\uA82C\uA8C4\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA951\uA980-\uA982\uA9B3\uA9B6-\uA9B9\uA9BC\uA9BD\uA9E5\uAA29-\uAA2E\uAA31\uAA32\uAA35\uAA36\uAA43\uAA4C\uAA7C\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEC\uAAED\uAAF6\uABE5\uABE8\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F',
        'astral': '\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD803[\uDD24-\uDD27\uDEAB\uDEAC\uDF46-\uDF50]|\uD804[\uDC01\uDC38-\uDC46\uDC7F-\uDC81\uDCB3-\uDCB6\uDCB9\uDCBA\uDD00-\uDD02\uDD27-\uDD2B\uDD2D-\uDD34\uDD73\uDD80\uDD81\uDDB6-\uDDBE\uDDC9-\uDDCC\uDDCF\uDE2F-\uDE31\uDE34\uDE36\uDE37\uDE3E\uDEDF\uDEE3-\uDEEA\uDF00\uDF01\uDF3B\uDF3C\uDF40\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC38-\uDC3F\uDC42-\uDC44\uDC46\uDC5E\uDCB3-\uDCB8\uDCBA\uDCBF\uDCC0\uDCC2\uDCC3\uDDB2-\uDDB5\uDDBC\uDDBD\uDDBF\uDDC0\uDDDC\uDDDD\uDE33-\uDE3A\uDE3D\uDE3F\uDE40\uDEAB\uDEAD\uDEB0-\uDEB5\uDEB7\uDF1D-\uDF1F\uDF22-\uDF25\uDF27-\uDF2B]|\uD806[\uDC2F-\uDC37\uDC39\uDC3A\uDD3B\uDD3C\uDD3E\uDD43\uDDD4-\uDDD7\uDDDA\uDDDB\uDDE0\uDE01-\uDE0A\uDE33-\uDE38\uDE3B-\uDE3E\uDE47\uDE51-\uDE56\uDE59-\uDE5B\uDE8A-\uDE96\uDE98\uDE99]|\uD807[\uDC30-\uDC36\uDC38-\uDC3D\uDC3F\uDC92-\uDCA7\uDCAA-\uDCB0\uDCB2\uDCB3\uDCB5\uDCB6\uDD31-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD45\uDD47\uDD90\uDD91\uDD95\uDD97\uDEF3\uDEF4]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF4F\uDF8F-\uDF92\uDFE4]|\uD82F[\uDC9D\uDC9E]|\uD834[\uDD67-\uDD69\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDD30-\uDD36\uDEEC-\uDEEF]|\uD83A[\uDCD0-\uDCD6\uDD44-\uDD4A]|\uDB40[\uDD00-\uDDEF]'
    },
    {
        'name': 'N',
        'alias': 'Number',
        'bmp': '0-9\xB2\xB3\xB9\xBC-\xBE\u0660-\u0669\u06F0-\u06F9\u07C0-\u07C9\u0966-\u096F\u09E6-\u09EF\u09F4-\u09F9\u0A66-\u0A6F\u0AE6-\u0AEF\u0B66-\u0B6F\u0B72-\u0B77\u0BE6-\u0BF2\u0C66-\u0C6F\u0C78-\u0C7E\u0CE6-\u0CEF\u0D58-\u0D5E\u0D66-\u0D78\u0DE6-\u0DEF\u0E50-\u0E59\u0ED0-\u0ED9\u0F20-\u0F33\u1040-\u1049\u1090-\u1099\u1369-\u137C\u16EE-\u16F0\u17E0-\u17E9\u17F0-\u17F9\u1810-\u1819\u1946-\u194F\u19D0-\u19DA\u1A80-\u1A89\u1A90-\u1A99\u1B50-\u1B59\u1BB0-\u1BB9\u1C40-\u1C49\u1C50-\u1C59\u2070\u2074-\u2079\u2080-\u2089\u2150-\u2182\u2185-\u2189\u2460-\u249B\u24EA-\u24FF\u2776-\u2793\u2CFD\u3007\u3021-\u3029\u3038-\u303A\u3192-\u3195\u3220-\u3229\u3248-\u324F\u3251-\u325F\u3280-\u3289\u32B1-\u32BF\uA620-\uA629\uA6E6-\uA6EF\uA830-\uA835\uA8D0-\uA8D9\uA900-\uA909\uA9D0-\uA9D9\uA9F0-\uA9F9\uAA50-\uAA59\uABF0-\uABF9\uFF10-\uFF19',
        'astral': '\uD800[\uDD07-\uDD33\uDD40-\uDD78\uDD8A\uDD8B\uDEE1-\uDEFB\uDF20-\uDF23\uDF41\uDF4A\uDFD1-\uDFD5]|\uD801[\uDCA0-\uDCA9]|\uD802[\uDC58-\uDC5F\uDC79-\uDC7F\uDCA7-\uDCAF\uDCFB-\uDCFF\uDD16-\uDD1B\uDDBC\uDDBD\uDDC0-\uDDCF\uDDD2-\uDDFF\uDE40-\uDE48\uDE7D\uDE7E\uDE9D-\uDE9F\uDEEB-\uDEEF\uDF58-\uDF5F\uDF78-\uDF7F\uDFA9-\uDFAF]|\uD803[\uDCFA-\uDCFF\uDD30-\uDD39\uDE60-\uDE7E\uDF1D-\uDF26\uDF51-\uDF54\uDFC5-\uDFCB]|\uD804[\uDC52-\uDC6F\uDCF0-\uDCF9\uDD36-\uDD3F\uDDD0-\uDDD9\uDDE1-\uDDF4\uDEF0-\uDEF9]|\uD805[\uDC50-\uDC59\uDCD0-\uDCD9\uDE50-\uDE59\uDEC0-\uDEC9\uDF30-\uDF3B]|\uD806[\uDCE0-\uDCF2\uDD50-\uDD59]|\uD807[\uDC50-\uDC6C\uDD50-\uDD59\uDDA0-\uDDA9\uDFC0-\uDFD4]|\uD809[\uDC00-\uDC6E]|\uD81A[\uDE60-\uDE69\uDF50-\uDF59\uDF5B-\uDF61]|\uD81B[\uDE80-\uDE96]|\uD834[\uDEE0-\uDEF3\uDF60-\uDF78]|\uD835[\uDFCE-\uDFFF]|\uD838[\uDD40-\uDD49\uDEF0-\uDEF9]|\uD83A[\uDCC7-\uDCCF\uDD50-\uDD59]|\uD83B[\uDC71-\uDCAB\uDCAD-\uDCAF\uDCB1-\uDCB4\uDD01-\uDD2D\uDD2F-\uDD3D]|\uD83C[\uDD00-\uDD0C]|\uD83E[\uDFF0-\uDFF9]'
    },
    {
        'name': 'Nd',
        'alias': 'Decimal_Number',
        'bmp': '0-9\u0660-\u0669\u06F0-\u06F9\u07C0-\u07C9\u0966-\u096F\u09E6-\u09EF\u0A66-\u0A6F\u0AE6-\u0AEF\u0B66-\u0B6F\u0BE6-\u0BEF\u0C66-\u0C6F\u0CE6-\u0CEF\u0D66-\u0D6F\u0DE6-\u0DEF\u0E50-\u0E59\u0ED0-\u0ED9\u0F20-\u0F29\u1040-\u1049\u1090-\u1099\u17E0-\u17E9\u1810-\u1819\u1946-\u194F\u19D0-\u19D9\u1A80-\u1A89\u1A90-\u1A99\u1B50-\u1B59\u1BB0-\u1BB9\u1C40-\u1C49\u1C50-\u1C59\uA620-\uA629\uA8D0-\uA8D9\uA900-\uA909\uA9D0-\uA9D9\uA9F0-\uA9F9\uAA50-\uAA59\uABF0-\uABF9\uFF10-\uFF19',
        'astral': '\uD801[\uDCA0-\uDCA9]|\uD803[\uDD30-\uDD39]|\uD804[\uDC66-\uDC6F\uDCF0-\uDCF9\uDD36-\uDD3F\uDDD0-\uDDD9\uDEF0-\uDEF9]|\uD805[\uDC50-\uDC59\uDCD0-\uDCD9\uDE50-\uDE59\uDEC0-\uDEC9\uDF30-\uDF39]|\uD806[\uDCE0-\uDCE9\uDD50-\uDD59]|\uD807[\uDC50-\uDC59\uDD50-\uDD59\uDDA0-\uDDA9]|\uD81A[\uDE60-\uDE69\uDF50-\uDF59]|\uD835[\uDFCE-\uDFFF]|\uD838[\uDD40-\uDD49\uDEF0-\uDEF9]|\uD83A[\uDD50-\uDD59]|\uD83E[\uDFF0-\uDFF9]'
    },
    {
        'name': 'Nl',
        'alias': 'Letter_Number',
        'bmp': '\u16EE-\u16F0\u2160-\u2182\u2185-\u2188\u3007\u3021-\u3029\u3038-\u303A\uA6E6-\uA6EF',
        'astral': '\uD800[\uDD40-\uDD74\uDF41\uDF4A\uDFD1-\uDFD5]|\uD809[\uDC00-\uDC6E]'
    },
    {
        'name': 'No',
        'alias': 'Other_Number',
        'bmp': '\xB2\xB3\xB9\xBC-\xBE\u09F4-\u09F9\u0B72-\u0B77\u0BF0-\u0BF2\u0C78-\u0C7E\u0D58-\u0D5E\u0D70-\u0D78\u0F2A-\u0F33\u1369-\u137C\u17F0-\u17F9\u19DA\u2070\u2074-\u2079\u2080-\u2089\u2150-\u215F\u2189\u2460-\u249B\u24EA-\u24FF\u2776-\u2793\u2CFD\u3192-\u3195\u3220-\u3229\u3248-\u324F\u3251-\u325F\u3280-\u3289\u32B1-\u32BF\uA830-\uA835',
        'astral': '\uD800[\uDD07-\uDD33\uDD75-\uDD78\uDD8A\uDD8B\uDEE1-\uDEFB\uDF20-\uDF23]|\uD802[\uDC58-\uDC5F\uDC79-\uDC7F\uDCA7-\uDCAF\uDCFB-\uDCFF\uDD16-\uDD1B\uDDBC\uDDBD\uDDC0-\uDDCF\uDDD2-\uDDFF\uDE40-\uDE48\uDE7D\uDE7E\uDE9D-\uDE9F\uDEEB-\uDEEF\uDF58-\uDF5F\uDF78-\uDF7F\uDFA9-\uDFAF]|\uD803[\uDCFA-\uDCFF\uDE60-\uDE7E\uDF1D-\uDF26\uDF51-\uDF54\uDFC5-\uDFCB]|\uD804[\uDC52-\uDC65\uDDE1-\uDDF4]|\uD805[\uDF3A\uDF3B]|\uD806[\uDCEA-\uDCF2]|\uD807[\uDC5A-\uDC6C\uDFC0-\uDFD4]|\uD81A[\uDF5B-\uDF61]|\uD81B[\uDE80-\uDE96]|\uD834[\uDEE0-\uDEF3\uDF60-\uDF78]|\uD83A[\uDCC7-\uDCCF]|\uD83B[\uDC71-\uDCAB\uDCAD-\uDCAF\uDCB1-\uDCB4\uDD01-\uDD2D\uDD2F-\uDD3D]|\uD83C[\uDD00-\uDD0C]'
    },
    {
        'name': 'P',
        'alias': 'Punctuation',
        'bmp': '!-#%-\\*,-\\/:;\\?@\\[-\\]_\\{\\}\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65',
        'astral': '\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD803[\uDEAD\uDF55-\uDF59]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5A\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDF3C-\uDF3E]|\uD806[\uDC3B\uDD44-\uDD46\uDDE2\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2]|\uD807[\uDC41-\uDC45\uDC70\uDC71\uDEF7\uDEF8\uDFFF]|\uD809[\uDC70-\uDC74]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD81B[\uDE97-\uDE9A\uDFE2]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]'
    },
    {
        'name': 'Pc',
        'alias': 'Connector_Punctuation',
        'bmp': '_\u203F\u2040\u2054\uFE33\uFE34\uFE4D-\uFE4F\uFF3F'
    },
    {
        'name': 'Pd',
        'alias': 'Dash_Punctuation',
        'bmp': '\\-\u058A\u05BE\u1400\u1806\u2010-\u2015\u2E17\u2E1A\u2E3A\u2E3B\u2E40\u301C\u3030\u30A0\uFE31\uFE32\uFE58\uFE63\uFF0D',
        'astral': '\uD803\uDEAD'
    },
    {
        'name': 'Pe',
        'alias': 'Close_Punctuation',
        'bmp': '\\)\\]\\}\u0F3B\u0F3D\u169C\u2046\u207E\u208E\u2309\u230B\u232A\u2769\u276B\u276D\u276F\u2771\u2773\u2775\u27C6\u27E7\u27E9\u27EB\u27ED\u27EF\u2984\u2986\u2988\u298A\u298C\u298E\u2990\u2992\u2994\u2996\u2998\u29D9\u29DB\u29FD\u2E23\u2E25\u2E27\u2E29\u3009\u300B\u300D\u300F\u3011\u3015\u3017\u3019\u301B\u301E\u301F\uFD3E\uFE18\uFE36\uFE38\uFE3A\uFE3C\uFE3E\uFE40\uFE42\uFE44\uFE48\uFE5A\uFE5C\uFE5E\uFF09\uFF3D\uFF5D\uFF60\uFF63'
    },
    {
        'name': 'Pf',
        'alias': 'Final_Punctuation',
        'bmp': '\xBB\u2019\u201D\u203A\u2E03\u2E05\u2E0A\u2E0D\u2E1D\u2E21'
    },
    {
        'name': 'Pi',
        'alias': 'Initial_Punctuation',
        'bmp': '\xAB\u2018\u201B\u201C\u201F\u2039\u2E02\u2E04\u2E09\u2E0C\u2E1C\u2E20'
    },
    {
        'name': 'Po',
        'alias': 'Other_Punctuation',
        'bmp': '!-#%-\'\\*,\\.\\/:;\\?@\\\xA1\xA7\xB6\xB7\xBF\u037E\u0387\u055A-\u055F\u0589\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u166E\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u1805\u1807-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2016\u2017\u2020-\u2027\u2030-\u2038\u203B-\u203E\u2041-\u2043\u2047-\u2051\u2053\u2055-\u205E\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00\u2E01\u2E06-\u2E08\u2E0B\u2E0E-\u2E16\u2E18\u2E19\u2E1B\u2E1E\u2E1F\u2E2A-\u2E2E\u2E30-\u2E39\u2E3C-\u2E3F\u2E41\u2E43-\u2E4F\u2E52\u3001-\u3003\u303D\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFE10-\uFE16\uFE19\uFE30\uFE45\uFE46\uFE49-\uFE4C\uFE50-\uFE52\uFE54-\uFE57\uFE5F-\uFE61\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF07\uFF0A\uFF0C\uFF0E\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3C\uFF61\uFF64\uFF65',
        'astral': '\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD803[\uDF55-\uDF59]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5A\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDF3C-\uDF3E]|\uD806[\uDC3B\uDD44-\uDD46\uDDE2\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2]|\uD807[\uDC41-\uDC45\uDC70\uDC71\uDEF7\uDEF8\uDFFF]|\uD809[\uDC70-\uDC74]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD81B[\uDE97-\uDE9A\uDFE2]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]'
    },
    {
        'name': 'Ps',
        'alias': 'Open_Punctuation',
        'bmp': '\\(\\[\\{\u0F3A\u0F3C\u169B\u201A\u201E\u2045\u207D\u208D\u2308\u230A\u2329\u2768\u276A\u276C\u276E\u2770\u2772\u2774\u27C5\u27E6\u27E8\u27EA\u27EC\u27EE\u2983\u2985\u2987\u2989\u298B\u298D\u298F\u2991\u2993\u2995\u2997\u29D8\u29DA\u29FC\u2E22\u2E24\u2E26\u2E28\u2E42\u3008\u300A\u300C\u300E\u3010\u3014\u3016\u3018\u301A\u301D\uFD3F\uFE17\uFE35\uFE37\uFE39\uFE3B\uFE3D\uFE3F\uFE41\uFE43\uFE47\uFE59\uFE5B\uFE5D\uFF08\uFF3B\uFF5B\uFF5F\uFF62'
    },
    {
        'name': 'S',
        'alias': 'Symbol',
        'bmp': '\\$\\+<->\\^`\\|~\xA2-\xA6\xA8\xA9\xAC\xAE-\xB1\xB4\xB8\xD7\xF7\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0384\u0385\u03F6\u0482\u058D-\u058F\u0606-\u0608\u060B\u060E\u060F\u06DE\u06E9\u06FD\u06FE\u07F6\u07FE\u07FF\u09F2\u09F3\u09FA\u09FB\u0AF1\u0B70\u0BF3-\u0BFA\u0C7F\u0D4F\u0D79\u0E3F\u0F01-\u0F03\u0F13\u0F15-\u0F17\u0F1A-\u0F1F\u0F34\u0F36\u0F38\u0FBE-\u0FC5\u0FC7-\u0FCC\u0FCE\u0FCF\u0FD5-\u0FD8\u109E\u109F\u1390-\u1399\u166D\u17DB\u1940\u19DE-\u19FF\u1B61-\u1B6A\u1B74-\u1B7C\u1FBD\u1FBF-\u1FC1\u1FCD-\u1FCF\u1FDD-\u1FDF\u1FED-\u1FEF\u1FFD\u1FFE\u2044\u2052\u207A-\u207C\u208A-\u208C\u20A0-\u20BF\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u2140-\u2144\u214A-\u214D\u214F\u218A\u218B\u2190-\u2307\u230C-\u2328\u232B-\u2426\u2440-\u244A\u249C-\u24E9\u2500-\u2767\u2794-\u27C4\u27C7-\u27E5\u27F0-\u2982\u2999-\u29D7\u29DC-\u29FB\u29FE-\u2B73\u2B76-\u2B95\u2B97-\u2BFF\u2CE5-\u2CEA\u2E50\u2E51\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFB\u3004\u3012\u3013\u3020\u3036\u3037\u303E\u303F\u309B\u309C\u3190\u3191\u3196-\u319F\u31C0-\u31E3\u3200-\u321E\u322A-\u3247\u3250\u3260-\u327F\u328A-\u32B0\u32C0-\u33FF\u4DC0-\u4DFF\uA490-\uA4C6\uA700-\uA716\uA720\uA721\uA789\uA78A\uA828-\uA82B\uA836-\uA839\uAA77-\uAA79\uAB5B\uAB6A\uAB6B\uFB29\uFBB2-\uFBC1\uFDFC\uFDFD\uFE62\uFE64-\uFE66\uFE69\uFF04\uFF0B\uFF1C-\uFF1E\uFF3E\uFF40\uFF5C\uFF5E\uFFE0-\uFFE6\uFFE8-\uFFEE\uFFFC\uFFFD',
        'astral': '\uD800[\uDD37-\uDD3F\uDD79-\uDD89\uDD8C-\uDD8E\uDD90-\uDD9C\uDDA0\uDDD0-\uDDFC]|\uD802[\uDC77\uDC78\uDEC8]|\uD805\uDF3F|\uD807[\uDFD5-\uDFF1]|\uD81A[\uDF3C-\uDF3F\uDF45]|\uD82F\uDC9C|\uD834[\uDC00-\uDCF5\uDD00-\uDD26\uDD29-\uDD64\uDD6A-\uDD6C\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDDE8\uDE00-\uDE41\uDE45\uDF00-\uDF56]|\uD835[\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85\uDE86]|\uD838[\uDD4F\uDEFF]|\uD83B[\uDCAC\uDCB0\uDD2E\uDEF0\uDEF1]|\uD83C[\uDC00-\uDC2B\uDC30-\uDC93\uDCA0-\uDCAE\uDCB1-\uDCBF\uDCC1-\uDCCF\uDCD1-\uDCF5\uDD0D-\uDDAD\uDDE6-\uDE02\uDE10-\uDE3B\uDE40-\uDE48\uDE50\uDE51\uDE60-\uDE65\uDF00-\uDFFF]|\uD83D[\uDC00-\uDED7\uDEE0-\uDEEC\uDEF0-\uDEFC\uDF00-\uDF73\uDF80-\uDFD8\uDFE0-\uDFEB]|\uD83E[\uDC00-\uDC0B\uDC10-\uDC47\uDC50-\uDC59\uDC60-\uDC87\uDC90-\uDCAD\uDCB0\uDCB1\uDD00-\uDD78\uDD7A-\uDDCB\uDDCD-\uDE53\uDE60-\uDE6D\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6\uDF00-\uDF92\uDF94-\uDFCA]'
    },
    {
        'name': 'Sc',
        'alias': 'Currency_Symbol',
        'bmp': '\\$\xA2-\xA5\u058F\u060B\u07FE\u07FF\u09F2\u09F3\u09FB\u0AF1\u0BF9\u0E3F\u17DB\u20A0-\u20BF\uA838\uFDFC\uFE69\uFF04\uFFE0\uFFE1\uFFE5\uFFE6',
        'astral': '\uD807[\uDFDD-\uDFE0]|\uD838\uDEFF|\uD83B\uDCB0'
    },
    {
        'name': 'Sk',
        'alias': 'Modifier_Symbol',
        'bmp': '\\^`\xA8\xAF\xB4\xB8\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0384\u0385\u1FBD\u1FBF-\u1FC1\u1FCD-\u1FCF\u1FDD-\u1FDF\u1FED-\u1FEF\u1FFD\u1FFE\u309B\u309C\uA700-\uA716\uA720\uA721\uA789\uA78A\uAB5B\uAB6A\uAB6B\uFBB2-\uFBC1\uFF3E\uFF40\uFFE3',
        'astral': '\uD83C[\uDFFB-\uDFFF]'
    },
    {
        'name': 'Sm',
        'alias': 'Math_Symbol',
        'bmp': '\\+<->\\|~\xAC\xB1\xD7\xF7\u03F6\u0606-\u0608\u2044\u2052\u207A-\u207C\u208A-\u208C\u2118\u2140-\u2144\u214B\u2190-\u2194\u219A\u219B\u21A0\u21A3\u21A6\u21AE\u21CE\u21CF\u21D2\u21D4\u21F4-\u22FF\u2320\u2321\u237C\u239B-\u23B3\u23DC-\u23E1\u25B7\u25C1\u25F8-\u25FF\u266F\u27C0-\u27C4\u27C7-\u27E5\u27F0-\u27FF\u2900-\u2982\u2999-\u29D7\u29DC-\u29FB\u29FE-\u2AFF\u2B30-\u2B44\u2B47-\u2B4C\uFB29\uFE62\uFE64-\uFE66\uFF0B\uFF1C-\uFF1E\uFF5C\uFF5E\uFFE2\uFFE9-\uFFEC',
        'astral': '\uD835[\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3]|\uD83B[\uDEF0\uDEF1]'
    },
    {
        'name': 'So',
        'alias': 'Other_Symbol',
        'bmp': '\xA6\xA9\xAE\xB0\u0482\u058D\u058E\u060E\u060F\u06DE\u06E9\u06FD\u06FE\u07F6\u09FA\u0B70\u0BF3-\u0BF8\u0BFA\u0C7F\u0D4F\u0D79\u0F01-\u0F03\u0F13\u0F15-\u0F17\u0F1A-\u0F1F\u0F34\u0F36\u0F38\u0FBE-\u0FC5\u0FC7-\u0FCC\u0FCE\u0FCF\u0FD5-\u0FD8\u109E\u109F\u1390-\u1399\u166D\u1940\u19DE-\u19FF\u1B61-\u1B6A\u1B74-\u1B7C\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116\u2117\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u214A\u214C\u214D\u214F\u218A\u218B\u2195-\u2199\u219C-\u219F\u21A1\u21A2\u21A4\u21A5\u21A7-\u21AD\u21AF-\u21CD\u21D0\u21D1\u21D3\u21D5-\u21F3\u2300-\u2307\u230C-\u231F\u2322-\u2328\u232B-\u237B\u237D-\u239A\u23B4-\u23DB\u23E2-\u2426\u2440-\u244A\u249C-\u24E9\u2500-\u25B6\u25B8-\u25C0\u25C2-\u25F7\u2600-\u266E\u2670-\u2767\u2794-\u27BF\u2800-\u28FF\u2B00-\u2B2F\u2B45\u2B46\u2B4D-\u2B73\u2B76-\u2B95\u2B97-\u2BFF\u2CE5-\u2CEA\u2E50\u2E51\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFB\u3004\u3012\u3013\u3020\u3036\u3037\u303E\u303F\u3190\u3191\u3196-\u319F\u31C0-\u31E3\u3200-\u321E\u322A-\u3247\u3250\u3260-\u327F\u328A-\u32B0\u32C0-\u33FF\u4DC0-\u4DFF\uA490-\uA4C6\uA828-\uA82B\uA836\uA837\uA839\uAA77-\uAA79\uFDFD\uFFE4\uFFE8\uFFED\uFFEE\uFFFC\uFFFD',
        'astral': '\uD800[\uDD37-\uDD3F\uDD79-\uDD89\uDD8C-\uDD8E\uDD90-\uDD9C\uDDA0\uDDD0-\uDDFC]|\uD802[\uDC77\uDC78\uDEC8]|\uD805\uDF3F|\uD807[\uDFD5-\uDFDC\uDFE1-\uDFF1]|\uD81A[\uDF3C-\uDF3F\uDF45]|\uD82F\uDC9C|\uD834[\uDC00-\uDCF5\uDD00-\uDD26\uDD29-\uDD64\uDD6A-\uDD6C\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDDE8\uDE00-\uDE41\uDE45\uDF00-\uDF56]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85\uDE86]|\uD838\uDD4F|\uD83B[\uDCAC\uDD2E]|\uD83C[\uDC00-\uDC2B\uDC30-\uDC93\uDCA0-\uDCAE\uDCB1-\uDCBF\uDCC1-\uDCCF\uDCD1-\uDCF5\uDD0D-\uDDAD\uDDE6-\uDE02\uDE10-\uDE3B\uDE40-\uDE48\uDE50\uDE51\uDE60-\uDE65\uDF00-\uDFFA]|\uD83D[\uDC00-\uDED7\uDEE0-\uDEEC\uDEF0-\uDEFC\uDF00-\uDF73\uDF80-\uDFD8\uDFE0-\uDFEB]|\uD83E[\uDC00-\uDC0B\uDC10-\uDC47\uDC50-\uDC59\uDC60-\uDC87\uDC90-\uDCAD\uDCB0\uDCB1\uDD00-\uDD78\uDD7A-\uDDCB\uDDCD-\uDE53\uDE60-\uDE6D\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6\uDF00-\uDF92\uDF94-\uDFCA]'
    },
    {
        'name': 'Z',
        'alias': 'Separator',
        'bmp': ' \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000'
    },
    {
        'name': 'Zl',
        'alias': 'Line_Separator',
        'bmp': '\u2028'
    },
    {
        'name': 'Zp',
        'alias': 'Paragraph_Separator',
        'bmp': '\u2029'
    },
    {
        'name': 'Zs',
        'alias': 'Space_Separator',
        'bmp': ' \xA0\u1680\u2000-\u200A\u202F\u205F\u3000'
    }
];

var jabref = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.parse = void 0;
function decode(s, sep = ';') {
    s = s.replace(/\n/g, '');
    let pos = 0;
    const records = [''];
    while (pos < s.length) {
        switch (s[pos]) {
            case '\\':
                pos++;
                records[0] += s[pos];
                break;
            case sep:
                records.unshift('');
                break;
            default:
                records[0] += s[pos];
        }
        pos++;
    }
    return records.reverse().filter(record => record);
}
const prefixes = {
    fileDirectory: 'jabref-meta: fileDirectory:',
    groupsversion: 'jabref-meta: groupsversion:',
    groupstree: 'jabref-meta: groupstree:',
    grouping: 'jabref-meta: grouping:',
};
/**
 * Import the JabRef groups from the `@string` comments in which they were stored. You would typically pass the comments parsed by [[bibtex.parse]] in here.
 *
 * JabRef knows several group types, and this parser parses most, but not all of them:
 *
 * * independent group: the keys listed in the group are the entries that are considered to belong to it
 * * intersection: the keys listed in the group are considered to belong to the group if they're also in the parent group
 * * union: the keys listed in the group are considered to belong to the group, and also the keys that are in the parent group
 * * query: not supported by this parser
 */
function parse(comments) {
    const result = {
        root: [],
        groups: {},
        fileDirectory: '',
        version: '',
    };
    const levels = [];
    const decoded = {
        fileDirectory: null,
        groupsversion: null,
        groupstree: null,
        grouping: null,
    };
    for (const comment of comments) {
        for (const [meta, prefix] of Object.entries(prefixes)) {
            if (comment.startsWith(prefix)) {
                decoded[meta] = decode(comment.substring(prefix.length));
            }
        }
    }
    result.version = decoded.groupsversion && decoded.groupsversion[0];
    result.fileDirectory = decoded.fileDirectory && decoded.fileDirectory[0];
    for (const tree of ['groupstree', 'grouping']) {
        if (!decoded[tree])
            continue;
        for (const encoded of decoded[tree]) {
            const fields = decode(encoded);
            const level_type_name = decode(fields.shift(), ':');
            const m = /^([0-9]+) (.+)/.exec(level_type_name[0]);
            if (!m)
                break;
            const level = parseInt(m[1]);
            const type = m[2]; // test for StaticGroup?
            if (type === 'AllEntriesGroup')
                continue; // root
            const name = level_type_name[1];
            const intersection = decode(fields.shift())[0];
            const keys = tree === 'grouping' ? [] : fields.map(field => decode(field)[0]);
            const group = {
                name,
                entries: keys,
                groups: [],
            };
            result.groups[name] = result.groups[name] || group;
            if (levels.length < level) {
                levels.push(group);
            }
            else {
                levels[level - 1] = group;
            }
            if (level === 1) {
                result.root.push(group);
            }
            else {
                const parent = levels[level - 2];
                switch (intersection) {
                    case '0': // independent
                        break;
                    case '1': // intersect
                        group.entries = group.entries.filter(key => parent.entries.includes(key));
                        break;
                    case '2': // union
                        group.entries = group.entries.concat(parent.entries.filter(key => !group.entries.includes(key)));
                        break;
                }
                levels[level - 2].groups.push(group);
            }
        }
    }
    return result;
}
exports.parse = parse;

});

var bibtexParser = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.jabref = exports.chunker = exports.ast = exports.parse = void 0;



class ParserError extends Error {
    constructor(message, node) {
        super(message); // 'Error' breaks prototype chain here
        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
        this.name = this.constructor.name;
        this.node = node;
    }
}
class TeXError extends Error {
    constructor(message, node, text) {
        super(message); // 'Error' breaks prototype chain here
        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
        this.name = this.constructor.name;
        this.node = node;
        this.text = text;
    }
}

const charClass = {
    Lu: categories.filter(cat => ['Uppercase_Letter', 'Titlecase_Letter'].includes(cat.alias)).map(cat => cat.bmp).join(''),
    Ll: categories.find(cat => cat.alias === 'Lowercase_Letter').bmp,
    LnotLu: categories.filter(cat => ['Lowercase_Letter', 'Modifier_Letter', 'Other_Letter', 'Nonspacing_Mark', 'Spacing_Mark', 'Decimal_Number', 'Letter_Number'].includes(cat.alias)).map(cat => cat.bmp).join(''),
    P: categories.find(cat => cat.alias === 'Punctuation').bmp,
    L: categories.find(cat => cat.alias === 'Letter').bmp,
    N: categories.filter(cat => ['Decimal_Number', 'Letter_Number'].includes(cat.alias)).map(cat => cat.bmp).join(''),
    AlphaNum: categories.filter(cat => ['Letter', 'Decimal_Number', 'Letter_Number'].includes(cat.alias)).map(cat => cat.bmp).join(''),
    LC: categories.find(cat => cat.alias === 'Cased_Letter').bmp,
};
const marker = {
    and: '\u0001',
    comma: '\u0002',
    space: '\u0003',
    literal: '\u0004',
    markup: '\u0005',
    re: {
        and: /./,
        comma: /./,
        space: /./,
        literal: /./,
        literalName: /./,
    },
    clean(s) {
        return s.replace(marker.re.space, ' ').replace(marker.re.comma, ', ').replace(marker.re.literal, '');
    },
};
marker.re = {
    and: new RegExp(marker.and, 'g'),
    comma: new RegExp(marker.comma, 'g'),
    space: new RegExp(marker.space, 'g'),
    literal: new RegExp(marker.literal, 'g'),
    literalName: new RegExp(`^${marker.literal}([^${marker.literal}]*)${marker.literal}$`),
};
const preserveCase = {
    leadingCap: new RegExp(`^[${charClass.Lu}][${charClass.LnotLu}]+[${charClass.P}]?$`),
    allCaps: new RegExp(`^[${charClass.Lu}${charClass.N}]{2,}$`),
    allLower: new RegExp(`^[${charClass.Ll}${charClass.N}]{2,}$`),
    joined: new RegExp(`^[${charClass.Lu}][${charClass.LnotLu}]*([-+][${charClass.L}${charClass.N}]+)*[${charClass.P}]*$`),
    hasUpper: new RegExp(`[${charClass.Lu}]`),
    hasLower: new RegExp(`[${charClass.Ll}]`),
    isNumber: /^[0-9]+$/,
    hasAlpha: new RegExp(`[${charClass.L}]`),
    hasAlphaNum: new RegExp(`[${charClass.AlphaNum}]`),
    notAlphaNum: new RegExp(`[^${charClass.AlphaNum}]`, 'g'),
    sentenceStart: new RegExp(`(^|([\u2014:?!.]\\s+))[${charClass.Lu}]`, 'g'),
    markup: /<\/?span[^>]*>/g,
    acronym: new RegExp(`.*\\.${marker.markup}*[${charClass.Lu}]${marker.markup}*\\.$`),
    notCaseSensitive: new RegExp(`[^${charClass.LC}]`),
    isCaseSensitive: new RegExp(`[${charClass.LC}]`),
    quoted: /("[^"]+")|(“[^“]+“)/g,
};
const fields = {
    creator: [
        'author',
        'bookauthor',
        'collaborator',
        'commentator',
        'director',
        'editor',
        'editora',
        'editorb',
        'editors',
        'holder',
        'scriptwriter',
        'translator',
    ],
    title: [
        'title',
        'series',
        'shorttitle',
        'booktitle',
        'type',
        'origtitle',
        'maintitle',
        'eventtitle',
    ],
    unnest: [
        'publisher',
        'location',
    ],
    verbatim: [
        'url',
        'doi',
        'file',
        'files',
        'eprint',
        'verba',
        'verbb',
        'verbc',
        'groups',
    ],
    html: [
        'annotation',
        'comment',
        'annote',
        'review',
        'notes',
        'note',
    ],
    unabbrev: [
        'journal',
        'journaltitle',
        'journal-full',
    ],
};
const english = [
    'american',
    'british',
    'canadian',
    'english',
    'australian',
    'newzealand',
    'usenglish',
    'ukenglish',
    'en',
    'eng',
    'en-au',
    'en-bz',
    'en-ca',
    'en-cb',
    'en-gb',
    'en-ie',
    'en-jm',
    'en-nz',
    'en-ph',
    'en-tt',
    'en-us',
    'en-za',
    'en-zw',
    'anglais',
];
class Parser {
    constructor(options = {}) {
        this.in_preamble = false;
        this.preamble = [];
        this.log = function (str) { }; // tslint:disable-line variable-name only-arrow-functions no-empty
        for (const [option, value] of Object.entries(options)) {
            if (typeof value === 'undefined')
                delete options[option];
        }
        if (options.errorHandler === false) {
            // tslint:disable-next-line only-arrow-functions no-empty
            options.errorHandler = function (err) { };
        }
        else if (options.errorHandler === undefined) {
            // tslint:disable-next-line only-arrow-functions
            options.errorHandler = function (err) { throw err; };
        }
        if (typeof options.sentenceCase === 'boolean') {
            options.sentenceCase = options.sentenceCase ? english : [];
        }
        else {
            options.sentenceCase = options.sentenceCase || english;
        }
        if (!options.strings)
            options.strings = {};
        if (!options.unabbreviate)
            options.unabbreviate = {};
        if (options.raw) {
            options.sentenceCase = false;
            options.caseProtection = false;
        }
        this.options = Object.assign({ caseProtection: 'as-needed', verbatimFields: [/^citeulike-linkout-[0-9]+$/, ...fields.verbatim], verbatimCommands: ['url', 'href'], unnestFields: [...fields.title, ...fields.unnest, ...fields.verbatim], unnestMode: 'unwrap', htmlFields: fields.html, guessAlreadySentenceCased: true, markup: {} }, options);
        const markup_defaults = {
            enquote: { open: '\u201c', close: '\u201d' },
            sub: { open: '<sub>', close: '</sub>' },
            sup: { open: '<sup>', close: '</sup>' },
            bold: { open: '<b>', close: '</b>' },
            italics: { open: '<i>', close: '</i>' },
            smallCaps: { open: '<span style="font-variant:small-caps;">', close: '</span>' },
            caseProtect: { open: '<span class="nocase">', close: '</span>' },
            roman: { open: '', close: '' },
            fixedWidth: { open: '', close: '' },
        };
        // patch in because the options will likely not have enquote and case-protect
        for (const [markup, { open, close }] of Object.entries(markup_defaults)) {
            this.options.markup[markup] = this.options.markup[markup] || { open, close };
        }
        for (const i of [1, 2, 3, 4]) { // tslint:disable-line:no-magic-numbers
            this.options.markup[`h${i}`] = this.options.markup[`h${i}`] || { open: `<h${i}>`, close: `</h${i}>` };
        }
        this.unresolvedStrings = {};
        this.errors = [];
        this.comments = [];
        this.entries = [];
        this.strings = {};
        this.newcommands = {};
        this.default_strings = {
            JAN: [this.text('01')],
            FEB: [this.text('02')],
            MAR: [this.text('03')],
            APR: [this.text('04')],
            MAY: [this.text('05')],
            JUN: [this.text('06')],
            JUL: [this.text('07')],
            AUG: [this.text('08')],
            SEP: [this.text('09')],
            OCT: [this.text('10')],
            NOV: [this.text('11')],
            DEC: [this.text('12')],
            ACMCS: [this.text('ACM Computing Surveys')],
            ACTA: [this.text('Acta Informatica')],
            CACM: [this.text('Communications of the ACM')],
            IBMJRD: [this.text('IBM Journal of Research and Development')],
            IBMSJ: [this.text('IBM Systems Journal')],
            IEEESE: [this.text('IEEE Transactions on Software Engineering')],
            IEEETC: [this.text('IEEE Transactions on Computers')],
            IEEETCAD: [this.text('IEEE Transactions on Computer-Aided Design of Integrated Circuits')],
            IPL: [this.text('Information Processing Letters')],
            JACM: [this.text('Journal of the ACM')],
            JCSS: [this.text('Journal of Computer and System Sciences')],
            SCP: [this.text('Science of Computer Programming')],
            SICOMP: [this.text('SIAM Journal on Computing')],
            TOCS: [this.text('ACM Transactions on Computer Systems')],
            TODS: [this.text('ACM Transactions on Database Systems')],
            TOG: [this.text('ACM Transactions on Graphics')],
            TOMS: [this.text('ACM Transactions on Mathematical Software')],
            TOOIS: [this.text('ACM Transactions on Office Information Systems')],
            TOPLAS: [this.text('ACM Transactions on Programming Languages and Systems')],
            TCS: [this.text('Theoretical Computer Science')],
        };
    }
    ast(input, clean = true) {
        const _ast = [];
        for (const chunk of chunker.parse(input)) {
            let chunk_ast = grammar.parse(chunk.text, Object.assign(Object.assign({}, this.options), { combiningDiacritics: unicode2latex.diacritics.commands }));
            if (clean)
                chunk_ast = this.clean(chunk_ast);
            _ast.push(chunk_ast);
        }
        return _ast;
    }
    parse(input) {
        return this.options.async ? this.parseAsync(input) : this.parseSync(input);
    }
    parseSync(input) {
        for (const chunk of chunker.parse(input)) {
            this.parseChunk(chunk);
        }
        return this.parsed();
    }
    async parseAsync(input) {
        for (const chunk of await chunker.parse(input, { async: true })) {
            this.parseChunk(chunk);
        }
        return this.parsed();
    }
    parsed() {
        this.field = null;
        const strings = {};
        this.cleaning = { type: 'other' };
        for (const [key, value] of Object.entries(this.strings)) {
            this.field = {
                name: '@string',
                text: '',
                level: 0,
                preserveRanges: null,
                words: {
                    upper: 0,
                    lower: 0,
                    other: 0,
                },
            };
            this.convert(this.clean(value));
            strings[key] = this.field.text;
        }
        return {
            errors: this.errors,
            entries: this.entries,
            comments: this.comments,
            strings,
            preamble: this.preamble,
        };
    }
    preserve(start, end, reason) {
        if (!this.field.preserveRanges)
            return;
        if (!end) {
            this.field.preserveRanges = null;
            return;
        }
        /*
        this.field.preserveRanges = this.field.preserveRanges.filter(range => range.start < start || range.end > end)
        if (this.field.preserveRanges.find(range => range.start <= start && range.end >= end)) return
        */
        /*
        if (this.field.preserveRanges && this.field.preserveRanges.length) {
          const last = this.field.preserveRanges[this.field.preserveRanges.length - 1]
          if (start < last.start) throw new Error(JSON.stringify({...last, new: { start, end, reason }, text: this.field.text}))
        }
        */
        this.field.preserveRanges.push({ start, end, reason });
    }
    parseChunk(chunk) {
        this.chunk = chunk.text;
        try {
            let bib = grammar.parse(chunk.text, Object.assign(Object.assign({}, this.options), { combiningDiacritics: unicode2latex.diacritics.commands }));
            if (bib.kind !== 'Bibliography')
                throw new Error(this.show(bib));
            bib = this.clean(bib);
            for (const entity of bib.children) {
                switch (entity.kind) {
                    case 'Entry':
                    case 'BracedComment':
                    case 'LineComment':
                    case 'PreambleExpression':
                        this.convert(entity);
                        break;
                    case 'StringDeclaration':
                    case 'NonEntryText':
                        break;
                }
            }
            return bib;
        }
        catch (err) {
            if (!err.location)
                throw err;
            this.errors.push({
                message: err.message,
                line: err.location.start.line + chunk.offset.line,
                column: err.location.start.column,
                source: this.chunk,
            });
            return null;
        }
    }
    show(o) {
        // tslint:disable-next-line prefer-template
        let text = JSON.stringify(o);
        if (this.chunk)
            text += '\n' + this.chunk.trim();
        return text;
    }
    text(value = '') {
        return { kind: 'Text', value, mode: 'text' };
    }
    error(err, returnvalue) {
        if (typeof this.options.errorHandler === 'function')
            this.options.errorHandler(err);
        return returnvalue;
    }
    condense(node) {
        // apply cleaning to resulting children
        node.value = node.value.map(child => this.clean(child));
        // unpack redundant blocks
        node.value = node.value.reduce((acc, child, i) => {
            if (child.kind === 'Block' && !child.case && Object.keys(child.markup).length === 0) {
                acc = acc.concat(child.value);
            }
            else {
                acc.push(child);
            }
            return acc;
        }, []);
        // condense text nodes to make whole words for sentence casing
        node.value = node.value.reduce((acc, child, i) => {
            if (acc.length === 0) {
                acc.push(child);
                return acc;
            }
            const last = acc[acc.length - 1];
            const next = node.value[i + 1];
            if (this.options.caseProtection === 'strict' && this.onlyCaseProtected(last) && child.kind === 'Text' && !child.value.match(preserveCase.isCaseSensitive) && this.onlyCaseProtected(next)) {
                last.value.push(child);
                delete last.source;
                return acc;
            }
            if (last.kind === 'Block' && child.kind === 'Block' && Object.keys(last.markup).sort().join('/') === Object.keys(child.markup).sort().join('/')) {
                last.value = last.value.concat(child.value);
                delete last.source;
                return acc;
            }
            if (last.kind === 'Text' && child.kind === 'Text' && last.mode === child.mode) {
                last.value += child.value;
                delete last.source;
                return acc;
            }
            acc.push(child);
            return acc;
        }, []);
    }
    onlyCaseProtected(node) {
        return (node === null || node === void 0 ? void 0 : node.kind) === 'Block' && node.case === 'protect' && Object.keys(node.markup).join('/') === '';
    }
    argument(node, kind) {
        if (!node.arguments || !node.arguments.required.length)
            return (kind === 'none');
        // expect 'n' text arguments
        if (typeof kind === 'number') {
            if (node.arguments.required.length !== kind)
                return false;
            return node.arguments.required;
        }
        // return first argument if it's the only one
        if (node.arguments.required.length !== 1)
            return false;
        // loose checking for text
        if (kind === 'text') {
            const first = node.arguments.required[0];
            if (first.kind === 'Block' && first.value.length === 1) {
                if (first.value[0].kind === 'Text')
                    return first.value[0].value;
            }
            // fall back to strict kind check
            kind = 'Text';
        }
        // return first argument if it's the only one and is of the specified kind
        if (node.arguments.required.length !== 1 || node.arguments.required[0].kind !== kind)
            return false;
        switch (kind) {
            case 'Text':
                return node.arguments.required[0].value;
            case 'RegularCommand':
            case 'Block':
                return node.arguments.required[0];
        }
        return false;
    }
    clean(node) {
        if (Array.isArray(node))
            return node.map(child => this.clean(child));
        delete node.loc;
        switch (node.kind) {
            case 'InlineMath':
            case 'DisplayMath':
                return this.clean_block(node);
            case 'Environment':
                return this.clean_environment(node);
            case 'Block':
                return this.clean_block(node);
            case 'Bibliography':
                return this.clean_bib(node);
            case 'RegularCommand':
                return this.clean_command(node);
            case 'DiacriticCommand':
                return this.clean_diacritic(node);
            case 'Entry':
                return this.clean_entry(node);
            case 'Field':
                return this.options.raw ? node : this.clean_field(node);
            case 'StringDeclaration':
                return this.clean_stringdecl(node);
            case 'StringReference':
                return this.clean_stringref(node);
            case 'SubscriptCommand':
            case 'SuperscriptCommand':
                return this.clean_script(node);
            case 'SymbolCommand':
                return this.clean_symbol(node);
            case 'PreambleExpression':
                return this.clean_preamble(node);
            case 'Number':
            case 'Text':
            case 'BracedComment':
            case 'LineComment':
                return node;
            default:
                return this.error(new ParserError(`no cleanup method for ${this.show(node)}`, node), this.text());
        }
    }
    clean_preamble(node) {
        this.in_preamble = true;
        const clean = this.clean(node.value);
        this.in_preamble = false;
        return clean;
    }
    clean_bib(node) {
        node.children = node.children.filter(child => child.kind !== 'NonEntryText').map(child => this.clean(child));
        return node;
    }
    clean_stringdecl(node) {
        this.strings[node.name.toUpperCase()] = node.value;
        return node;
    }
    clean_stringref(node) {
        var _a;
        const name = node.name.toUpperCase();
        const _string = this.strings[name]
            || this.options.strings[name]
            || this.default_strings[name]
            || (fields.unabbrev.includes(this.cleaning.name) && ((_a = this.options.unabbreviate[name]) === null || _a === void 0 ? void 0 : _a.text) && [this.text(this.options.unabbreviate[name].text)]);
        if (!_string) {
            if (!this.unresolvedStrings[name])
                this.errors.push({ message: `Unresolved @string reference ${JSON.stringify(node.name)}` });
            this.unresolvedStrings[name] = true;
        }
        return this.clean({
            kind: 'Block',
            // if the string isn't found, add it as-is but exempt it from sentence casing
            case: _string ? undefined : 'preserve',
            markup: {},
            value: _string ? JSON.parse(JSON.stringify(_string)) : [this.text(node.name)],
        });
    }
    clean_entry(node) {
        const shortjournals = [];
        for (const field of node.fields) {
            if (fields.unabbrev.includes(field.name) && Array.isArray(field.value)) {
                const abbr = field.value.map(v => v.source).join('');
                const journal = this.options.unabbreviate[abbr];
                if (journal) {
                    shortjournals.push(Object.assign(Object.assign({}, JSON.parse(JSON.stringify(field))), { name: 'shortjournal' }));
                    field.value = JSON.parse(JSON.stringify(journal.ast));
                }
            }
        }
        node.fields = node.fields.concat(shortjournals).map(child => this.clean(child));
        return node;
    }
    startCleaning(name) {
        name = name.toLowerCase();
        if (fields.title.includes(name)) {
            this.cleaning = { type: 'title', name };
        }
        else if (fields.creator.includes(name.replace(/s$/, ''))) {
            this.cleaning = { type: 'creator', name: name.replace(/s$/, '') };
        }
        else {
            this.cleaning = { type: 'other', name };
        }
    }
    stripNoCase(node, strip, preserve) {
        switch (node.kind) {
            case 'RegularCommand':
                // a bit cheaty to assume these to be nocased, but it's just more likely to be what people want
                if (['chsf', 'bibstring', 'cite'].includes(node.command))
                    strip = true;
                node.arguments.required.map(arg => this.stripNoCase(arg, strip, preserve));
                break;
            case 'Block':
            case 'InlineMath':
            case 'DisplayMath':
                if (strip && node.case === 'protect') {
                    if (preserve) {
                        node.case = 'preserve';
                    }
                    else {
                        delete node.case;
                    }
                }
                node.value.map(v => this.stripNoCase(v, strip || node.case === 'protect', preserve));
                break;
            case 'Field':
                if (Array.isArray(node.value))
                    node.value.map(v => this.stripNoCase(v, strip, preserve));
                break;
        }
    }
    isVerbatimField(name) {
        return !!this.options.verbatimFields.find(p => (typeof p === 'string') ? name === p : name.match(p));
    }
    clean_field(node) {
        this.startCleaning(node.name);
        this.stripNoCase(node, !this.options.caseProtection || this.isVerbatimField(node.name), this.options.sentenceCase.length === 0);
        if (Array.isArray(node.value))
            this.condense(node);
        return node;
    }
    clean_script(node) {
        let m, value, singlechar;
        // recognize combined forms like \^\circ
        if (singlechar = unicode2latex.latex[node.source])
            return this.text(singlechar);
        if ((m = node.source.match(/^([\^_])([^{}]+)$/)) && ((singlechar = unicode2latex.latex[`${m[1]}${m[2]}`]) || (singlechar = unicode2latex.latex[`${m[1]}{${m[2]}}`])))
            return this.text(singlechar);
        if ((m = node.source.match(/^([\^_])\{([^{}]+)\}$/)) && ((singlechar = unicode2latex.latex[`${m[1]}${m[2]}`]) || (singlechar = unicode2latex.latex[`${m[1]}{${m[2]}}`])))
            return this.text(singlechar);
        const cmd = node.kind === 'SuperscriptCommand' ? '^' : '_';
        if (typeof node.value === 'string' && (singlechar = unicode2latex.latex[`${cmd}${node.value}`] || unicode2latex.latex[`${cmd}{${node.value}}`])) {
            return this.text(singlechar);
        }
        if (typeof node.value === 'string') {
            value = [this.text(node.value)];
        }
        else if (!Array.isArray(node.value)) {
            value = [node.value];
        }
        else {
            value = node.value;
        }
        const mode = node.kind === 'SuperscriptCommand' ? 'sup' : 'sub';
        return this.clean({
            kind: 'Block',
            markup: { [mode]: true },
            value,
        });
    }
    clean_environment(node) {
        this.condense(node);
        return node;
    }
    needsProtection(word) {
        return !word.match(preserveCase.hasUpper) && word.match(preserveCase.hasLower);
    }
    clean_block(node) {
        var _a;
        this.condense(node);
        if (this.options.caseProtection !== 'strict' && ((_a = this.cleaning) === null || _a === void 0 ? void 0 : _a.type) === 'title' && node.case === 'protect') {
            // test whether we can get away with skipping case protection because it contains all words that will be preserved anyway when converting back to Title Case
            let preserve = true;
            for (const child of node.value) {
                if (child.kind === 'Text') {
                    const value = child.value.trim();
                    preserve = !value.match(preserveCase.isCaseSensitive) || !value.split(/\s+/).find(word => this.needsProtection(word));
                }
                else {
                    preserve = false;
                }
                if (!preserve)
                    break;
            }
            if (preserve)
                node.case = 'preserve';
        }
        if (node.kind === 'Block') {
            for (const [markup, on] of Object.entries(node.markup)) {
                if (!on)
                    delete node.markup[markup];
            }
        }
        return node;
    }
    clean_diacritic(node) {
        const char = node.dotless ? `\\${node.character}` : node.character;
        let unicode = unicode2latex.latex[`\\${node.mark}{${char}}`]
            || unicode2latex.latex[`\\${node.mark}${char}`]
            || unicode2latex.latex[`{\\${node.mark} ${char}}`]
            || unicode2latex.latex[`{\\${node.mark}${char}}`]
            || unicode2latex.latex[`\\${node.mark} ${char}`];
        if (!unicode && !node.dotless && node.character.length === 1 && unicode2latex.diacritics.tounicode[node.mark])
            unicode = node.character + unicode2latex.diacritics.tounicode[node.mark];
        if (!unicode && !this.in_preamble)
            return this.error(new TeXError(`Unhandled \\${node.mark}{${char}}`, node, this.chunk), this.text());
        return this.text(unicode);
    }
    clean_symbol(node) {
        if (node.command === '\\')
            return this.text('\n');
        return this.text(unicode2latex.latex[`\\${node.command}`] || node.command);
    }
    first_text_block(node) {
        if (!node)
            return null;
        if (node.kind === 'Block') {
            for (const child of node.value) {
                switch (child.kind) {
                    case 'Text':
                        return child.value ? node : null;
                    case 'Block':
                        const candidate = this.first_text_block(child);
                        if (candidate)
                            return candidate;
                        break;
                    default:
                        return null;
                }
            }
        }
        else {
            return null;
        }
    }
    clean_command(node) {
        var _a;
        let arg, unicode;
        if (unicode = unicode2latex.latex[node.source])
            return this.text(unicode);
        switch (node.command) {
            case 'newcommand':
                if (((_a = node.arguments) === null || _a === void 0 ? void 0 : _a.required.length) === 2
                    && node.arguments.required[0].kind === 'Block'
                    && node.arguments.required[0].value.length === 1
                    && node.arguments.required[0].value[0].kind === 'RegularCommand'
                    && node.arguments.required[1].kind === 'Block') {
                    this.newcommands[node.arguments.required[0].value[0].command] = node.arguments.required[1].value;
                    return this.text();
                }
                // console.log('newcommand?', JSON.stringify(node, null, 2))
                break;
            case 'item':
                return { kind: 'Markup', value: '<li>', source: node.source };
            case 'frac':
                if (arg = this.argument(node, 2)) {
                    if (arg[0].kind === 'Text' && arg[1].kind === 'Text' && (unicode = unicode2latex.latex[`\\frac{${arg[0].value}}{${arg[1].value}}`]))
                        return this.text(unicode);
                    return this.clean({
                        kind: 'Block',
                        case: 'protect',
                        markup: {},
                        value: [
                            { kind: 'Block', markup: { sup: true }, value: [arg[0]] },
                            this.text('\u2044'),
                            { kind: 'Block', markup: { sub: true }, value: [arg[1]] },
                        ],
                    });
                }
                break;
            // ignore
            case 'vspace':
            case 'vphantom':
            case 'path':
            case 'aftergroup':
            case 'ignorespaces':
            case 'relax':
            case 'noopsort':
            case 'ifdefined':
            case 'DeclarePrefChars':
            case 'else':
            case 'fi':
            case 'makeatletter':
                return this.text();
            case 'ElsevierGlyph':
                if (arg = this.argument(node, 'Text')) {
                    if (unicode = unicode2latex.latex[`\\${node.command}{${arg}}`])
                        return this.text(unicode);
                    return this.text(String.fromCharCode(parseInt(arg, 16)));
                }
                break;
            case 'chsf':
                if (this.argument(node, 'none'))
                    return this.text();
                if (arg = this.argument(node, 'Block'))
                    return this.clean(arg);
                break;
            case 'bibstring':
                if (arg = this.argument(node, 'Block'))
                    return this.clean(arg);
                break;
            case 'cite':
                if (arg = this.argument(node, 'Block'))
                    return this.clean(arg);
                break;
            case 'textsuperscript':
            case 'sp':
                if ((arg = this.argument(node, 'Text')) && (unicode = unicode2latex.latex[`^{${arg}}`]))
                    return this.text(unicode);
                if (arg = this.argument(node, 'Block'))
                    return this.clean(arg);
                break;
            case 'textsubscript':
            case 'sb':
                if ((arg = this.argument(node, 'Text')) && (unicode = unicode2latex.latex[`_{${arg}}`]))
                    return this.text(unicode);
                if (arg = this.argument(node, 'Block'))
                    return this.clean(arg);
                break;
            case 'textsc':
                if (arg = this.argument(node, 'Block'))
                    return this.clean(arg);
                break;
            case 'enquote':
            case 'mkbibquote':
                if (arg = this.argument(node, 'Block'))
                    return this.clean(arg);
                break;
            case 'textbf':
            case 'mkbibbold':
                if (arg = this.argument(node, 'Block'))
                    return this.clean(arg);
                break;
            case 'section':
            case 'subsection':
            case 'subsubsection':
            case 'subsubsubsection':
                if (arg = this.argument(node, 'Block'))
                    return this.clean(arg);
                break;
            case 'mkbibitalic':
            case 'mkbibemph':
            case 'textit':
            case 'emph':
                if (arg = this.argument(node, 'Block'))
                    return this.clean(arg);
                if (arg = this.argument(node, 'Text'))
                    return this.clean({ kind: 'Block', markup: { italics: true }, value: [this.text(arg)] });
                break;
            case 'bibcyr':
                if (this.argument(node, 'none'))
                    return this.text();
                if (arg = this.argument(node, 'Block'))
                    return this.clean(arg);
                break;
            case 'hspace':
            case 'mathrm':
            case 'textrm':
            case 'ocirc':
            case 'mbox':
                if (arg = this.argument(node, 'text')) {
                    unicode = unicode2latex.latex[`\\${node.command}{${arg}}`];
                    return this.text(unicode || (node.command === 'hspace' ? ' ' : arg));
                }
                else if (!node.arguments.required.length) {
                    return this.text();
                }
                else if (arg = this.argument(node, 'Block')) {
                    return this.clean(arg);
                }
                break;
            // just take the URL? Not the label?
            case 'href':
                if (arg = this.argument(node, 2))
                    return this.clean(arg[0]);
                break;
            case 'url':
                if (arg = this.argument(node, 'Text'))
                    return this.text(arg);
                if (arg = this.argument(node, 'Block'))
                    return this.clean(arg);
                break;
            case 'sl':
            case 'em':
            case 'it':
            case 'itshape':
            case 'bf':
            case 'bfseries':
            case 'sc':
            case 'scshape':
            case 'tt':
            case 'rm':
            case 'sf':
            case 'verb':
                // handled in the grammar
                return this.text();
            // wouldn't know what to do with these
            case 'left':
            case 'right':
                return this.text();
            case 'par':
                return this.text('\n\n');
            case 'cyr':
                if (this.argument(node, 'none'))
                    return this.text();
                break;
            case 'polhk':
                if (unicode = this.argument(node, 'text')) {
                    if (unicode.length === 1)
                        return this.text(unicode + '\u0328');
                }
                if (this.argument(node, 'none'))
                    return this.text('\u0328');
                break;
            default:
                if (node.kind === 'RegularCommand' && this.newcommands[node.command]) {
                    return this.clean({
                        kind: 'Block',
                        markup: {},
                        value: JSON.parse(JSON.stringify(this.newcommands[node.command])),
                    });
                }
                if (unicode2latex.diacritics.tounicode[node.command]) {
                    node.arguments.required = this.clean(node.arguments.required);
                    let block;
                    if (node.arguments.required.length === 1 && node.arguments.required[0].kind === 'Text') {
                        // no idea why I can't just straight return this but typescript just won't shut up
                        block = {
                            kind: 'Block',
                            markup: {},
                            value: [{
                                    kind: 'DiacriticCommand',
                                    mark: node.command,
                                    character: node.arguments.required[0].value,
                                    dotless: false,
                                    loc: node.arguments.required[0].loc,
                                    source: node.arguments.required[0].source,
                                }],
                        };
                        return this.clean(block);
                    }
                    else if (block = this.first_text_block(node.arguments.required[0])) {
                        let fixed = false;
                        block.value = block.value.reduce((value, child) => {
                            if (!fixed && child.kind === 'Text') {
                                fixed = true;
                                value.push({ kind: 'DiacriticCommand', mark: node.command, character: child.value[0] });
                                value.push(Object.assign(Object.assign({}, child), { value: child.value.substring(1) }));
                            }
                            else {
                                value.push(child);
                            }
                            return value;
                        }, []);
                        return this.clean({
                            kind: 'Block',
                            markup: {},
                            value: node.arguments.required,
                        });
                    }
                    else {
                        // overline without arguments doesn't seem to render in LaTeX
                        if (node.command === 'overline')
                            return this.text(' ');
                        return this.clean({
                            kind: 'Block',
                            markup: {},
                            value: [this.text(' ' + unicode2latex.diacritics.tounicode[node.command])].concat(node.arguments.required),
                        });
                    }
                }
                if (unicode = unicode2latex.latex[node.source] || unicode2latex.latex[`${node.source}{}`])
                    return this.text(unicode);
                if ((unicode = unicode2latex.latex[`\\${node.command}`] || unicode2latex.latex[`\\${node.command}{}`]) && this.argument(node, 'none'))
                    return this.text(unicode);
                if ((arg = this.argument(node, 'Text')) && (unicode = unicode2latex.latex[`\\${node.command}{${arg}}`]))
                    return this.text(unicode);
                break;
        }
        if (this.in_preamble)
            return this.text(node.source);
        return this.error(new TeXError(`Unhandled command: ${node.command}` + this.show(node), node, this.chunk), this.text());
    }
    preserveCase(word) {
        // word = word.replace(new RegExp(`"[${this.markup.enquote.open}${this.markup.enquote.close}:()]`, 'g'), '')
        var _a, _b;
        if (!word.trim())
            return false;
        if (!word.match(preserveCase.hasAlphaNum))
            return true;
        word = word.replace(/[\/’'”:()]/g, '');
        if (word === 'I')
            return true;
        if (word.length === 1)
            return false;
        if (word.replace(preserveCase.notCaseSensitive) === '')
            return false;
        // word = word.replace(preserveCase.notAlphaNum, '')
        // simple cap at start of field
        if (word.match(preserveCase.leadingCap) && ((_b = (_a = this.field) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.length) === 0)
            return false;
        if (word.match(preserveCase.allCaps))
            return true;
        if (word.length > 1 && word.match(preserveCase.joined))
            return false;
        if (word.match(preserveCase.hasUpper))
            return true;
        if (word.match(preserveCase.isNumber))
            return true;
        return false;
    }
    convert(node) {
        if (Array.isArray(node))
            return node.map(child => this.convert(child));
        if (this.options.raw && this.field)
            node = this.text(node.source);
        switch (node.kind) {
            case 'Markup':
                if (this.field)
                    this.field.text += node.value;
                break;
            case 'BracedComment':
            case 'LineComment':
                this.comments.push(node.value);
                break;
            case 'Entry':
                this.convert_entry(node);
                break;
            case 'Number':
                this.convert_number(node);
                break;
            case 'Text':
                this.convert_text(node);
                break;
            case 'Block':
            case 'InlineMath':
            case 'DisplayMath':
                const start = this.field ? this.field.text.length : null;
                const preserve = typeof start === 'number' && this.field.preserveRanges;
                this.convert_block(node);
                if (preserve && (node.case || node.kind.endsWith('Math')))
                    this.preserve(start, this.field.text.length); // , `convert-block: case=${node.case}, math=${node.kind.endsWith('Math')}`)
                break;
            case 'Environment':
                this.convert_environment(node);
                break;
            case 'PreambleExpression':
                this.preamble.push(node.value.map(preamble => preamble.source).join('\n\n'));
                break;
            case 'DisplayMath':
            case 'InlineMath':
            case 'StringDeclaration':
                break;
            default:
                return this.error(new ParserError(`no converter for ${node.kind}: ${this.show(node)}`, node), undefined);
        }
    }
    splitOnce(s, sep, fromEnd = false) {
        const split = fromEnd ? s.lastIndexOf(sep) : s.indexOf(sep);
        return (split < 0) ? [s, ''] : [s.substr(0, split), s.substr(split + 1)];
    }
    parseName(name) {
        let parsed = null;
        const parts = name.split(marker.comma);
        if (parts.length && !parts.find(p => !p.match(/^[a-z]+(-i)?=/i))) { // extended name format
            for (const part of parts) {
                parsed = parsed || {};
                const [attr, value] = this.splitOnce(part.replace(marker.re.space, ''), '=').map(v => v.trim());
                if (!value) {
                    parsed = null;
                    break;
                }
                switch (attr.toLowerCase()) {
                    case 'family':
                        parsed.lastName = value;
                        break;
                    case 'given-i':
                        parsed.initial = value;
                        break;
                    case 'given':
                        parsed.firstName = value;
                        break;
                    case 'prefix':
                        parsed.prefix = value;
                        break;
                    case 'suffix':
                        parsed.suffix = value;
                        break;
                    case 'useprefix':
                        parsed.useprefix = value.toLowerCase() === 'true';
                        break;
                    case 'juniorcomma':
                        parsed.useprefix = value.toLowerCase() === 'true';
                        break;
                    default:
                        parsed[attr.toLowerCase()] = value;
                        break;
                }
            }
        }
        const prefix = /(.+?)\s+(vere|von|van den|van der|van|de|del|della|der|di|da|pietro|vanden|du|st.|st|la|lo|ter|bin|ibn|te|ten|op|ben|al)\s+(.+)/;
        let m;
        switch (parsed ? 0 : parts.length) {
            case 0:
                // already parsed
                break;
            case 1: // name without commas
                // literal
                if (marker.re.literalName.test(parts[0])) {
                    parsed = { literal: parts[0] };
                }
                else if (m = parts[0].replace(marker.re.space, ' ').match(prefix)) { // split on prefix
                    parsed = {
                        firstName: m[1],
                        prefix: m[2],
                        lastName: m[3],
                    };
                }
                else {
                    // top-level "firstname lastname"
                    const [firstName, lastName] = this.splitOnce(parts[0], marker.space, true);
                    if (lastName) {
                        parsed = { firstName, lastName };
                    }
                    else {
                        parsed = { lastName: firstName };
                    }
                }
                break;
            case 2: // lastname, firstname
                parsed = {
                    lastName: parts[0],
                    firstName: parts[1],
                };
                break;
            default: // lastname, suffix, firstname
                parsed = {
                    lastName: parts[0],
                    suffix: parts[1],
                    firstName: parts.slice(2).join(marker.comma),
                };
        }
        for (const [k, v] of Object.entries(parsed)) {
            if (typeof v !== 'string')
                continue;
            parsed[k] = marker.clean(v).trim();
        }
        return parsed;
    }
    convert_entry(node) {
        var _a;
        this.entry = {
            key: node.id,
            type: node.type,
            fields: {},
            creators: {},
        };
        this.entries.push(this.entry);
        // order these first for language-dependent sentence casing
        const order = ['langid', 'hyphenation', 'language'];
        node.fields.sort((a, b) => {
            const ia = order.indexOf(a.name);
            const ib = order.indexOf(b.name);
            if (ia === -1 && ib === -1)
                return a.name.localeCompare(b.name); // doesn't matter really
            if (ia === -1)
                return 1;
            if (ib === -1)
                return -1;
            return ia - ib;
        });
        let sentenceCase = !!this.options.sentenceCase.length; // if sentenceCase is empty, no sentence casing
        for (const field of node.fields) {
            if (field.kind !== 'Field')
                return this.error(new ParserError(`Expected Field, got ${field.kind}`, node), undefined);
            this.startCleaning(field.name);
            /*
            if (this.options.raw && this.fieldType !== 'creator') {
              this.entry.fields[field.name] = [ field.value.map(v => v.source).join('') ]
              continue
            }
            */
            this.field = {
                name: field.name,
                text: '',
                level: 0,
                words: {
                    upper: 0,
                    lower: 0,
                    other: 0,
                },
                preserveRanges: (sentenceCase && fields.title.includes(field.name)) ? [] : null,
                html: this.options.htmlFields.includes(field.name),
            };
            this.entry.fields[this.field.name] = this.entry.fields[this.field.name] || [];
            // special case for 'title = 2020'
            if (field.value.kind === 'Number') {
                this.entry.fields[this.field.name].push(field.value.value);
                this.field = null;
                continue;
            }
            this.convert(field.value);
            this.field.text = this.field.text.trim();
            this.field.text = this.field.text.replace(/<\/([a-z])><\1>/g, '');
            this.field.text = this.field.text.replace(/<([a-z])>(\s*)<\/\1>/g, '$1');
            if (!this.field.text)
                continue;
            // disable sentenceCasing if not an english
            switch (this.field.name) {
                case 'langid':
                case 'hyphenation':
                    sentenceCase = sentenceCase && this.options.sentenceCase.includes(this.field.text.toLowerCase());
                    break;
                case 'language':
                    sentenceCase = sentenceCase && !!(this.field.text.toLowerCase().trim().split(/\s*,\s*/).find(lang => this.options.sentenceCase.includes(lang)));
                    break;
            }
            // "groups" is a jabref 3.8+ monstrosity
            if (this.field.name.match(/^(keywords?|groups)$/)) {
                for (let text of this.field.text.split(marker.comma)) {
                    text = text.trim();
                    if (text)
                        this.entry.fields[this.field.name].push(text);
                }
            }
            else if (this.cleaning.type === 'creator') {
                if (!this.entry.creators[this.field.name])
                    this.entry.creators[this.field.name] = [];
                // {M. Halle, J. Bresnan, and G. Miller}
                if (this.field.text.includes(`${marker.comma}${marker.and}`)) { //
                    this.field.text = this.field.text.replace(new RegExp(`${marker.comma}${marker.and}`, 'g'), marker.and).replace(new RegExp(marker.comma), marker.and);
                }
                for (const creator of this.field.text.split(marker.and)) {
                    this.entry.fields[this.field.name].push(marker.clean(creator));
                    this.entry.creators[this.field.name].push(this.parseName(creator));
                }
            }
            else if (fields.unabbrev.includes(field.name)) { // doesn't get sentence casing anyhow TODO: booktitle does!
                this.entry.fields[this.field.name].push((((_a = this.options.unabbreviate[this.field.text]) === null || _a === void 0 ? void 0 : _a.text) || this.field.text).normalize('NFC'));
            }
            else {
                if (this.field.preserveRanges) {
                    if (this.options.guessAlreadySentenceCased && Math.max(this.field.words.upper, this.field.words.lower) > (this.field.words.other + Math.min(this.field.words.upper, this.field.words.lower))) {
                        this.preserve(null, null); // , 'mostly sentence cased already')
                    }
                    else {
                        const txt = this.field.text.replace(preserveCase.markup, markup => marker.markup.repeat(markup.length));
                        let match;
                        preserveCase.sentenceStart.lastIndex = 0;
                        while ((match = preserveCase.sentenceStart.exec(txt))) {
                            // exclude stuff like "U.S. Taxes"
                            if (match.index > 2 && txt.substr(0, match.index + 1).match(preserveCase.acronym))
                                continue;
                            this.preserve(match.index, match.index + match[0].length); // , `sentenceStart: ${match[0]} at ${match.index}..${match.index + match[0].length}`)
                        }
                        preserveCase.quoted.lastIndex = 0;
                        while ((match = preserveCase.quoted.exec(this.field.text))) {
                            this.preserve(match.index, match.index + match[0].length); // , 'quoted')
                        }
                    }
                }
                this.entry.fields[this.field.name].push(this.convertToSentenceCase(this.field.text).normalize('NFC'));
            }
        }
        this.field = null;
    }
    convertToSentenceCase(text) {
        if (!this.field.preserveRanges)
            return text;
        // always keep the leading char, but skip markup
        const lead = text.match(/^(<[^>]+>)*./);
        if (lead) {
            this.preserve(lead[0].length - 1, lead[0].length);
        }
        else {
            this.preserve(0, 1);
        }
        let sentenceCased = text.toLowerCase().replace(/(([\?!]\s*|^)([\'\"¡¿“‘„«\s]+)?[^\s])/g, x => x.toUpperCase());
        for (const { start, end } of this.field.preserveRanges) {
            sentenceCased = sentenceCased.substring(0, start) + text.substring(start, end) + sentenceCased.substring(end);
        }
        if (text !== sentenceCased)
            this.entry.sentenceCased = true;
        return sentenceCased;
    }
    convert_number(node) {
        this.field.text += `${node.value}`;
    }
    convert_text(node) {
        if (node.mode === 'verbatim') {
            this.field.text += node.value.trim();
            return;
        }
        // heuristic to detect pre-sentencecased text
        for (const word of node.value.split(/\b/)) {
            if (word.match(preserveCase.allLower)) {
                this.field.words.lower++;
            }
            else if (word.match(preserveCase.allCaps)) {
                this.field.words.upper++;
            }
            else if (word.match(preserveCase.hasAlpha)) {
                this.field.words.other++;
            }
        }
        if (this.field.level === 0 && this.cleaning.type === 'creator') {
            this.field.text += node.value.replace(/\s+and\s+/ig, marker.and).replace(/\s*,\s*/g, marker.comma).replace(/\s+/g, marker.space);
            return;
        }
        if (this.field.level === 0 && this.field.name.match(/^(keywords?|groups)$/)) {
            this.field.text += node.value.replace(/\s*[;,]\s*/g, marker.comma);
            return;
        }
        if (this.field.html) {
            this.field.text += node.value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
        }
        else if (this.field.preserveRanges) {
            const words = node.value.split(/(\s+)/);
            for (const word of words) {
                const start = this.field.text.length;
                this.field.text += word;
                if (this.preserveCase(word))
                    this.preserve(start, this.field.text.length); // , `word: ${JSON.stringify(word)}`)
            }
        }
        else {
            this.field.text += node.value;
        }
    }
    convert_environment(node) {
        this.field.text += { enumerate: '<ol>', itemize: '<ul>' }[node.env];
        this.convert_block(Object.assign(Object.assign({}, node), { kind: 'Block', markup: {} }));
        this.field.text += { enumerate: '</ol>', itemize: '</ul>' }[node.env];
    }
    convert_block(node) {
        const start = this.field.text.length;
        let prefix = '';
        let postfix = '';
        if (this.options.caseProtection !== 'strict' && this.cleaning.type === 'other')
            delete node.case;
        if (this.cleaning.type === 'creator' && node.case === 'protect') {
            prefix += marker.literal;
            postfix = marker.literal + postfix;
            delete node.case;
        }
        if (node.case === 'protect') {
            prefix += this.options.markup.caseProtect.open;
            postfix = this.options.markup.caseProtect.close + postfix;
        }
        if (node.kind === 'Block') {
            for (const markup of Object.keys(node.markup)) {
                if (!this.options.markup[markup])
                    return this.error(new ParserError(`markup: ${markup}`, node), undefined);
                prefix += this.options.markup[markup].open;
                postfix = this.options.markup[markup].close + postfix;
            }
        }
        const end = {
            withoutPrefix: this.field.text.length,
            withPrefix: this.field.text.length + prefix.length,
        };
        this.field.text += prefix;
        this.field.level++;
        this.convert(node.value);
        this.field.level--;
        const added = this.field.text.substring(end.withPrefix);
        const added_text = added.replace(/<\/?[^>]+>/g, '');
        const needsProtection = added_text && ((this.options.caseProtection === 'strict' && added_text.match(preserveCase.isCaseSensitive))
            ||
                (this.options.caseProtection === 'as-needed' && added_text.split(/\s+/).find(word => this.needsProtection(word))));
        if (!added) { // nothing was added, so remove prefix
            this.field.text = this.field.text.substring(0, end.withoutPrefix);
        }
        else if (this.field.preserveRanges && prefix === this.options.markup.caseProtect.open && !needsProtection) {
            // something was added that didn't actually need case protection
            this.field.text = this.field.text.substring(0, end.withoutPrefix) + added;
            this.field.preserveRanges = this.field.preserveRanges.filter(range => range.start < end.withoutPrefix);
        }
        else {
            this.field.text += postfix;
        }
        this.field.text = this.field.text.replace(/<(sup|sub)>([^<>]+)<\/\1>$/i, (m, mode, chars) => {
            const cmd = mode === 'sup' ? '^' : '_';
            let script = '';
            for (const char of chars) {
                const unicode = unicode2latex.latex[`${cmd}${char}`] || unicode2latex.latex[`${cmd}{${char}}`];
                script += unicode ? unicode : `<${mode}>${char}</${mode}>`;
            }
            script = script.replace(new RegExp(`</${mode}><${mode}>`, 'g'), '');
            return script.length < m.length ? script : m;
        });
        if (node.case && this.field.preserveRanges)
            this.preserve(start, this.field.text.length); // , 'in convert-block ' + node.source || '<source>')
    }
}
/**
 * parse bibtex. This will try to convert TeX commands into unicode equivalents, and apply `@string` expansion
 */
function parse(input, options = {}) {
    const parser = new Parser(options);
    return parser.parse(input);
}
exports.parse = parse;
function ast(input, options = {}, clean = true) {
    const parser = new Parser(options);
    return parser.ast(input, clean);
}
exports.ast = ast;
var chunker_2 = chunker;
Object.defineProperty(exports, "chunker", { enumerable: true, get: function () { return chunker_2.parse; } });

Object.defineProperty(exports, "jabref", { enumerable: true, get: function () { return jabref.parse; } });

});

var TEMPLATE_VARIABLES = {
    citekey: 'Unique citekey',
    abstract: '',
    authorString: 'Comma-separated list of author names',
    containerTitle: 'Title of the container holding the reference (e.g. book title for a book chapter, or the journal title for a journal article)',
    DOI: '',
    eprint: '',
    eprinttype: '',
    eventPlace: 'Location of event',
    note: '',
    page: 'Page or page range',
    publisher: '',
    publisherPlace: 'Location of publisher',
    title: '',
    titleShort: '',
    URL: '',
    year: 'Publication year',
    zoteroSelectURI: 'URI to open the reference in Zotero',
};
var Library = /** @class */ (function () {
    function Library(entries) {
        this.entries = entries;
    }
    Object.defineProperty(Library.prototype, "size", {
        get: function () {
            return Object.keys(this.entries).length;
        },
        enumerable: false,
        configurable: true
    });
    /**
     * For the given citekey, find the corresponding `Entry` and return a
     * collection of template variable assignments.
     */
    Library.prototype.getTemplateVariablesForCitekey = function (citekey) {
        var _a;
        var entry = this.entries[citekey];
        var shortcuts = {
            citekey: citekey,
            abstract: entry.abstract,
            authorString: entry.authorString,
            containerTitle: entry.containerTitle,
            DOI: entry.DOI,
            eprint: entry.eprint,
            eprinttype: entry.eprinttype,
            eventPlace: entry.eventPlace,
            note: entry.note,
            page: entry.page,
            publisher: entry.publisher,
            publisherPlace: entry.publisherPlace,
            title: entry.title,
            titleShort: entry.titleShort,
            URL: entry.URL,
            year: (_a = entry.year) === null || _a === void 0 ? void 0 : _a.toString(),
            zoteroSelectURI: entry.zoteroSelectURI,
        };
        return __assign({ entry: entry.toJSON() }, shortcuts);
    };
    return Library;
}());
/**
 * An `Entry` represents a single reference in a reference database.
 * Each entry has a unique identifier, known in most reference managers as its
 * "citekey."
 */
var Entry = /** @class */ (function () {
    function Entry() {
    }
    Object.defineProperty(Entry.prototype, "year", {
        get: function () {
            var _a;
            return this._year
                ? parseInt(this._year)
                : (_a = this.issuedDate) === null || _a === void 0 ? void 0 : _a.getUTCFullYear();
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Entry.prototype, "note", {
        get: function () {
            var _a;
            return (_a = this._note) === null || _a === void 0 ? void 0 : _a.map(function (el) { return el.replace(/(zotero:\/\/.+)/g, '[Link]($1)'); }).join('\n\n');
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Entry.prototype, "zoteroSelectURI", {
        /**
         * A URI which will open the relevant entry in the Zotero client.
         */
        get: function () {
            return "zotero://select/items/@" + this.id;
        },
        enumerable: false,
        configurable: true
    });
    Entry.prototype.toJSON = function () {
        var _this = this;
        var jsonObj = Object.assign({}, this);
        // add getter values
        var proto = Object.getPrototypeOf(this);
        Object.entries(Object.getOwnPropertyDescriptors(proto))
            .filter(function (_a) {
            var descriptor = _a[1];
            return typeof descriptor.get == 'function';
        })
            .forEach(function (_a) {
            var key = _a[0], descriptor = _a[1];
            if (descriptor && key[0] !== '_') {
                try {
                    var val = _this[key];
                    jsonObj[key] = val;
                }
                catch (error) {
                    return;
                }
            }
        });
        return jsonObj;
    };
    return Entry;
}());
var EntryCSLAdapter = /** @class */ (function (_super) {
    __extends(EntryCSLAdapter, _super);
    function EntryCSLAdapter(data) {
        var _this = _super.call(this) || this;
        _this.data = data;
        _this.eprint = null;
        _this.eprinttype = null;
        _this.files = null;
        return _this;
    }
    Object.defineProperty(EntryCSLAdapter.prototype, "id", {
        get: function () {
            return this.data.id;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryCSLAdapter.prototype, "type", {
        get: function () {
            return this.data.type;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryCSLAdapter.prototype, "abstract", {
        get: function () {
            return this.data.abstract;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryCSLAdapter.prototype, "author", {
        get: function () {
            return this.data.author;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryCSLAdapter.prototype, "authorString", {
        get: function () {
            return this.data.author
                ? this.data.author.map(function (a) { return a.given + " " + a.family; }).join(', ')
                : null;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryCSLAdapter.prototype, "containerTitle", {
        get: function () {
            return this.data['container-title'];
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryCSLAdapter.prototype, "DOI", {
        get: function () {
            return this.data.DOI;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryCSLAdapter.prototype, "eventPlace", {
        get: function () {
            return this.data['event-place'];
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryCSLAdapter.prototype, "issuedDate", {
        get: function () {
            if (!(this.data.issued &&
                this.data.issued['date-parts'] &&
                this.data.issued['date-parts'][0].length > 0))
                return null;
            var _a = this.data.issued['date-parts'][0], year = _a[0], month = _a[1], day = _a[2];
            return new Date(Date.UTC(year, (month || 1) - 1, day || 1));
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryCSLAdapter.prototype, "page", {
        get: function () {
            return this.data.page;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryCSLAdapter.prototype, "publisher", {
        get: function () {
            return this.data.publisher;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryCSLAdapter.prototype, "publisherPlace", {
        get: function () {
            return this.data['publisher-place'];
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryCSLAdapter.prototype, "title", {
        get: function () {
            return this.data.title;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryCSLAdapter.prototype, "titleShort", {
        get: function () {
            return this.data['title-short'];
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryCSLAdapter.prototype, "URL", {
        get: function () {
            return this.data.URL;
        },
        enumerable: false,
        configurable: true
    });
    return EntryCSLAdapter;
}(Entry));
var BIBLATEX_PROPERTY_MAPPING = {
    abstract: 'abstract',
    booktitle: '_containerTitle',
    date: 'issued',
    doi: 'DOI',
    eprint: 'eprint',
    eprinttype: 'eprinttype',
    eventtitle: 'event',
    journal: '_containerTitle',
    journaltitle: '_containerTitle',
    location: 'publisherPlace',
    pages: 'page',
    shortjournal: 'containerTitleShort',
    title: 'title',
    shorttitle: 'titleShort',
    url: 'URL',
    venue: 'eventPlace',
    year: '_year',
    publisher: 'publisher',
    note: '_note',
};
// BibLaTeX parser returns arrays of property values (allowing for repeated
// property entries). For the following fields, just blindly take the first.
var BIBLATEX_PROPERTY_TAKE_FIRST = [
    'abstract',
    'booktitle',
    '_containerTitle',
    'date',
    'doi',
    'eprint',
    'eprinttype',
    'eventtitle',
    'journaltitle',
    'location',
    'pages',
    'shortjournal',
    'title',
    'shorttitle',
    'url',
    'venue',
    '_year',
    'publisher',
];
var EntryBibLaTeXAdapter = /** @class */ (function (_super) {
    __extends(EntryBibLaTeXAdapter, _super);
    function EntryBibLaTeXAdapter(data) {
        var _this = _super.call(this) || this;
        _this.data = data;
        Object.entries(BIBLATEX_PROPERTY_MAPPING).forEach(function (map) {
            var src = map[0], tgt = map[1];
            if (src in _this.data.fields) {
                var val = _this.data.fields[src];
                if (BIBLATEX_PROPERTY_TAKE_FIRST.includes(src)) {
                    val = val[0];
                }
                _this[tgt] = val;
            }
        });
        return _this;
    }
    Object.defineProperty(EntryBibLaTeXAdapter.prototype, "id", {
        get: function () {
            return this.data.key;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryBibLaTeXAdapter.prototype, "type", {
        get: function () {
            return this.data.type;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryBibLaTeXAdapter.prototype, "files", {
        get: function () {
            // For some reason the bibtex parser doesn't reliably parse file list to
            // array ; so we'll do it manually / redundantly
            var ret = [];
            if (this.data.fields.file) {
                ret = ret.concat(this.data.fields.file.flatMap(function (x) { return x.split(';'); }));
            }
            if (this.data.fields.files) {
                ret = ret.concat(this.data.fields.files.flatMap(function (x) { return x.split(';'); }));
            }
            return ret;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryBibLaTeXAdapter.prototype, "authorString", {
        get: function () {
            var _a;
            if (this.data.creators.author) {
                var names = this.data.creators.author.map(function (name) {
                    if (name.literal)
                        return name.literal;
                    var parts = [name.firstName, name.prefix, name.lastName, name.suffix];
                    // Drop any null parts and join
                    return parts.filter(function (x) { return x; }).join(' ');
                });
                return names.join(', ');
            }
            else {
                return (_a = this.data.fields.author) === null || _a === void 0 ? void 0 : _a.join(', ');
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryBibLaTeXAdapter.prototype, "containerTitle", {
        get: function () {
            if (this._containerTitle) {
                return this._containerTitle;
            }
            else if (this.data.fields.eprint) {
                var prefix = this.data.fields.eprinttype
                    ? this.data.fields.eprinttype + ":"
                    : '';
                var suffix = this.data.fields.primaryclass
                    ? " [" + this.data.fields.primaryclass + "]"
                    : '';
                return "" + prefix + this.data.fields.eprint + suffix;
            }
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryBibLaTeXAdapter.prototype, "issuedDate", {
        get: function () {
            return this.issued ? new Date(this.issued) : null;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(EntryBibLaTeXAdapter.prototype, "author", {
        get: function () {
            var _a;
            return (_a = this.data.creators.author) === null || _a === void 0 ? void 0 : _a.map(function (a) { return ({
                given: a.firstName,
                family: a.lastName,
            }); });
        },
        enumerable: false,
        configurable: true
    });
    return EntryBibLaTeXAdapter;
}(Entry));

var CITATION_DATABASE_FORMAT_LABELS = {
    'csl-json': 'CSL-JSON',
    biblatex: 'BibLaTeX',
};
var CitationsPluginSettings = /** @class */ (function () {
    function CitationsPluginSettings() {
        this.citationExportFormat = 'csl-json';
        this.literatureNoteTitleTemplate = '@{{citekey}}';
        this.literatureNoteFolder = 'Reading notes';
        this.literatureNoteContentTemplate = '---\n' +
            'title: {{title}}\n' +
            'authors: {{authorString}}\n' +
            'year: {{year}}\n' +
            '---\n\n';
        this.markdownCitationTemplate = '[@{{citekey}}]';
        this.alternativeMarkdownCitationTemplate = '@{{citekey}}';
    }
    return CitationsPluginSettings;
}());
var CitationSettingTab = /** @class */ (function (_super) {
    __extends(CitationSettingTab, _super);
    function CitationSettingTab(app, plugin) {
        var _this = _super.call(this, app, plugin) || this;
        _this.plugin = plugin;
        return _this;
    }
    CitationSettingTab.prototype.open = function () {
        var _this = this;
        _super.prototype.open.call(this);
        this.checkCitationExportPath(this.plugin.settings.citationExportPath).then(function () { return _this.showCitationExportPathSuccess(); });
    };
    CitationSettingTab.prototype.addValueChangeCallback = function (component, settingsKey, cb) {
        var _this = this;
        component.onChange(function (value) { return __awaiter(_this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                this.plugin.settings[settingsKey] = value;
                this.plugin.saveSettings().then(function () {
                    if (cb) {
                        cb(value);
                    }
                });
                return [2 /*return*/];
            });
        }); });
    };
    CitationSettingTab.prototype.buildValueInput = function (component, settingsKey, cb) {
        component.setValue(this.plugin.settings[settingsKey]);
        this.addValueChangeCallback(component, settingsKey, cb);
    };
    CitationSettingTab.prototype.display = function () {
        var _this = this;
        var containerEl = this.containerEl;
        containerEl.empty();
        containerEl.setAttr('id', 'zoteroSettingTab');
        containerEl.createEl('h2', { text: 'Citation plugin settings' });
        new obsidian.Setting(containerEl)
            .setName('Citation database format')
            .addDropdown(function (component) {
            return _this.buildValueInput(component.addOptions(CITATION_DATABASE_FORMAT_LABELS), 'citationExportFormat', function (value) {
                _this.checkCitationExportPath(_this.plugin.settings.citationExportPath).then(function (success) {
                    if (success) {
                        _this.citationPathSuccessEl.addClass('d-none');
                        _this.citationPathLoadingEl.removeClass('d-none');
                        _this.plugin.loadLibrary().then(function () {
                            _this.citationPathLoadingEl.addClass('d-none');
                            _this.showCitationExportPathSuccess();
                        });
                    }
                });
            });
        });
        // NB: we force reload of the library on path change.
        new obsidian.Setting(containerEl)
            .setName('Citation database path')
            .setDesc('Path to citation library exported by your reference manager. ' +
            'Can be an absolute path or a path relative to the current vault root folder. ' +
            'Citations will be automatically reloaded whenever this file updates.')
            .addText(function (input) {
            return _this.buildValueInput(input.setPlaceholder('/path/to/export.json'), 'citationExportPath', function (value) {
                _this.checkCitationExportPath(value).then(function (success) {
                    return success &&
                        _this.plugin
                            .loadLibrary()
                            .then(function () { return _this.showCitationExportPathSuccess(); });
                });
            });
        });
        this.citationPathLoadingEl = containerEl.createEl('p', {
            cls: 'zoteroSettingCitationPathLoading d-none',
            text: 'Loading citation database...',
        });
        this.citationPathErrorEl = containerEl.createEl('p', {
            cls: 'zoteroSettingCitationPathError d-none',
            text: 'The citation export file cannot be found. Please check the path above.',
        });
        this.citationPathSuccessEl = containerEl.createEl('p', {
            cls: 'zoteroSettingCitationPathSuccess d-none',
            text: 'Loaded library with {{n}} references.',
        });
        new obsidian.Setting(containerEl)
            .setName('Literature note folder')
            .addText(function (input) { return _this.buildValueInput(input, 'literatureNoteFolder'); })
            .setDesc('Save literature note files in this folder within your vault. If empty, notes will be stored in the root directory of the vault.');
        containerEl.createEl('h3', { text: 'Template settings' });
        var templateInstructionsEl = containerEl.createEl('p');
        templateInstructionsEl.append(createSpan({
            text: 'The following settings determine how the notes and links created by ' +
                'the plugin will be rendered. You may specify a custom template for ' +
                'each type of content. Templates are interpreted using ',
        }));
        templateInstructionsEl.append(createEl('a', {
            text: 'Handlebars',
            href: 'https://handlebarsjs.com/guide/expressions.html',
        }));
        templateInstructionsEl.append(createSpan({
            text: ' syntax. You can make reference to the following variables:',
        }));
        var templateVariableUl = containerEl.createEl('ul', {
            attr: { id: 'citationTemplateVariables' },
        });
        Object.entries(TEMPLATE_VARIABLES).forEach(function (variableData) {
            var key = variableData[0], description = variableData[1], templateVariableItem = templateVariableUl.createEl('li');
            templateVariableItem.createEl('span', {
                cls: 'text-monospace',
                text: '{{' + key + '}}',
            });
            templateVariableItem.createEl('span', {
                text: description ? " \u2014 " + description : '',
            });
        });
        var templateEntryInstructionsEl = containerEl.createEl('p');
        templateEntryInstructionsEl.append(createSpan({ text: 'Advanced users may also refer to the ' }), createSpan({ text: '{{entry}}', cls: 'text-monospace' }), createSpan({
            text: ' variable, which contains the full object representation of the ' +
                'reference as used internally by the plugin. See the ',
        }), createEl('a', {
            text: 'plugin documentation',
            href: 'http://www.foldl.me/obsidian-citation-plugin/classes/entry.html',
        }), createSpan({ text: " for information on this object's structure." }));
        containerEl.createEl('h3', { text: 'Literature note templates' });
        new obsidian.Setting(containerEl)
            .setName('Literature note title template')
            .addText(function (input) {
            return _this.buildValueInput(input, 'literatureNoteTitleTemplate');
        });
        new obsidian.Setting(containerEl)
            .setName('Literature note content template')
            .addTextArea(function (input) {
            return _this.buildValueInput(input, 'literatureNoteContentTemplate');
        });
        containerEl.createEl('h3', { text: 'Markdown citation templates' });
        containerEl.createEl('p', {
            text: 'You can insert Pandoc-style Markdown citations rather than literature notes by using the "Insert Markdown citation" command. The below options allow customization of the Markdown citation format.',
        });
        new obsidian.Setting(containerEl)
            .setName('Markdown primary citation template')
            .addText(function (input) {
            return _this.buildValueInput(input, 'markdownCitationTemplate');
        });
        new obsidian.Setting(containerEl)
            .setName('Markdown secondary citation template')
            .addText(function (input) {
            return _this.buildValueInput(input, 'alternativeMarkdownCitationTemplate');
        });
    };
    /**
     * Returns true iff the path exists; displays error as a side-effect
     */
    CitationSettingTab.prototype.checkCitationExportPath = function (filePath) {
        return __awaiter(this, void 0, void 0, function () {
            var e_1;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.citationPathLoadingEl.addClass('d-none');
                        _a.label = 1;
                    case 1:
                        _a.trys.push([1, 3, , 4]);
                        return [4 /*yield*/, obsidian.FileSystemAdapter.readLocalFile(this.plugin.resolveLibraryPath(filePath))];
                    case 2:
                        _a.sent();
                        this.citationPathErrorEl.addClass('d-none');
                        return [3 /*break*/, 4];
                    case 3:
                        e_1 = _a.sent();
                        this.citationPathSuccessEl.addClass('d-none');
                        this.citationPathErrorEl.removeClass('d-none');
                        return [2 /*return*/, false];
                    case 4: return [2 /*return*/, true];
                }
            });
        });
    };
    CitationSettingTab.prototype.showCitationExportPathSuccess = function () {
        if (!this.plugin.library)
            return;
        this.citationPathSuccessEl.setText("Loaded library with " + this.plugin.library.size + " references.");
        this.citationPathSuccessEl.removeClass('d-none');
    };
    return CitationSettingTab;
}(obsidian.PluginSettingTab));

var messageIds = 0;

function onMessage (self, e) {
  var message = e.data;
  if (!Array.isArray(message) || message.length < 2) {
    // Ignore - this message is not for us.
    return
  }
  var messageId = message[0];
  var error = message[1];
  var result = message[2];

  var callback = self._callbacks[messageId];

  if (!callback) {
    // Ignore - user might have created multiple PromiseWorkers.
    // This message is not for us.
    return
  }

  delete self._callbacks[messageId];
  callback(error, result);
}

function PromiseWorker (worker) {
  var self = this;
  self._worker = worker;
  self._callbacks = {};

  worker.addEventListener('message', function (e) {
    onMessage(self, e);
  });
}

PromiseWorker.prototype.postMessage = function (userMessage) {
  var self = this;
  var messageId = messageIds++;

  var messageToSend = [messageId, userMessage];

  return new Promise(function (resolve, reject) {
    self._callbacks[messageId] = function (error, result) {
      if (error) {
        return reject(new Error(error.message))
      }
      resolve(result);
    };

    /* istanbul ignore if */
    if (typeof self._worker.controller !== 'undefined') {
      // service worker, use MessageChannels because e.source is broken in Chrome < 51:
      // https://bugs.chromium.org/p/chromium/issues/detail?id=543198
      var channel = new MessageChannel();
      channel.port1.onmessage = function (e) {
        onMessage(self, e);
      };
      self._worker.controller.postMessage(messageToSend, [channel.port2]);
    } else {
      // web worker
      self._worker.postMessage(messageToSend);
    }
  })
};

var promiseWorker = PromiseWorker;

/**
 * Declares properties and methods which are missing from the Obsidian API.
 */
var NoticeExt = /** @class */ (function (_super) {
    __extends(NoticeExt, _super);
    function NoticeExt() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    NoticeExt.DISAPPEARING_CLASS = 'mod-disappearing';
    return NoticeExt;
}(obsidian.Notice));

var DISALLOWED_FILENAME_CHARACTERS_RE = /[*"\\/<>:|?]/g;
/**
 * Manages a category of notices to be displayed in the UI. Prevents multiple
 * notices being shown at the same time.
 */
var Notifier = /** @class */ (function () {
    function Notifier(defaultMessage) {
        this.defaultMessage = defaultMessage;
    }
    Notifier.prototype.unload = function () {
        this.hide();
    };
    /**
     * @returns true if the notice was shown, and false otherwise
     */
    Notifier.prototype.show = function (message) {
        var _this = this;
        var _a;
        message = message || this.defaultMessage;
        if (this.currentNotice)
            return false;
        this.currentNotice = new obsidian.Notice(message);
        // Set up mutation observer to watch for when the notice disappears.
        (_a = this.mutationObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
        this.mutationObserver = new MutationObserver(function (changes, observer) {
            var isDisappearing = changes.some(function (change) {
                var el = change.target;
                return (change.type == 'attributes' &&
                    el.hasClass(NoticeExt.DISAPPEARING_CLASS));
            });
            if (isDisappearing) {
                _this.currentNotice = null;
                observer.disconnect();
                _this.mutationObserver = null;
            }
        });
        this.mutationObserver.observe(this.currentNotice.noticeEl, {
            attributeFilter: ['class'],
        });
    };
    Notifier.prototype.hide = function () {
        var _a, _b;
        (_a = this.currentNotice) === null || _a === void 0 ? void 0 : _a.hide();
        (_b = this.mutationObserver) === null || _b === void 0 ? void 0 : _b.disconnect();
        this.currentNotice = null;
        this.mutationObserver = null;
    };
    Notifier.DISAPPEARING_CLASS = 'mod-disappearing';
    return Notifier;
}());
/**
 * Manages a Worker, recording its state and optionally preventing
 * message postings before responses to prior messages have been received.
 */
var WorkerManager = /** @class */ (function () {
    function WorkerManager(_worker, options) {
        this._worker = _worker;
        this.worker = new promiseWorker(this._worker);
        /**
         * Only relevant when `blockingChannel` option is true.
         * Then this property is true iff the worker is currently processing a
         * received message, and has not yet posted a response.
         */
        this.blocked = false;
        this.options = __assign(__assign({}, workerManagerDefaultOptions), options);
    }
    /**
     * Attempt to post a message to the worker and return a promise response.
     *
     * If `blockingChannel` option is true and the channel is currently blocked,
     * the message will be discarded and an error will be thrown.
     */
    WorkerManager.prototype.post = function (msg) {
        return __awaiter(this, void 0, void 0, function () {
            var _this = this;
            return __generator(this, function (_a) {
                if (this.options.blockingChannel && this.blocked) {
                    throw new WorkerManagerBlocked();
                }
                this.blocked = true;
                return [2 /*return*/, this.worker.postMessage(msg).then(function (result) {
                        _this.blocked = false;
                        return result;
                    }, function (error) {
                        _this.blocked = false;
                        throw error;
                    })];
            });
        });
    };
    return WorkerManager;
}());
var WorkerManagerBlocked = /** @class */ (function (_super) {
    __extends(WorkerManagerBlocked, _super);
    function WorkerManagerBlocked() {
        var _this = _super.call(this, 'WorkerManager: discarded message because channel is blocked') || this;
        Object.setPrototypeOf(_this, WorkerManagerBlocked.prototype);
        return _this;
    }
    return WorkerManagerBlocked;
}(Error));
var workerManagerDefaultOptions = {
    blockingChannel: false,
};

function funcToSource(fn, sourcemapArg) {
    var sourcemap = sourcemapArg === undefined ? null : sourcemapArg;
    var source = fn.toString();
    var lines = source.split('\n');
    lines.pop();
    lines.shift();
    var blankPrefixLength = lines[0].search(/\S/);
    var regex = /(['"])__worker_loader_strict__(['"])/g;
    for (var i = 0, n = lines.length; i < n; ++i) {
        lines[i] = lines[i].substring(blankPrefixLength).replace(regex, '$1use strict$2') + '\n';
    }
    if (sourcemap) {
        lines.push('\/\/# sourceMappingURL=' + sourcemap + '\n');
    }
    return lines;
}

function createURL(fn, sourcemapArg) {
    var lines = funcToSource(fn, sourcemapArg);
    var blob = new Blob(lines, { type: 'application/javascript' });
    return URL.createObjectURL(blob);
}

function createInlineWorkerFactory(fn, sourcemapArg) {
    var url;
    return function WorkerFactory(options) {
        url = url || createURL(fn, sourcemapArg);
        return new Worker(url, options);
    };
}

var WorkerFactory = createInlineWorkerFactory(/* rollup-plugin-web-worker-loader */function () {
(function () {
  '__worker_loader_strict__';

  function isPromise (obj) {
    // via https://unpkg.com/is-promise@2.1.0/index.js
    return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function'
  }

  function registerPromiseWorker (callback) {
    function postOutgoingMessage (e, messageId, error, result) {
      function postMessage (msg) {
        /* istanbul ignore if */
        if (typeof self.postMessage !== 'function') { // service worker
          e.ports[0].postMessage(msg);
        } else { // web worker
          self.postMessage(msg);
        }
      }
      if (error) {
        /* istanbul ignore else */
        if (typeof console !== 'undefined' && 'error' in console) {
          // This is to make errors easier to debug. I think it's important
          // enough to just leave here without giving the user an option
          // to silence it.
          console.error('Worker caught an error:', error);
        }
        postMessage([messageId, {
          message: error.message
        }]);
      } else {
        postMessage([messageId, null, result]);
      }
    }

    function tryCatchFunc (callback, message) {
      try {
        return { res: callback(message) }
      } catch (e) {
        return { err: e }
      }
    }

    function handleIncomingMessage (e, callback, messageId, message) {
      var result = tryCatchFunc(callback, message);

      if (result.err) {
        postOutgoingMessage(e, messageId, result.err);
      } else if (!isPromise(result.res)) {
        postOutgoingMessage(e, messageId, null, result.res);
      } else {
        result.res.then(function (finalResult) {
          postOutgoingMessage(e, messageId, null, finalResult);
        }, function (finalError) {
          postOutgoingMessage(e, messageId, finalError);
        });
      }
    }

    function onIncomingMessage (e) {
      var payload = e.data;
      if (!Array.isArray(payload) || payload.length !== 2) {
        // message doens't match communication format; ignore
        return
      }
      var messageId = payload[0];
      var message = payload[1];

      if (typeof callback !== 'function') {
        postOutgoingMessage(e, messageId, new Error(
          'Please pass a function into register().'));
      } else {
        handleIncomingMessage(e, callback, messageId, message);
      }
    }

    self.addEventListener('message', onIncomingMessage);
  }

  var register = registerPromiseWorker;

  /*! *****************************************************************************
  Copyright (c) Microsoft Corporation.

  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted.

  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  PERFORMANCE OF THIS SOFTWARE.
  ***************************************************************************** */
  /* global Reflect, Promise */

  var extendStatics = function(d, b) {
      extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
      return extendStatics(d, b);
  };

  function __extends(d, b) {
      extendStatics(d, b);
      function __() { this.constructor = d; }
      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  }

  var __assign = function() {
      __assign = Object.assign || function __assign(t) {
          for (var s, i = 1, n = arguments.length; i < n; i++) {
              s = arguments[i];
              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
          }
          return t;
      };
      return __assign.apply(this, arguments);
  };

  function createCommonjsModule(fn, basedir, module) {
  	return module = {
  		path: basedir,
  		exports: {},
  		require: function (path, base) {
  			return commonjsRequire(path, (base === undefined || base === null) ? module.path : base);
  		}
  	}, fn(module, module.exports), module.exports;
  }

  function commonjsRequire () {
  	throw new Error('Dynamic requires are not currently supported by @rollup/plugin-commonjs');
  }

  /*
   * Generated by PEG.js 0.10.0.
   *
   * http://pegjs.org/
   */

  function peg$subclass(child, parent) {
    function ctor() { this.constructor = child; }
    ctor.prototype = parent.prototype;
    child.prototype = new ctor();
  }

  function peg$SyntaxError(message, expected, found, location) {
    this.message  = message;
    this.expected = expected;
    this.found    = found;
    this.location = location;
    this.name     = "SyntaxError";

    if (typeof Error.captureStackTrace === "function") {
      Error.captureStackTrace(this, peg$SyntaxError);
    }
  }

  peg$subclass(peg$SyntaxError, Error);

  peg$SyntaxError.buildMessage = function(expected, found) {
    var DESCRIBE_EXPECTATION_FNS = {
          literal: function(expectation) {
            return "\"" + literalEscape(expectation.text) + "\"";
          },

          "class": function(expectation) {
            var escapedParts = "",
                i;

            for (i = 0; i < expectation.parts.length; i++) {
              escapedParts += expectation.parts[i] instanceof Array
                ? classEscape(expectation.parts[i][0]) + "-" + classEscape(expectation.parts[i][1])
                : classEscape(expectation.parts[i]);
            }

            return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]";
          },

          any: function(expectation) {
            return "any character";
          },

          end: function(expectation) {
            return "end of input";
          },

          other: function(expectation) {
            return expectation.description;
          }
        };

    function hex(ch) {
      return ch.charCodeAt(0).toString(16).toUpperCase();
    }

    function literalEscape(s) {
      return s
        .replace(/\\/g, '\\\\')
        .replace(/"/g,  '\\"')
        .replace(/\0/g, '\\0')
        .replace(/\t/g, '\\t')
        .replace(/\n/g, '\\n')
        .replace(/\r/g, '\\r')
        .replace(/[\x00-\x0F]/g,          function(ch) { return '\\x0' + hex(ch); })
        .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x'  + hex(ch); });
    }

    function classEscape(s) {
      return s
        .replace(/\\/g, '\\\\')
        .replace(/\]/g, '\\]')
        .replace(/\^/g, '\\^')
        .replace(/-/g,  '\\-')
        .replace(/\0/g, '\\0')
        .replace(/\t/g, '\\t')
        .replace(/\n/g, '\\n')
        .replace(/\r/g, '\\r')
        .replace(/[\x00-\x0F]/g,          function(ch) { return '\\x0' + hex(ch); })
        .replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) { return '\\x'  + hex(ch); });
    }

    function describeExpectation(expectation) {
      return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
    }

    function describeExpected(expected) {
      var descriptions = new Array(expected.length),
          i, j;

      for (i = 0; i < expected.length; i++) {
        descriptions[i] = describeExpectation(expected[i]);
      }

      descriptions.sort();

      if (descriptions.length > 0) {
        for (i = 1, j = 1; i < descriptions.length; i++) {
          if (descriptions[i - 1] !== descriptions[i]) {
            descriptions[j] = descriptions[i];
            j++;
          }
        }
        descriptions.length = j;
      }

      switch (descriptions.length) {
        case 1:
          return descriptions[0];

        case 2:
          return descriptions[0] + " or " + descriptions[1];

        default:
          return descriptions.slice(0, -1).join(", ")
            + ", or "
            + descriptions[descriptions.length - 1];
      }
    }

    function describeFound(found) {
      return found ? "\"" + literalEscape(found) + "\"" : "end of input";
    }

    return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
  };

  function peg$parse(input, options) {
    options = options !== void 0 ? options : {};

    var peg$FAILED = {},

        peg$startRuleFunctions = { Bibliography: peg$parseBibliography },
        peg$startRuleFunction  = peg$parseBibliography,

        peg$c0 = function(r) {
            return {
              kind: 'Bibliography',
              loc: location(),
              source: text(),
              children: r,
            }
          },
        peg$c1 = "@",
        peg$c2 = peg$literalExpectation("@", false),
        peg$c3 = "comment",
        peg$c4 = peg$literalExpectation("comment", true),
        peg$c5 = function(v) {
            return {
              kind: 'BracedComment',
              loc: location(),
              source: text(),
              value: v.slice(1, -1),
            }
          },
        peg$c6 = /^[^\n\r]/,
        peg$c7 = peg$classExpectation(["\n", "\r"], true, false),
        peg$c8 = /^[\n\r]/,
        peg$c9 = peg$classExpectation(["\n", "\r"], false, false),
        peg$c10 = function(v) {
            return {
              kind: 'LineComment',
              loc: location(),
              source: text(),
              value: normalizeWhitespace(v),
            }
            },
        peg$c11 = /^[^@]/,
        peg$c12 = peg$classExpectation(["@"], true, false),
        peg$c13 = function(v) {
            return {
              kind: 'NonEntryText',
              loc: location(),
              source: text(),
              value: normalizeWhitespace(v),
            }
          },
        peg$c14 = function(n) { return n; },
        peg$c15 = "{",
        peg$c16 = peg$literalExpectation("{", false),
        peg$c17 = /^[^{}]/,
        peg$c18 = peg$classExpectation(["{", "}"], true, false),
        peg$c19 = "}",
        peg$c20 = peg$literalExpectation("}", false),
        peg$c21 = function(comment) { return '{' + comment.join('') + '}' },
        peg$c22 = /^[A-Za-z]/,
        peg$c23 = peg$classExpectation([["A", "Z"], ["a", "z"]], false, false),
        peg$c24 = /^[({]/,
        peg$c25 = peg$classExpectation(["(", "{"], false, false),
        peg$c26 = /^[})]/,
        peg$c27 = peg$classExpectation(["}", ")"], false, false),
        peg$c28 = function(type, id, fields) {
            return {
              kind: 'Entry',
              id: id || '',
              type: type.toLowerCase(),
              loc: location(),
              source: text(),
              fields: fields,
            }
          },
        peg$c29 = "preamble",
        peg$c30 = peg$literalExpectation("preamble", true),
        peg$c31 = function(opener, v, closer) {
            switch (opener + closer) {
              case '{}':
              case '()':
                break
              default:
                throw new Error(`Unbalanced opener-closer for preamble: ${opener}...${closer}`)
            }
            return {
              kind: 'PreambleExpression',
              loc: location(),
              source: text(),
              value: v.reduce((a, b) => a.concat(b), []),
            }
          },
        peg$c32 = "string",
        peg$c33 = peg$literalExpectation("string", true),
        peg$c34 = function(k, v) {
            return {
              kind: 'StringDeclaration',
              loc: location(),
              source: text(),
              name: k,
              value: v.reduce((a, b) => a.concat(b), []),
            }
          },
        peg$c35 = /^[^ \t\r\n,]/,
        peg$c36 = peg$classExpectation([" ", "\t", "\r", "\n", ","], true, false),
        peg$c37 = ",",
        peg$c38 = peg$literalExpectation(",", false),
        peg$c39 = function(id) { return id; },
        peg$c40 = function(name) { return isVerbatimField(name) && unnestFields.includes(name) },
        peg$c41 = function(name, value) {
            // because this was abused so much, many processors treat double-outer-braces as single
            return {
              kind: 'Field',
              loc: location(),
              source: text(),
              name: name,
              loc: location(),
              value: [ protect(value) ]
            }
          },
        peg$c42 = function(name) { return isVerbatimField(name) },
        peg$c43 = function(name, value) {
            return {
              kind: 'Field',
              loc: location(),
              source: text(),
              name: name,
              loc: location(),
              value: [ protect(value) ]
            }
          },
        peg$c44 = function(name, value) {
            // because this was abused so much, many processors treat double-outer-braces as single
            if (unnestFields.includes(name) && Array.isArray(value) && value.length === 1 && value[0].kind === 'Block') {
              if (options.unnestMode === 'preserve') {
                value[0].case = 'preserve';
              } else {
                value = value[0].value;
              }
            }

            return handle_markup_switches({
              kind: 'Field',
              loc: location(),
              source: text(),
              name: name,
              value: value,
            })
          },
        peg$c45 = /^[_:a-zA-Z0-9\-]/,
        peg$c46 = peg$classExpectation(["_", ":", ["a", "z"], ["A", "Z"], ["0", "9"], "-"], false, false),
        peg$c47 = function(name) { return name.toLowerCase() },
        peg$c48 = "\"",
        peg$c49 = peg$literalExpectation("\"", false),
        peg$c50 = function(v) {
            v = v || {
              kind: 'Text',
              loc: location(),
              source: text(),
              value: '',
            };
            v.mode = 'verbatim';
            return basicTextConversions(v)
          },
        peg$c51 = function(v) {
            return basicTextConversions({
              kind: 'Text',
              loc: location(),
              source: text(),
              value: v.join('').trim(),
              mode: 'verbatim',
            })
          },
        peg$c52 = function(v) { return v },
        peg$c53 = function(v) { return '{' + v.join('') + '}' },
        peg$c54 = function() { return math.set(false) },
        peg$c55 = function(v) {
            return v.reduce((a, b) => a.concat(b), []);
          },
        peg$c56 = function(v) { return v; },
        peg$c57 = "{\\verb",
        peg$c58 = peg$literalExpectation("{\\verb", false),
        peg$c59 = /^[a-zA-Z]/,
        peg$c60 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false),
        peg$c61 = /^[^\^_${}\\]/,
        peg$c62 = peg$classExpectation(["^", "_", "$", "{", "}", "\\"], true, false),
        peg$c63 = function(v) {
            return basicTextConversions({
              kind: 'Text',
              loc: location(),
              source: text(),
              value: normalizeWhitespace(v),
              mode: math.on ? 'math' : 'text',
            })
          },
        peg$c64 = /^[^\^_${}"\\]/,
        peg$c65 = peg$classExpectation(["^", "_", "$", "{", "}", "\"", "\\"], true, false),
        peg$c66 = /^[0-9]/,
        peg$c67 = peg$classExpectation([["0", "9"]], false, false),
        peg$c68 = function(v) {
            return {
              kind: 'Number',
              loc: location(),
              source: text(),
              value: parseInt(v, 10),
            }
          },
        peg$c69 = function(v) {
            return {
              kind: 'StringReference',
              loc: location(),
              source: text(),
              name: v,
            }
          },
        peg$c70 = "\\begin{",
        peg$c71 = peg$literalExpectation("\\begin{", false),
        peg$c72 = /^[a-zA-Z0-9]/,
        peg$c73 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"]], false, false),
        peg$c74 = "\\end{",
        peg$c75 = peg$literalExpectation("\\end{", false),
        peg$c76 = function(env, v, cenv) { return env === cenv },
        peg$c77 = function(env, v, cenv) {
            if (markup[env]) {
              return {
                kind: 'Block',
                loc: location(),
                source: text(),
                value: v,
                markup: { [markup[env]]: true },
              }
            } else {
              return {
                kind: 'Environment',
                loc: location(),
                source: text(),
                value: v,
                env: env,
              }
            }
          },
        peg$c78 = "{\\",
        peg$c79 = peg$literalExpectation("{\\", false),
        peg$c80 = "\\",
        peg$c81 = peg$literalExpectation("\\", false),
        peg$c82 = /^[ij]/,
        peg$c83 = peg$classExpectation(["i", "j"], false, false),
        peg$c84 = function(mark, char) {
            return {
              kind: 'DiacriticCommand',
              loc: location(),
              source: text(),
              mark: mark,
              dotless: !!char[1],
              character: char[1] || char[0],
            }
          },
        peg$c85 = function(v) {
              return basicTextConversions({
                kind: 'Text',
                loc: location(),
                source: text(),
                value: v.join('').trim(),
                mode: 'verbatim',
              })
          },
        peg$c86 = function(v) {
            const block = {
              kind: 'Block',
              loc: location(),
              source: text(),
              value: v,
              markup: {},
              case: 'protect',
            };

            let leadingcmd = block.value.length && (block.value[0].kind.endsWith('Command') || block.value[0].kind === 'Environment') ? block.value[0] : null;
            let leadingcmdblockarg = leadingcmd
              && leadingcmd.kind === 'RegularCommand'
              && leadingcmd.arguments.required.length
              && leadingcmd.arguments.required[0].kind === 'Block'
              && leadingcmd.arguments.required[0];

            // https://github.com/retorquere/zotero-better-bibtex/issues/541#issuecomment-240156274
            if (leadingcmd) {
              delete block.case;

              // command with a block cancels out case protection with containing block
              // if a smallcaps block has set case to 'preserve' we want to keep this
              if (leadingcmdblockarg && leadingcmdblockarg.case === 'protect') delete leadingcmdblockarg.case;

              // \sl, \it etc
              if (markup[leadingcmd.command]) {
                block.markup[markup[leadingcmd.command]] = true;
                block.value.shift();
              }
            }

            return handle_markup_switches(block)
          },
        peg$c87 = function() { return !math.on },
        peg$c88 = "$",
        peg$c89 = peg$literalExpectation("$", false),
        peg$c90 = "$$",
        peg$c91 = peg$literalExpectation("$$", false),
        peg$c92 = function(mode) { return math.set(true) },
        peg$c93 = function(mode, v) { return math.set(false) },
        peg$c94 = function(mode, v) {
            return {
              kind: mode == '$$' ? 'DisplayMath' : 'InlineMath',
              loc: location(),
              source: text(),
              value: v,
              case: 'protect',
              markup: {},
            }
          },
        peg$c95 = "%",
        peg$c96 = peg$literalExpectation("%", false),
        peg$c97 = /^[^\r\n]/,
        peg$c98 = peg$classExpectation(["\r", "\n"], true, false),
        peg$c99 = function(v) {
            return {
              kind: 'LineComment',
              loc: location(),
              source: text(),
              value: v,
            }
          },
        peg$c100 = /^[_\^]/,
        peg$c101 = peg$classExpectation(["_", "^"], false, false),
        peg$c102 = function(mode, v) {
            if (v.kind === 'Block') v = v.value;

            return {
              kind: mode === '_' ? 'SubscriptCommand' : 'SuperscriptCommand',
              loc: location(),
              source: text(),
              value: v,
            }
          },
        peg$c103 = function(mark, v) {
            return {
              kind: 'RegularCommand',
              loc: location(),
              source: text(),
              command: mark,
              arguments: {
                optional: [],
                required: [ protect(v) ],
              },
            }
          },
        peg$c104 = /^[^A-Za-z0-9\t\r\n]/,
        peg$c105 = peg$classExpectation([["A", "Z"], ["a", "z"], ["0", "9"], "\t", "\r", "\n"], true, false),
        peg$c106 = function(v) {
            return {
              kind: 'SymbolCommand',
              loc: location(),
              source: text(),
              command: v,
            }
          },
        peg$c107 = "newcommand",
        peg$c108 = peg$literalExpectation("newcommand", false),
        peg$c109 = function(cmd, name) { return name.value.length == 1 && name.value[0].kind === 'RegularCommand' },
        peg$c110 = function(cmd, name, optional, def) {
            return {
              kind: 'RegularCommand',
              loc: location(),
              source: text(),
              command: cmd,
              arguments: {
                optional: [],
                required: [name, def],
              },
            }
          },
        peg$c111 = "begin",
        peg$c112 = peg$literalExpectation("begin", false),
        peg$c113 = "end",
        peg$c114 = peg$literalExpectation("end", false),
        peg$c115 = function(cmd) { return verbatimCommands.includes(cmd) && (has_arguments[cmd] === 2) },
        peg$c116 = function(cmd, optional, req1, req2) {
            return {
              kind: 'RegularCommand',
              loc: location(),
              source: text(),
              command: cmd,
              arguments: {
                optional: optional,
                required: [protect(req1), protect(req2)],
              },
            }
          },
        peg$c117 = function(cmd) { return verbatimCommands.includes(cmd) && (has_arguments[cmd] === 1) },
        peg$c118 = function(cmd, optional, req) {
            return {
              kind: 'RegularCommand',
              loc: location(),
              source: text(),
              command: cmd,
              arguments: {
                optional: optional,
                required: [protect(req)],
              },
            }
          },
        peg$c119 = function(cmd) { return (has_arguments[cmd] === 2) },
        peg$c120 = function(cmd, optional, req1, req2) {
            return {
              kind: 'RegularCommand',
              loc: location(),
              source: text(),
              command: cmd,
              arguments: {
                optional: optional,
                required: [req1, req2],
              },
            }
          },
        peg$c121 = function(cmd) { return (has_arguments[cmd] === 1) },
        peg$c122 = function(cmd, optional, req) {
            let m;
            if (req.kind === 'Block') {
              switch (cmd) {
                case 'textsuperscript':
                case 'sp':
                  req.markup.sup = true;
                  break
                case 'textsubscript':
                case 'sb':
                  req.markup.sub = true;
                  break
                case 'textsc':
                  req.markup.smallCaps = true;
                  break
                case 'enquote':
                case 'mkbibquote':
                  req.markup.enquote = true;
                  break
                case 'textbf':
                case 'mkbibbold':
                  req.markup.bold = true;
                  break
                case 'emph':
                case 'textit':
                case 'mkbibitalic':
                case 'mkbibemph':
                  req.markup.italics = true;
                  break
                default:
                  if (m = cmd.match(/^((sub)*)section$/)) {
                    req.markup[`h${(m[1].length / 3) + 1}`] = true;
                  }
              }
            }

            // ignore case stuff on bibcyr
            if (cmd === 'bibcyr') delete req.case;

            return {
              kind: 'RegularCommand',
              loc: location(),
              source: text(),
              command: cmd,
              arguments: {
                optional: optional,
                required: [req],
              }
            }
          },
        peg$c123 = function(cmd, optional) {
            return {
              kind: 'RegularCommand',
              loc: location(),
              source: text(),
              command: cmd,
              arguments: {
                optional: optional,
                required: [],
              }
            }
          },
        peg$c124 = "[",
        peg$c125 = peg$literalExpectation("[", false),
        peg$c126 = /^[^\]]/,
        peg$c127 = peg$classExpectation(["]"], true, false),
        peg$c128 = "]",
        peg$c129 = peg$literalExpectation("]", false),
        peg$c130 = function(v) {
            return basicTextConversions({
              kind: 'Text', // this isn't really correct but I don't need these right now
              loc: location(),
              source: text(),
              value: v,
              mode: math.on ? 'math' : 'text',
            })
          },
        peg$c131 = /^[^ \t\^_${}\\]/,
        peg$c132 = peg$classExpectation([" ", "\t", "^", "_", "$", "{", "}", "\\"], true, false),
        peg$c133 = function(v) {
            return basicTextConversions({
              kind: 'Text',
              loc: location(),
              source: text(),
              value: normalizeWhitespace([v]),
              mode: math.on ? 'math' : 'text',
            })
          },
        peg$c134 = /^[a-zA-Z\-_]/,
        peg$c135 = peg$classExpectation([["a", "z"], ["A", "Z"], "-", "_"], false, false),
        peg$c136 = /^[a-zA-Z0-9\-&_:]/,
        peg$c137 = peg$classExpectation([["a", "z"], ["A", "Z"], ["0", "9"], "-", "&", "_", ":"], false, false),
        peg$c138 = /^['`"=~\^.]/,
        peg$c139 = peg$classExpectation(["'", "`", "\"", "=", "~", "^", "."], false, false),
        peg$c140 = /^['`"=~\^.cbuvdrHk]/,
        peg$c141 = peg$classExpectation(["'", "`", "\"", "=", "~", "^", ".", "c", "b", "u", "v", "d", "r", "H", "k"], false, false),
        peg$c142 = "=",
        peg$c143 = peg$literalExpectation("=", false),
        peg$c144 = "#",
        peg$c145 = peg$literalExpectation("#", false),
        peg$c146 = /^[\r\n]/,
        peg$c147 = peg$classExpectation(["\r", "\n"], false, false),
        peg$c149 = /^[ \t]/,
        peg$c150 = peg$classExpectation([" ", "\t"], false, false),
        peg$c151 = peg$otherExpectation("Optional Horizontal Whitespace"),
        peg$c155 = /^[ \t\n\r]/,
        peg$c156 = peg$classExpectation([" ", "\t", "\n", "\r"], false, false),
        peg$c157 = peg$otherExpectation("Optional Whitespace"),

        peg$currPos          = 0,
        peg$savedPos         = 0,
        peg$posDetailsCache  = [{ line: 1, column: 1 }],
        peg$maxFailPos       = 0,
        peg$maxFailExpected  = [],
        peg$silentFails      = 0,

        peg$result;

    if ("startRule" in options) {
      if (!(options.startRule in peg$startRuleFunctions)) {
        throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
      }

      peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
    }

    function text() {
      return input.substring(peg$savedPos, peg$currPos);
    }

    function location() {
      return peg$computeLocation(peg$savedPos, peg$currPos);
    }

    function peg$literalExpectation(text, ignoreCase) {
      return { type: "literal", text: text, ignoreCase: ignoreCase };
    }

    function peg$classExpectation(parts, inverted, ignoreCase) {
      return { type: "class", parts: parts, inverted: inverted, ignoreCase: ignoreCase };
    }

    function peg$endExpectation() {
      return { type: "end" };
    }

    function peg$otherExpectation(description) {
      return { type: "other", description: description };
    }

    function peg$computePosDetails(pos) {
      var details = peg$posDetailsCache[pos], p;

      if (details) {
        return details;
      } else {
        p = pos - 1;
        while (!peg$posDetailsCache[p]) {
          p--;
        }

        details = peg$posDetailsCache[p];
        details = {
          line:   details.line,
          column: details.column
        };

        while (p < pos) {
          if (input.charCodeAt(p) === 10) {
            details.line++;
            details.column = 1;
          } else {
            details.column++;
          }

          p++;
        }

        peg$posDetailsCache[pos] = details;
        return details;
      }
    }

    function peg$computeLocation(startPos, endPos) {
      var startPosDetails = peg$computePosDetails(startPos),
          endPosDetails   = peg$computePosDetails(endPos);

      return {
        start: {
          offset: startPos,
          line:   startPosDetails.line,
          column: startPosDetails.column
        },
        end: {
          offset: endPos,
          line:   endPosDetails.line,
          column: endPosDetails.column
        }
      };
    }

    function peg$fail(expected) {
      if (peg$currPos < peg$maxFailPos) { return; }

      if (peg$currPos > peg$maxFailPos) {
        peg$maxFailPos = peg$currPos;
        peg$maxFailExpected = [];
      }

      peg$maxFailExpected.push(expected);
    }

    function peg$buildStructuredError(expected, found, location) {
      return new peg$SyntaxError(
        peg$SyntaxError.buildMessage(expected, found),
        expected,
        found,
        location
      );
    }

    function peg$parseBibliography() {
      var s0, s1, s2, s3;

      s0 = peg$currPos;
      s1 = peg$parse__();
      if (s1 !== peg$FAILED) {
        s2 = [];
        s3 = peg$parseNode();
        while (s3 !== peg$FAILED) {
          s2.push(s3);
          s3 = peg$parseNode();
        }
        if (s2 !== peg$FAILED) {
          s3 = peg$parse__();
          if (s3 !== peg$FAILED) {
            peg$savedPos = s0;
            s1 = peg$c0(s2);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseComment() {
      var s0, s1, s2, s3, s4, s5, s6, s7;

      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 64) {
        s1 = peg$c1;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c2); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$parse__();
        if (s2 !== peg$FAILED) {
          if (input.substr(peg$currPos, 7).toLowerCase() === peg$c3) {
            s3 = input.substr(peg$currPos, 7);
            peg$currPos += 7;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c4); }
          }
          if (s3 !== peg$FAILED) {
            s4 = peg$parse__h();
            if (s4 !== peg$FAILED) {
              s5 = peg$parseBracedComment();
              if (s5 !== peg$FAILED) {
                peg$savedPos = s0;
                s1 = peg$c5(s5);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        if (input.charCodeAt(peg$currPos) === 64) {
          s1 = peg$c1;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c2); }
        }
        if (s1 !== peg$FAILED) {
          s2 = peg$parse__();
          if (s2 !== peg$FAILED) {
            if (input.substr(peg$currPos, 7).toLowerCase() === peg$c3) {
              s3 = input.substr(peg$currPos, 7);
              peg$currPos += 7;
            } else {
              s3 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c4); }
            }
            if (s3 !== peg$FAILED) {
              s4 = peg$parse__h();
              if (s4 !== peg$FAILED) {
                s5 = [];
                if (peg$c6.test(input.charAt(peg$currPos))) {
                  s6 = input.charAt(peg$currPos);
                  peg$currPos++;
                } else {
                  s6 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c7); }
                }
                while (s6 !== peg$FAILED) {
                  s5.push(s6);
                  if (peg$c6.test(input.charAt(peg$currPos))) {
                    s6 = input.charAt(peg$currPos);
                    peg$currPos++;
                  } else {
                    s6 = peg$FAILED;
                    if (peg$silentFails === 0) { peg$fail(peg$c7); }
                  }
                }
                if (s5 !== peg$FAILED) {
                  s6 = [];
                  if (peg$c8.test(input.charAt(peg$currPos))) {
                    s7 = input.charAt(peg$currPos);
                    peg$currPos++;
                  } else {
                    s7 = peg$FAILED;
                    if (peg$silentFails === 0) { peg$fail(peg$c9); }
                  }
                  while (s7 !== peg$FAILED) {
                    s6.push(s7);
                    if (peg$c8.test(input.charAt(peg$currPos))) {
                      s7 = input.charAt(peg$currPos);
                      peg$currPos++;
                    } else {
                      s7 = peg$FAILED;
                      if (peg$silentFails === 0) { peg$fail(peg$c9); }
                    }
                  }
                  if (s6 !== peg$FAILED) {
                    peg$savedPos = s0;
                    s1 = peg$c10(s5);
                    s0 = s1;
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
        if (s0 === peg$FAILED) {
          s0 = peg$currPos;
          s1 = peg$currPos;
          if (peg$c11.test(input.charAt(peg$currPos))) {
            s2 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s2 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c12); }
          }
          if (s2 !== peg$FAILED) {
            s3 = [];
            if (peg$c6.test(input.charAt(peg$currPos))) {
              s4 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s4 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c7); }
            }
            while (s4 !== peg$FAILED) {
              s3.push(s4);
              if (peg$c6.test(input.charAt(peg$currPos))) {
                s4 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s4 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c7); }
              }
            }
            if (s3 !== peg$FAILED) {
              s2 = [s2, s3];
              s1 = s2;
            } else {
              peg$currPos = s1;
              s1 = peg$FAILED;
            }
          } else {
            peg$currPos = s1;
            s1 = peg$FAILED;
          }
          if (s1 !== peg$FAILED) {
            s2 = [];
            if (peg$c8.test(input.charAt(peg$currPos))) {
              s3 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s3 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c9); }
            }
            while (s3 !== peg$FAILED) {
              s2.push(s3);
              if (peg$c8.test(input.charAt(peg$currPos))) {
                s3 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s3 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c9); }
              }
            }
            if (s2 !== peg$FAILED) {
              peg$savedPos = s0;
              s1 = peg$c13(s1);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        }
      }

      return s0;
    }

    function peg$parseNode() {
      var s0, s1;

      s0 = peg$currPos;
      s1 = peg$parseComment();
      if (s1 === peg$FAILED) {
        s1 = peg$parsePreambleExpression();
        if (s1 === peg$FAILED) {
          s1 = peg$parseStringDeclaration();
          if (s1 === peg$FAILED) {
            s1 = peg$parseEntry();
          }
        }
      }
      if (s1 !== peg$FAILED) {
        peg$savedPos = s0;
        s1 = peg$c14(s1);
      }
      s0 = s1;

      return s0;
    }

    function peg$parseBracedComment() {
      var s0, s1, s2, s3;

      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 123) {
        s1 = peg$c15;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c16); }
      }
      if (s1 !== peg$FAILED) {
        s2 = [];
        if (peg$c17.test(input.charAt(peg$currPos))) {
          s3 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s3 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c18); }
        }
        if (s3 === peg$FAILED) {
          s3 = peg$parseBracedComment();
        }
        while (s3 !== peg$FAILED) {
          s2.push(s3);
          if (peg$c17.test(input.charAt(peg$currPos))) {
            s3 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c18); }
          }
          if (s3 === peg$FAILED) {
            s3 = peg$parseBracedComment();
          }
        }
        if (s2 !== peg$FAILED) {
          if (input.charCodeAt(peg$currPos) === 125) {
            s3 = peg$c19;
            peg$currPos++;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c20); }
          }
          if (s3 !== peg$FAILED) {
            peg$savedPos = s0;
            s1 = peg$c21(s2);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseEntry() {
      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;

      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 64) {
        s1 = peg$c1;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c2); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$parse__();
        if (s2 !== peg$FAILED) {
          s3 = peg$currPos;
          s4 = [];
          if (peg$c22.test(input.charAt(peg$currPos))) {
            s5 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s5 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c23); }
          }
          if (s5 !== peg$FAILED) {
            while (s5 !== peg$FAILED) {
              s4.push(s5);
              if (peg$c22.test(input.charAt(peg$currPos))) {
                s5 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s5 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c23); }
              }
            }
          } else {
            s4 = peg$FAILED;
          }
          if (s4 !== peg$FAILED) {
            s3 = input.substring(s3, peg$currPos);
          } else {
            s3 = s4;
          }
          if (s3 !== peg$FAILED) {
            s4 = peg$parse__();
            if (s4 !== peg$FAILED) {
              if (peg$c24.test(input.charAt(peg$currPos))) {
                s5 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s5 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c25); }
              }
              if (s5 !== peg$FAILED) {
                s6 = peg$parse__();
                if (s6 !== peg$FAILED) {
                  s7 = peg$parseEntryId();
                  if (s7 === peg$FAILED) {
                    s7 = null;
                  }
                  if (s7 !== peg$FAILED) {
                    s8 = peg$parse__();
                    if (s8 !== peg$FAILED) {
                      s9 = [];
                      s10 = peg$parseField();
                      while (s10 !== peg$FAILED) {
                        s9.push(s10);
                        s10 = peg$parseField();
                      }
                      if (s9 !== peg$FAILED) {
                        s10 = peg$parse__();
                        if (s10 !== peg$FAILED) {
                          if (peg$c26.test(input.charAt(peg$currPos))) {
                            s11 = input.charAt(peg$currPos);
                            peg$currPos++;
                          } else {
                            s11 = peg$FAILED;
                            if (peg$silentFails === 0) { peg$fail(peg$c27); }
                          }
                          if (s11 !== peg$FAILED) {
                            s12 = peg$parse__();
                            if (s12 !== peg$FAILED) {
                              peg$savedPos = s0;
                              s1 = peg$c28(s3, s7, s9);
                              s0 = s1;
                            } else {
                              peg$currPos = s0;
                              s0 = peg$FAILED;
                            }
                          } else {
                            peg$currPos = s0;
                            s0 = peg$FAILED;
                          }
                        } else {
                          peg$currPos = s0;
                          s0 = peg$FAILED;
                        }
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parsePreambleExpression() {
      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;

      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 64) {
        s1 = peg$c1;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c2); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$parse__();
        if (s2 !== peg$FAILED) {
          if (input.substr(peg$currPos, 8).toLowerCase() === peg$c29) {
            s3 = input.substr(peg$currPos, 8);
            peg$currPos += 8;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c30); }
          }
          if (s3 !== peg$FAILED) {
            s4 = peg$parse__();
            if (s4 !== peg$FAILED) {
              if (peg$c24.test(input.charAt(peg$currPos))) {
                s5 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s5 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c25); }
              }
              if (s5 !== peg$FAILED) {
                s6 = peg$parse__();
                if (s6 !== peg$FAILED) {
                  s7 = [];
                  s8 = peg$parseEnvironment();
                  if (s8 === peg$FAILED) {
                    s8 = peg$parseBlock();
                    if (s8 === peg$FAILED) {
                      s8 = peg$parseMath();
                      if (s8 === peg$FAILED) {
                        s8 = peg$parseCommand();
                        if (s8 === peg$FAILED) {
                          s8 = peg$parseText();
                        }
                      }
                    }
                  }
                  while (s8 !== peg$FAILED) {
                    s7.push(s8);
                    s8 = peg$parseEnvironment();
                    if (s8 === peg$FAILED) {
                      s8 = peg$parseBlock();
                      if (s8 === peg$FAILED) {
                        s8 = peg$parseMath();
                        if (s8 === peg$FAILED) {
                          s8 = peg$parseCommand();
                          if (s8 === peg$FAILED) {
                            s8 = peg$parseText();
                          }
                        }
                      }
                    }
                  }
                  if (s7 !== peg$FAILED) {
                    s8 = peg$parse__();
                    if (s8 !== peg$FAILED) {
                      if (peg$c26.test(input.charAt(peg$currPos))) {
                        s9 = input.charAt(peg$currPos);
                        peg$currPos++;
                      } else {
                        s9 = peg$FAILED;
                        if (peg$silentFails === 0) { peg$fail(peg$c27); }
                      }
                      if (s9 !== peg$FAILED) {
                        s10 = peg$parse__();
                        if (s10 !== peg$FAILED) {
                          peg$savedPos = s0;
                          s1 = peg$c31(s5, s7, s9);
                          s0 = s1;
                        } else {
                          peg$currPos = s0;
                          s0 = peg$FAILED;
                        }
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseStringDeclaration() {
      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;

      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 64) {
        s1 = peg$c1;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c2); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$parse__();
        if (s2 !== peg$FAILED) {
          if (input.substr(peg$currPos, 6).toLowerCase() === peg$c32) {
            s3 = input.substr(peg$currPos, 6);
            peg$currPos += 6;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c33); }
          }
          if (s3 !== peg$FAILED) {
            s4 = peg$parse__();
            if (s4 !== peg$FAILED) {
              if (peg$c24.test(input.charAt(peg$currPos))) {
                s5 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s5 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c25); }
              }
              if (s5 !== peg$FAILED) {
                s6 = peg$parse__();
                if (s6 !== peg$FAILED) {
                  s7 = peg$parseVariableName();
                  if (s7 !== peg$FAILED) {
                    s8 = peg$parseFieldSeparator();
                    if (s8 !== peg$FAILED) {
                      s9 = [];
                      s10 = peg$parseRegularValue();
                      if (s10 !== peg$FAILED) {
                        while (s10 !== peg$FAILED) {
                          s9.push(s10);
                          s10 = peg$parseRegularValue();
                        }
                      } else {
                        s9 = peg$FAILED;
                      }
                      if (s9 !== peg$FAILED) {
                        s10 = peg$parse__();
                        if (s10 !== peg$FAILED) {
                          if (peg$c26.test(input.charAt(peg$currPos))) {
                            s11 = input.charAt(peg$currPos);
                            peg$currPos++;
                          } else {
                            s11 = peg$FAILED;
                            if (peg$silentFails === 0) { peg$fail(peg$c27); }
                          }
                          if (s11 !== peg$FAILED) {
                            s12 = peg$parse__();
                            if (s12 !== peg$FAILED) {
                              peg$savedPos = s0;
                              s1 = peg$c34(s7, s9);
                              s0 = s1;
                            } else {
                              peg$currPos = s0;
                              s0 = peg$FAILED;
                            }
                          } else {
                            peg$currPos = s0;
                            s0 = peg$FAILED;
                          }
                        } else {
                          peg$currPos = s0;
                          s0 = peg$FAILED;
                        }
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseEntryId() {
      var s0, s1, s2, s3, s4;

      s0 = peg$currPos;
      s1 = peg$parse__();
      if (s1 !== peg$FAILED) {
        s2 = peg$currPos;
        s3 = [];
        if (peg$c35.test(input.charAt(peg$currPos))) {
          s4 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s4 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c36); }
        }
        while (s4 !== peg$FAILED) {
          s3.push(s4);
          if (peg$c35.test(input.charAt(peg$currPos))) {
            s4 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s4 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c36); }
          }
        }
        if (s3 !== peg$FAILED) {
          s2 = input.substring(s2, peg$currPos);
        } else {
          s2 = s3;
        }
        if (s2 !== peg$FAILED) {
          s3 = peg$parse__();
          if (s3 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 44) {
              s4 = peg$c37;
              peg$currPos++;
            } else {
              s4 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c38); }
            }
            if (s4 !== peg$FAILED) {
              peg$savedPos = s0;
              s1 = peg$c39(s2);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseField() {
      var s0, s1, s2, s3, s4, s5, s6, s7, s8;

      s0 = peg$currPos;
      s1 = peg$parseFieldName();
      if (s1 !== peg$FAILED) {
        peg$savedPos = peg$currPos;
        s2 = peg$c40(s1);
        if (s2) {
          s2 = void 0;
        } else {
          s2 = peg$FAILED;
        }
        if (s2 !== peg$FAILED) {
          s3 = peg$parseFieldSeparator();
          if (s3 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 123) {
              s4 = peg$c15;
              peg$currPos++;
            } else {
              s4 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c16); }
            }
            if (s4 !== peg$FAILED) {
              s5 = peg$currPos;
              peg$silentFails++;
              if (input.charCodeAt(peg$currPos) === 123) {
                s6 = peg$c15;
                peg$currPos++;
              } else {
                s6 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c16); }
              }
              peg$silentFails--;
              if (s6 !== peg$FAILED) {
                peg$currPos = s5;
                s5 = void 0;
              } else {
                s5 = peg$FAILED;
              }
              if (s5 !== peg$FAILED) {
                s6 = peg$parseVerbatimFieldValue();
                if (s6 !== peg$FAILED) {
                  if (input.charCodeAt(peg$currPos) === 125) {
                    s7 = peg$c19;
                    peg$currPos++;
                  } else {
                    s7 = peg$FAILED;
                    if (peg$silentFails === 0) { peg$fail(peg$c20); }
                  }
                  if (s7 !== peg$FAILED) {
                    s8 = peg$parseFieldTerminator();
                    if (s8 !== peg$FAILED) {
                      peg$savedPos = s0;
                      s1 = peg$c41(s1, s6);
                      s0 = s1;
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        s1 = peg$parseFieldName();
        if (s1 !== peg$FAILED) {
          peg$savedPos = peg$currPos;
          s2 = peg$c42(s1);
          if (s2) {
            s2 = void 0;
          } else {
            s2 = peg$FAILED;
          }
          if (s2 !== peg$FAILED) {
            s3 = peg$parseFieldSeparator();
            if (s3 !== peg$FAILED) {
              s4 = peg$parseVerbatimFieldValue();
              if (s4 !== peg$FAILED) {
                s5 = peg$parseFieldTerminator();
                if (s5 !== peg$FAILED) {
                  peg$savedPos = s0;
                  s1 = peg$c43(s1, s4);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
        if (s0 === peg$FAILED) {
          s0 = peg$currPos;
          s1 = peg$parseFieldName();
          if (s1 !== peg$FAILED) {
            s2 = peg$parseFieldSeparator();
            if (s2 !== peg$FAILED) {
              s3 = peg$parseFieldValue();
              if (s3 !== peg$FAILED) {
                s4 = peg$parseFieldTerminator();
                if (s4 !== peg$FAILED) {
                  peg$savedPos = s0;
                  s1 = peg$c44(s1, s3);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        }
      }

      return s0;
    }

    function peg$parseFieldName() {
      var s0, s1, s2, s3, s4;

      s0 = peg$currPos;
      s1 = peg$parse__();
      if (s1 !== peg$FAILED) {
        s2 = peg$currPos;
        s3 = [];
        if (peg$c45.test(input.charAt(peg$currPos))) {
          s4 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s4 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c46); }
        }
        if (s4 !== peg$FAILED) {
          while (s4 !== peg$FAILED) {
            s3.push(s4);
            if (peg$c45.test(input.charAt(peg$currPos))) {
              s4 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s4 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c46); }
            }
          }
        } else {
          s3 = peg$FAILED;
        }
        if (s3 !== peg$FAILED) {
          s2 = input.substring(s2, peg$currPos);
        } else {
          s2 = s3;
        }
        if (s2 !== peg$FAILED) {
          peg$savedPos = s0;
          s1 = peg$c47(s2);
          s0 = s1;
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseVerbatimFieldValue() {
      var s0, s1, s2, s3;

      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 34) {
        s1 = peg$c48;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c49); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$parseTextNoQuotes();
        if (s2 === peg$FAILED) {
          s2 = null;
        }
        if (s2 !== peg$FAILED) {
          if (input.charCodeAt(peg$currPos) === 34) {
            s3 = peg$c48;
            peg$currPos++;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c49); }
          }
          if (s3 !== peg$FAILED) {
            peg$savedPos = s0;
            s1 = peg$c50(s2);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        if (input.charCodeAt(peg$currPos) === 123) {
          s1 = peg$c15;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c16); }
        }
        if (s1 !== peg$FAILED) {
          s2 = [];
          s3 = peg$parseVerbatimText();
          while (s3 !== peg$FAILED) {
            s2.push(s3);
            s3 = peg$parseVerbatimText();
          }
          if (s2 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 125) {
              s3 = peg$c19;
              peg$currPos++;
            } else {
              s3 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c20); }
            }
            if (s3 !== peg$FAILED) {
              peg$savedPos = s0;
              s1 = peg$c51(s2);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      }

      return s0;
    }

    function peg$parseVerbatimText() {
      var s0, s1, s2, s3;

      s0 = peg$currPos;
      s1 = peg$currPos;
      s2 = [];
      if (peg$c17.test(input.charAt(peg$currPos))) {
        s3 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s3 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c18); }
      }
      if (s3 !== peg$FAILED) {
        while (s3 !== peg$FAILED) {
          s2.push(s3);
          if (peg$c17.test(input.charAt(peg$currPos))) {
            s3 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c18); }
          }
        }
      } else {
        s2 = peg$FAILED;
      }
      if (s2 !== peg$FAILED) {
        s1 = input.substring(s1, peg$currPos);
      } else {
        s1 = s2;
      }
      if (s1 !== peg$FAILED) {
        peg$savedPos = s0;
        s1 = peg$c52(s1);
      }
      s0 = s1;
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        if (input.charCodeAt(peg$currPos) === 123) {
          s1 = peg$c15;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c16); }
        }
        if (s1 !== peg$FAILED) {
          s2 = [];
          s3 = peg$parseVerbatimText();
          while (s3 !== peg$FAILED) {
            s2.push(s3);
            s3 = peg$parseVerbatimText();
          }
          if (s2 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 125) {
              s3 = peg$c19;
              peg$currPos++;
            } else {
              s3 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c20); }
            }
            if (s3 !== peg$FAILED) {
              peg$savedPos = s0;
              s1 = peg$c53(s2);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      }

      return s0;
    }

    function peg$parseFieldValue() {
      var s0, s1, s2, s3;

      s0 = peg$parseNumber();
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        peg$savedPos = peg$currPos;
        s1 = peg$c54();
        if (s1) {
          s1 = void 0;
        } else {
          s1 = peg$FAILED;
        }
        if (s1 !== peg$FAILED) {
          s2 = [];
          s3 = peg$parseRegularValue();
          if (s3 === peg$FAILED) {
            s3 = peg$parseStringValue();
          }
          while (s3 !== peg$FAILED) {
            s2.push(s3);
            s3 = peg$parseRegularValue();
            if (s3 === peg$FAILED) {
              s3 = peg$parseStringValue();
            }
          }
          if (s2 !== peg$FAILED) {
            peg$savedPos = s0;
            s1 = peg$c55(s2);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      }

      return s0;
    }

    function peg$parseRegularValue() {
      var s0, s1, s2, s3, s4, s5;

      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 34) {
        s1 = peg$c48;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c49); }
      }
      if (s1 !== peg$FAILED) {
        s2 = [];
        s3 = peg$parseEnvironment();
        if (s3 === peg$FAILED) {
          s3 = peg$parseBlock();
          if (s3 === peg$FAILED) {
            s3 = peg$parseMath();
            if (s3 === peg$FAILED) {
              s3 = peg$parseCommand();
              if (s3 === peg$FAILED) {
                s3 = peg$parseTextNoQuotes();
              }
            }
          }
        }
        while (s3 !== peg$FAILED) {
          s2.push(s3);
          s3 = peg$parseEnvironment();
          if (s3 === peg$FAILED) {
            s3 = peg$parseBlock();
            if (s3 === peg$FAILED) {
              s3 = peg$parseMath();
              if (s3 === peg$FAILED) {
                s3 = peg$parseCommand();
                if (s3 === peg$FAILED) {
                  s3 = peg$parseTextNoQuotes();
                }
              }
            }
          }
        }
        if (s2 !== peg$FAILED) {
          if (input.charCodeAt(peg$currPos) === 34) {
            s3 = peg$c48;
            peg$currPos++;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c49); }
          }
          if (s3 !== peg$FAILED) {
            s4 = peg$parseConcat();
            if (s4 === peg$FAILED) {
              s4 = null;
            }
            if (s4 !== peg$FAILED) {
              peg$savedPos = s0;
              s1 = peg$c56(s2);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        if (input.substr(peg$currPos, 6) === peg$c57) {
          s1 = peg$c57;
          peg$currPos += 6;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c58); }
        }
        if (s1 !== peg$FAILED) {
          s2 = peg$currPos;
          peg$silentFails++;
          if (peg$c59.test(input.charAt(peg$currPos))) {
            s3 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c60); }
          }
          peg$silentFails--;
          if (s3 === peg$FAILED) {
            s2 = void 0;
          } else {
            peg$currPos = s2;
            s2 = peg$FAILED;
          }
          if (s2 !== peg$FAILED) {
            s3 = [];
            s4 = peg$parseVerbatimText();
            while (s4 !== peg$FAILED) {
              s3.push(s4);
              s4 = peg$parseVerbatimText();
            }
            if (s3 !== peg$FAILED) {
              if (input.charCodeAt(peg$currPos) === 125) {
                s4 = peg$c19;
                peg$currPos++;
              } else {
                s4 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c20); }
              }
              if (s4 !== peg$FAILED) {
                s5 = peg$parseConcat();
                if (s5 === peg$FAILED) {
                  s5 = null;
                }
                if (s5 !== peg$FAILED) {
                  peg$savedPos = s0;
                  s1 = peg$c51(s3);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
        if (s0 === peg$FAILED) {
          s0 = peg$currPos;
          if (input.charCodeAt(peg$currPos) === 123) {
            s1 = peg$c15;
            peg$currPos++;
          } else {
            s1 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c16); }
          }
          if (s1 !== peg$FAILED) {
            s2 = [];
            s3 = peg$parseEnvironment();
            if (s3 === peg$FAILED) {
              s3 = peg$parseBlock();
              if (s3 === peg$FAILED) {
                s3 = peg$parseMath();
                if (s3 === peg$FAILED) {
                  s3 = peg$parseCommand();
                  if (s3 === peg$FAILED) {
                    s3 = peg$parseText();
                  }
                }
              }
            }
            while (s3 !== peg$FAILED) {
              s2.push(s3);
              s3 = peg$parseEnvironment();
              if (s3 === peg$FAILED) {
                s3 = peg$parseBlock();
                if (s3 === peg$FAILED) {
                  s3 = peg$parseMath();
                  if (s3 === peg$FAILED) {
                    s3 = peg$parseCommand();
                    if (s3 === peg$FAILED) {
                      s3 = peg$parseText();
                    }
                  }
                }
              }
            }
            if (s2 !== peg$FAILED) {
              if (input.charCodeAt(peg$currPos) === 125) {
                s3 = peg$c19;
                peg$currPos++;
              } else {
                s3 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c20); }
              }
              if (s3 !== peg$FAILED) {
                s4 = peg$parseConcat();
                if (s4 === peg$FAILED) {
                  s4 = null;
                }
                if (s4 !== peg$FAILED) {
                  peg$savedPos = s0;
                  s1 = peg$c56(s2);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
          if (s0 === peg$FAILED) {
            s0 = peg$currPos;
            s1 = peg$parseStringReference();
            if (s1 !== peg$FAILED) {
              s2 = peg$parseConcat();
              if (s2 === peg$FAILED) {
                s2 = null;
              }
              if (s2 !== peg$FAILED) {
                peg$savedPos = s0;
                s1 = peg$c56(s1);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          }
        }
      }

      return s0;
    }

    function peg$parseStringValue() {
      var s0, s1, s2;

      s0 = peg$currPos;
      s1 = peg$parseStringReference();
      if (s1 !== peg$FAILED) {
        s2 = peg$parseConcat();
        if (s2 === peg$FAILED) {
          s2 = null;
        }
        if (s2 !== peg$FAILED) {
          peg$savedPos = s0;
          s1 = peg$c56(s1);
          s0 = s1;
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseText() {
      var s0, s1, s2;

      s0 = peg$currPos;
      s1 = [];
      if (peg$c61.test(input.charAt(peg$currPos))) {
        s2 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s2 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c62); }
      }
      if (s2 !== peg$FAILED) {
        while (s2 !== peg$FAILED) {
          s1.push(s2);
          if (peg$c61.test(input.charAt(peg$currPos))) {
            s2 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s2 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c62); }
          }
        }
      } else {
        s1 = peg$FAILED;
      }
      if (s1 !== peg$FAILED) {
        peg$savedPos = s0;
        s1 = peg$c63(s1);
      }
      s0 = s1;

      return s0;
    }

    function peg$parseTextNoQuotes() {
      var s0, s1, s2;

      s0 = peg$currPos;
      s1 = [];
      if (peg$c64.test(input.charAt(peg$currPos))) {
        s2 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s2 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c65); }
      }
      if (s2 !== peg$FAILED) {
        while (s2 !== peg$FAILED) {
          s1.push(s2);
          if (peg$c64.test(input.charAt(peg$currPos))) {
            s2 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s2 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c65); }
          }
        }
      } else {
        s1 = peg$FAILED;
      }
      if (s1 !== peg$FAILED) {
        peg$savedPos = s0;
        s1 = peg$c63(s1);
      }
      s0 = s1;

      return s0;
    }

    function peg$parseNumber() {
      var s0, s1, s2, s3;

      s0 = peg$currPos;
      s1 = peg$currPos;
      s2 = [];
      if (peg$c66.test(input.charAt(peg$currPos))) {
        s3 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s3 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c67); }
      }
      if (s3 !== peg$FAILED) {
        while (s3 !== peg$FAILED) {
          s2.push(s3);
          if (peg$c66.test(input.charAt(peg$currPos))) {
            s3 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c67); }
          }
        }
      } else {
        s2 = peg$FAILED;
      }
      if (s2 !== peg$FAILED) {
        s1 = input.substring(s1, peg$currPos);
      } else {
        s1 = s2;
      }
      if (s1 !== peg$FAILED) {
        peg$savedPos = s0;
        s1 = peg$c68(s1);
      }
      s0 = s1;

      return s0;
    }

    function peg$parseStringReference() {
      var s0, s1;

      s0 = peg$currPos;
      s1 = peg$parseVariableName();
      if (s1 !== peg$FAILED) {
        peg$savedPos = s0;
        s1 = peg$c69(s1);
      }
      s0 = s1;

      return s0;
    }

    function peg$parseEnvironment() {
      var s0, s1, s2, s3, s4, s5, s6, s7, s8;

      s0 = peg$currPos;
      if (input.substr(peg$currPos, 7) === peg$c70) {
        s1 = peg$c70;
        peg$currPos += 7;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c71); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$currPos;
        s3 = [];
        if (peg$c72.test(input.charAt(peg$currPos))) {
          s4 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s4 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c73); }
        }
        if (s4 !== peg$FAILED) {
          while (s4 !== peg$FAILED) {
            s3.push(s4);
            if (peg$c72.test(input.charAt(peg$currPos))) {
              s4 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s4 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c73); }
            }
          }
        } else {
          s3 = peg$FAILED;
        }
        if (s3 !== peg$FAILED) {
          s2 = input.substring(s2, peg$currPos);
        } else {
          s2 = s3;
        }
        if (s2 !== peg$FAILED) {
          if (input.charCodeAt(peg$currPos) === 125) {
            s3 = peg$c19;
            peg$currPos++;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c20); }
          }
          if (s3 !== peg$FAILED) {
            s4 = [];
            s5 = peg$parseEnvironment();
            if (s5 === peg$FAILED) {
              s5 = peg$parseBlock();
              if (s5 === peg$FAILED) {
                s5 = peg$parseCommand();
                if (s5 === peg$FAILED) {
                  s5 = peg$parseMath();
                  if (s5 === peg$FAILED) {
                    s5 = peg$parseText();
                  }
                }
              }
            }
            while (s5 !== peg$FAILED) {
              s4.push(s5);
              s5 = peg$parseEnvironment();
              if (s5 === peg$FAILED) {
                s5 = peg$parseBlock();
                if (s5 === peg$FAILED) {
                  s5 = peg$parseCommand();
                  if (s5 === peg$FAILED) {
                    s5 = peg$parseMath();
                    if (s5 === peg$FAILED) {
                      s5 = peg$parseText();
                    }
                  }
                }
              }
            }
            if (s4 !== peg$FAILED) {
              if (input.substr(peg$currPos, 5) === peg$c74) {
                s5 = peg$c74;
                peg$currPos += 5;
              } else {
                s5 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c75); }
              }
              if (s5 !== peg$FAILED) {
                s6 = peg$currPos;
                s7 = [];
                if (peg$c72.test(input.charAt(peg$currPos))) {
                  s8 = input.charAt(peg$currPos);
                  peg$currPos++;
                } else {
                  s8 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c73); }
                }
                if (s8 !== peg$FAILED) {
                  while (s8 !== peg$FAILED) {
                    s7.push(s8);
                    if (peg$c72.test(input.charAt(peg$currPos))) {
                      s8 = input.charAt(peg$currPos);
                      peg$currPos++;
                    } else {
                      s8 = peg$FAILED;
                      if (peg$silentFails === 0) { peg$fail(peg$c73); }
                    }
                  }
                } else {
                  s7 = peg$FAILED;
                }
                if (s7 !== peg$FAILED) {
                  s6 = input.substring(s6, peg$currPos);
                } else {
                  s6 = s7;
                }
                if (s6 !== peg$FAILED) {
                  if (input.charCodeAt(peg$currPos) === 125) {
                    s7 = peg$c19;
                    peg$currPos++;
                  } else {
                    s7 = peg$FAILED;
                    if (peg$silentFails === 0) { peg$fail(peg$c20); }
                  }
                  if (s7 !== peg$FAILED) {
                    peg$savedPos = peg$currPos;
                    s8 = peg$c76(s2, s4, s6);
                    if (s8) {
                      s8 = void 0;
                    } else {
                      s8 = peg$FAILED;
                    }
                    if (s8 !== peg$FAILED) {
                      peg$savedPos = s0;
                      s1 = peg$c77(s2, s4);
                      s0 = s1;
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseBlock() {
      var s0, s1, s2, s3, s4, s5, s6;

      s0 = peg$currPos;
      if (input.substr(peg$currPos, 2) === peg$c78) {
        s1 = peg$c78;
        peg$currPos += 2;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c79); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$parseExtendedDiacritic();
        if (s2 !== peg$FAILED) {
          s3 = peg$parse__();
          if (s3 !== peg$FAILED) {
            if (peg$c72.test(input.charAt(peg$currPos))) {
              s4 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s4 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c73); }
            }
            if (s4 === peg$FAILED) {
              s4 = peg$currPos;
              if (input.charCodeAt(peg$currPos) === 92) {
                s5 = peg$c80;
                peg$currPos++;
              } else {
                s5 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c81); }
              }
              if (s5 !== peg$FAILED) {
                if (peg$c82.test(input.charAt(peg$currPos))) {
                  s6 = input.charAt(peg$currPos);
                  peg$currPos++;
                } else {
                  s6 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c83); }
                }
                if (s6 !== peg$FAILED) {
                  s5 = [s5, s6];
                  s4 = s5;
                } else {
                  peg$currPos = s4;
                  s4 = peg$FAILED;
                }
              } else {
                peg$currPos = s4;
                s4 = peg$FAILED;
              }
            }
            if (s4 !== peg$FAILED) {
              if (input.charCodeAt(peg$currPos) === 125) {
                s5 = peg$c19;
                peg$currPos++;
              } else {
                s5 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c20); }
              }
              if (s5 !== peg$FAILED) {
                peg$savedPos = s0;
                s1 = peg$c84(s2, s4);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        if (input.substr(peg$currPos, 6) === peg$c57) {
          s1 = peg$c57;
          peg$currPos += 6;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c58); }
        }
        if (s1 !== peg$FAILED) {
          s2 = peg$currPos;
          peg$silentFails++;
          if (peg$c59.test(input.charAt(peg$currPos))) {
            s3 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c60); }
          }
          peg$silentFails--;
          if (s3 === peg$FAILED) {
            s2 = void 0;
          } else {
            peg$currPos = s2;
            s2 = peg$FAILED;
          }
          if (s2 !== peg$FAILED) {
            s3 = [];
            s4 = peg$parseVerbatimText();
            while (s4 !== peg$FAILED) {
              s3.push(s4);
              s4 = peg$parseVerbatimText();
            }
            if (s3 !== peg$FAILED) {
              if (input.charCodeAt(peg$currPos) === 125) {
                s4 = peg$c19;
                peg$currPos++;
              } else {
                s4 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c20); }
              }
              if (s4 !== peg$FAILED) {
                peg$savedPos = s0;
                s1 = peg$c85(s3);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
        if (s0 === peg$FAILED) {
          s0 = peg$currPos;
          if (input.charCodeAt(peg$currPos) === 123) {
            s1 = peg$c15;
            peg$currPos++;
          } else {
            s1 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c16); }
          }
          if (s1 !== peg$FAILED) {
            s2 = [];
            s3 = peg$parseEnvironment();
            if (s3 === peg$FAILED) {
              s3 = peg$parseBlock();
              if (s3 === peg$FAILED) {
                s3 = peg$parseCommand();
                if (s3 === peg$FAILED) {
                  s3 = peg$parseMath();
                  if (s3 === peg$FAILED) {
                    s3 = peg$parseText();
                  }
                }
              }
            }
            while (s3 !== peg$FAILED) {
              s2.push(s3);
              s3 = peg$parseEnvironment();
              if (s3 === peg$FAILED) {
                s3 = peg$parseBlock();
                if (s3 === peg$FAILED) {
                  s3 = peg$parseCommand();
                  if (s3 === peg$FAILED) {
                    s3 = peg$parseMath();
                    if (s3 === peg$FAILED) {
                      s3 = peg$parseText();
                    }
                  }
                }
              }
            }
            if (s2 !== peg$FAILED) {
              if (input.charCodeAt(peg$currPos) === 125) {
                s3 = peg$c19;
                peg$currPos++;
              } else {
                s3 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c20); }
              }
              if (s3 !== peg$FAILED) {
                peg$savedPos = s0;
                s1 = peg$c86(s2);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        }
      }

      return s0;
    }

    function peg$parseMath() {
      var s0, s1, s2, s3, s4, s5, s6;

      s0 = peg$currPos;
      peg$savedPos = peg$currPos;
      s1 = peg$c87();
      if (s1) {
        s1 = void 0;
      } else {
        s1 = peg$FAILED;
      }
      if (s1 !== peg$FAILED) {
        if (input.charCodeAt(peg$currPos) === 36) {
          s2 = peg$c88;
          peg$currPos++;
        } else {
          s2 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c89); }
        }
        if (s2 === peg$FAILED) {
          if (input.substr(peg$currPos, 2) === peg$c90) {
            s2 = peg$c90;
            peg$currPos += 2;
          } else {
            s2 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c91); }
          }
        }
        if (s2 !== peg$FAILED) {
          peg$savedPos = peg$currPos;
          s3 = peg$c92();
          if (s3) {
            s3 = void 0;
          } else {
            s3 = peg$FAILED;
          }
          if (s3 !== peg$FAILED) {
            s4 = [];
            s5 = peg$parseBlock();
            if (s5 === peg$FAILED) {
              s5 = peg$parseCommand();
              if (s5 === peg$FAILED) {
                s5 = peg$parseText();
              }
            }
            while (s5 !== peg$FAILED) {
              s4.push(s5);
              s5 = peg$parseBlock();
              if (s5 === peg$FAILED) {
                s5 = peg$parseCommand();
                if (s5 === peg$FAILED) {
                  s5 = peg$parseText();
                }
              }
            }
            if (s4 !== peg$FAILED) {
              if (input.charCodeAt(peg$currPos) === 36) {
                s5 = peg$c88;
                peg$currPos++;
              } else {
                s5 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c89); }
              }
              if (s5 === peg$FAILED) {
                if (input.substr(peg$currPos, 2) === peg$c90) {
                  s5 = peg$c90;
                  peg$currPos += 2;
                } else {
                  s5 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c91); }
                }
              }
              if (s5 !== peg$FAILED) {
                peg$savedPos = peg$currPos;
                s6 = peg$c93();
                if (s6) {
                  s6 = void 0;
                } else {
                  s6 = peg$FAILED;
                }
                if (s6 !== peg$FAILED) {
                  peg$savedPos = s0;
                  s1 = peg$c94(s2, s4);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseLineComment() {
      var s0, s1, s2, s3, s4, s5;

      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 37) {
        s1 = peg$c95;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c96); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$parse__h();
        if (s2 !== peg$FAILED) {
          s3 = peg$currPos;
          s4 = [];
          if (peg$c97.test(input.charAt(peg$currPos))) {
            s5 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s5 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c98); }
          }
          if (s5 !== peg$FAILED) {
            while (s5 !== peg$FAILED) {
              s4.push(s5);
              if (peg$c97.test(input.charAt(peg$currPos))) {
                s5 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s5 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c98); }
              }
            }
          } else {
            s4 = peg$FAILED;
          }
          if (s4 !== peg$FAILED) {
            s3 = input.substring(s3, peg$currPos);
          } else {
            s3 = s4;
          }
          if (s3 !== peg$FAILED) {
            s4 = [];
            s5 = peg$parseEOL();
            if (s5 !== peg$FAILED) {
              while (s5 !== peg$FAILED) {
                s4.push(s5);
                s5 = peg$parseEOL();
              }
            } else {
              s4 = peg$FAILED;
            }
            if (s4 !== peg$FAILED) {
              peg$savedPos = s0;
              s1 = peg$c99(s3);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseCommand() {
      var s0;

      s0 = peg$parseScriptCommand();
      if (s0 === peg$FAILED) {
        s0 = peg$parseDiacriticCommand();
        if (s0 === peg$FAILED) {
          s0 = peg$parseRegularCommand();
          if (s0 === peg$FAILED) {
            s0 = peg$parseSymbolCommand();
          }
        }
      }

      return s0;
    }

    function peg$parseScriptCommand() {
      var s0, s1, s2, s3;

      s0 = peg$currPos;
      if (peg$c100.test(input.charAt(peg$currPos))) {
        s1 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c101); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$parse__h();
        if (s2 !== peg$FAILED) {
          s3 = peg$parseRequiredArgument();
          if (s3 !== peg$FAILED) {
            peg$savedPos = s0;
            s1 = peg$c102(s1, s3);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseDiacriticCommand() {
      var s0, s1, s2, s3, s4, s5, s6;

      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 92) {
        s1 = peg$c80;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c81); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$parseSimpleDiacritic();
        if (s2 !== peg$FAILED) {
          s3 = peg$parse__();
          if (s3 !== peg$FAILED) {
            if (peg$c72.test(input.charAt(peg$currPos))) {
              s4 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s4 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c73); }
            }
            if (s4 === peg$FAILED) {
              s4 = peg$currPos;
              if (input.charCodeAt(peg$currPos) === 92) {
                s5 = peg$c80;
                peg$currPos++;
              } else {
                s5 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c81); }
              }
              if (s5 !== peg$FAILED) {
                if (peg$c82.test(input.charAt(peg$currPos))) {
                  s6 = input.charAt(peg$currPos);
                  peg$currPos++;
                } else {
                  s6 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c83); }
                }
                if (s6 !== peg$FAILED) {
                  s5 = [s5, s6];
                  s4 = s5;
                } else {
                  peg$currPos = s4;
                  s4 = peg$FAILED;
                }
              } else {
                peg$currPos = s4;
                s4 = peg$FAILED;
              }
            }
            if (s4 !== peg$FAILED) {
              peg$savedPos = s0;
              s1 = peg$c84(s2, s4);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        if (input.charCodeAt(peg$currPos) === 92) {
          s1 = peg$c80;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c81); }
        }
        if (s1 !== peg$FAILED) {
          s2 = peg$parseExtendedDiacritic();
          if (s2 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 123) {
              s3 = peg$c15;
              peg$currPos++;
            } else {
              s3 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c16); }
            }
            if (s3 !== peg$FAILED) {
              if (peg$c72.test(input.charAt(peg$currPos))) {
                s4 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s4 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c73); }
              }
              if (s4 === peg$FAILED) {
                s4 = peg$currPos;
                if (input.charCodeAt(peg$currPos) === 92) {
                  s5 = peg$c80;
                  peg$currPos++;
                } else {
                  s5 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c81); }
                }
                if (s5 !== peg$FAILED) {
                  if (peg$c82.test(input.charAt(peg$currPos))) {
                    s6 = input.charAt(peg$currPos);
                    peg$currPos++;
                  } else {
                    s6 = peg$FAILED;
                    if (peg$silentFails === 0) { peg$fail(peg$c83); }
                  }
                  if (s6 !== peg$FAILED) {
                    s5 = [s5, s6];
                    s4 = s5;
                  } else {
                    peg$currPos = s4;
                    s4 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s4;
                  s4 = peg$FAILED;
                }
              }
              if (s4 !== peg$FAILED) {
                if (input.charCodeAt(peg$currPos) === 125) {
                  s5 = peg$c19;
                  peg$currPos++;
                } else {
                  s5 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c20); }
                }
                if (s5 !== peg$FAILED) {
                  peg$savedPos = s0;
                  s1 = peg$c84(s2, s4);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
        if (s0 === peg$FAILED) {
          s0 = peg$currPos;
          if (input.charCodeAt(peg$currPos) === 92) {
            s1 = peg$c80;
            peg$currPos++;
          } else {
            s1 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c81); }
          }
          if (s1 !== peg$FAILED) {
            s2 = peg$parseExtendedDiacritic();
            if (s2 !== peg$FAILED) {
              s3 = peg$currPos;
              peg$silentFails++;
              if (input.charCodeAt(peg$currPos) === 123) {
                s4 = peg$c15;
                peg$currPos++;
              } else {
                s4 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c16); }
              }
              peg$silentFails--;
              if (s4 !== peg$FAILED) {
                peg$currPos = s3;
                s3 = void 0;
              } else {
                s3 = peg$FAILED;
              }
              if (s3 !== peg$FAILED) {
                s4 = peg$parseRegularValue();
                if (s4 !== peg$FAILED) {
                  peg$savedPos = s0;
                  s1 = peg$c103(s2, s4);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        }
      }

      return s0;
    }

    function peg$parseSymbolCommand() {
      var s0, s1, s2, s3;

      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 92) {
        s1 = peg$c80;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c81); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$currPos;
        if (peg$c104.test(input.charAt(peg$currPos))) {
          s3 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s3 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c105); }
        }
        if (s3 !== peg$FAILED) {
          s2 = input.substring(s2, peg$currPos);
        } else {
          s2 = s3;
        }
        if (s2 !== peg$FAILED) {
          peg$savedPos = s0;
          s1 = peg$c106(s2);
          s0 = s1;
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseRegularCommand() {
      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;

      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 92) {
        s1 = peg$c80;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c81); }
      }
      if (s1 !== peg$FAILED) {
        if (input.substr(peg$currPos, 10) === peg$c107) {
          s2 = peg$c107;
          peg$currPos += 10;
        } else {
          s2 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c108); }
        }
        if (s2 !== peg$FAILED) {
          s3 = peg$parseBlock();
          if (s3 !== peg$FAILED) {
            peg$savedPos = peg$currPos;
            s4 = peg$c109(s2, s3);
            if (s4) {
              s4 = void 0;
            } else {
              s4 = peg$FAILED;
            }
            if (s4 !== peg$FAILED) {
              s5 = [];
              s6 = peg$parseOptionalArgument();
              while (s6 !== peg$FAILED) {
                s5.push(s6);
                s6 = peg$parseOptionalArgument();
              }
              if (s5 !== peg$FAILED) {
                s6 = peg$parseRequiredArgument();
                if (s6 !== peg$FAILED) {
                  peg$savedPos = s0;
                  s1 = peg$c110(s2, s3, s5, s6);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        if (input.charCodeAt(peg$currPos) === 92) {
          s1 = peg$c80;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c81); }
        }
        if (s1 !== peg$FAILED) {
          s2 = peg$currPos;
          peg$silentFails++;
          if (input.substr(peg$currPos, 5) === peg$c111) {
            s3 = peg$c111;
            peg$currPos += 5;
          } else {
            s3 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c112); }
          }
          peg$silentFails--;
          if (s3 === peg$FAILED) {
            s2 = void 0;
          } else {
            peg$currPos = s2;
            s2 = peg$FAILED;
          }
          if (s2 !== peg$FAILED) {
            s3 = peg$currPos;
            peg$silentFails++;
            if (input.substr(peg$currPos, 3) === peg$c113) {
              s4 = peg$c113;
              peg$currPos += 3;
            } else {
              s4 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c114); }
            }
            peg$silentFails--;
            if (s4 === peg$FAILED) {
              s3 = void 0;
            } else {
              peg$currPos = s3;
              s3 = peg$FAILED;
            }
            if (s3 !== peg$FAILED) {
              s4 = peg$currPos;
              s5 = [];
              if (peg$c22.test(input.charAt(peg$currPos))) {
                s6 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s6 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c23); }
              }
              if (s6 !== peg$FAILED) {
                while (s6 !== peg$FAILED) {
                  s5.push(s6);
                  if (peg$c22.test(input.charAt(peg$currPos))) {
                    s6 = input.charAt(peg$currPos);
                    peg$currPos++;
                  } else {
                    s6 = peg$FAILED;
                    if (peg$silentFails === 0) { peg$fail(peg$c23); }
                  }
                }
              } else {
                s5 = peg$FAILED;
              }
              if (s5 !== peg$FAILED) {
                s4 = input.substring(s4, peg$currPos);
              } else {
                s4 = s5;
              }
              if (s4 !== peg$FAILED) {
                peg$savedPos = peg$currPos;
                s5 = peg$c115(s4);
                if (s5) {
                  s5 = void 0;
                } else {
                  s5 = peg$FAILED;
                }
                if (s5 !== peg$FAILED) {
                  s6 = [];
                  s7 = peg$parseOptionalArgument();
                  while (s7 !== peg$FAILED) {
                    s6.push(s7);
                    s7 = peg$parseOptionalArgument();
                  }
                  if (s6 !== peg$FAILED) {
                    s7 = peg$parse__h();
                    if (s7 !== peg$FAILED) {
                      s8 = peg$currPos;
                      peg$silentFails++;
                      if (input.charCodeAt(peg$currPos) === 123) {
                        s9 = peg$c15;
                        peg$currPos++;
                      } else {
                        s9 = peg$FAILED;
                        if (peg$silentFails === 0) { peg$fail(peg$c16); }
                      }
                      peg$silentFails--;
                      if (s9 !== peg$FAILED) {
                        peg$currPos = s8;
                        s8 = void 0;
                      } else {
                        s8 = peg$FAILED;
                      }
                      if (s8 !== peg$FAILED) {
                        s9 = peg$parseVerbatimFieldValue();
                        if (s9 !== peg$FAILED) {
                          s10 = peg$parseVerbatimFieldValue();
                          if (s10 !== peg$FAILED) {
                            peg$savedPos = s0;
                            s1 = peg$c116(s4, s6, s9, s10);
                            s0 = s1;
                          } else {
                            peg$currPos = s0;
                            s0 = peg$FAILED;
                          }
                        } else {
                          peg$currPos = s0;
                          s0 = peg$FAILED;
                        }
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
        if (s0 === peg$FAILED) {
          s0 = peg$currPos;
          if (input.charCodeAt(peg$currPos) === 92) {
            s1 = peg$c80;
            peg$currPos++;
          } else {
            s1 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c81); }
          }
          if (s1 !== peg$FAILED) {
            s2 = peg$currPos;
            peg$silentFails++;
            if (input.substr(peg$currPos, 5) === peg$c111) {
              s3 = peg$c111;
              peg$currPos += 5;
            } else {
              s3 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c112); }
            }
            peg$silentFails--;
            if (s3 === peg$FAILED) {
              s2 = void 0;
            } else {
              peg$currPos = s2;
              s2 = peg$FAILED;
            }
            if (s2 !== peg$FAILED) {
              s3 = peg$currPos;
              peg$silentFails++;
              if (input.substr(peg$currPos, 3) === peg$c113) {
                s4 = peg$c113;
                peg$currPos += 3;
              } else {
                s4 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c114); }
              }
              peg$silentFails--;
              if (s4 === peg$FAILED) {
                s3 = void 0;
              } else {
                peg$currPos = s3;
                s3 = peg$FAILED;
              }
              if (s3 !== peg$FAILED) {
                s4 = peg$currPos;
                s5 = [];
                if (peg$c22.test(input.charAt(peg$currPos))) {
                  s6 = input.charAt(peg$currPos);
                  peg$currPos++;
                } else {
                  s6 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c23); }
                }
                if (s6 !== peg$FAILED) {
                  while (s6 !== peg$FAILED) {
                    s5.push(s6);
                    if (peg$c22.test(input.charAt(peg$currPos))) {
                      s6 = input.charAt(peg$currPos);
                      peg$currPos++;
                    } else {
                      s6 = peg$FAILED;
                      if (peg$silentFails === 0) { peg$fail(peg$c23); }
                    }
                  }
                } else {
                  s5 = peg$FAILED;
                }
                if (s5 !== peg$FAILED) {
                  s4 = input.substring(s4, peg$currPos);
                } else {
                  s4 = s5;
                }
                if (s4 !== peg$FAILED) {
                  peg$savedPos = peg$currPos;
                  s5 = peg$c117(s4);
                  if (s5) {
                    s5 = void 0;
                  } else {
                    s5 = peg$FAILED;
                  }
                  if (s5 !== peg$FAILED) {
                    s6 = [];
                    s7 = peg$parseOptionalArgument();
                    while (s7 !== peg$FAILED) {
                      s6.push(s7);
                      s7 = peg$parseOptionalArgument();
                    }
                    if (s6 !== peg$FAILED) {
                      s7 = peg$parse__h();
                      if (s7 !== peg$FAILED) {
                        s8 = peg$currPos;
                        peg$silentFails++;
                        if (input.charCodeAt(peg$currPos) === 123) {
                          s9 = peg$c15;
                          peg$currPos++;
                        } else {
                          s9 = peg$FAILED;
                          if (peg$silentFails === 0) { peg$fail(peg$c16); }
                        }
                        peg$silentFails--;
                        if (s9 !== peg$FAILED) {
                          peg$currPos = s8;
                          s8 = void 0;
                        } else {
                          s8 = peg$FAILED;
                        }
                        if (s8 !== peg$FAILED) {
                          s9 = peg$parseVerbatimFieldValue();
                          if (s9 !== peg$FAILED) {
                            peg$savedPos = s0;
                            s1 = peg$c118(s4, s6, s9);
                            s0 = s1;
                          } else {
                            peg$currPos = s0;
                            s0 = peg$FAILED;
                          }
                        } else {
                          peg$currPos = s0;
                          s0 = peg$FAILED;
                        }
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
          if (s0 === peg$FAILED) {
            s0 = peg$currPos;
            if (input.charCodeAt(peg$currPos) === 92) {
              s1 = peg$c80;
              peg$currPos++;
            } else {
              s1 = peg$FAILED;
              if (peg$silentFails === 0) { peg$fail(peg$c81); }
            }
            if (s1 !== peg$FAILED) {
              s2 = peg$currPos;
              peg$silentFails++;
              if (input.substr(peg$currPos, 5) === peg$c111) {
                s3 = peg$c111;
                peg$currPos += 5;
              } else {
                s3 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c112); }
              }
              peg$silentFails--;
              if (s3 === peg$FAILED) {
                s2 = void 0;
              } else {
                peg$currPos = s2;
                s2 = peg$FAILED;
              }
              if (s2 !== peg$FAILED) {
                s3 = peg$currPos;
                peg$silentFails++;
                if (input.substr(peg$currPos, 3) === peg$c113) {
                  s4 = peg$c113;
                  peg$currPos += 3;
                } else {
                  s4 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c114); }
                }
                peg$silentFails--;
                if (s4 === peg$FAILED) {
                  s3 = void 0;
                } else {
                  peg$currPos = s3;
                  s3 = peg$FAILED;
                }
                if (s3 !== peg$FAILED) {
                  s4 = peg$currPos;
                  s5 = [];
                  if (peg$c22.test(input.charAt(peg$currPos))) {
                    s6 = input.charAt(peg$currPos);
                    peg$currPos++;
                  } else {
                    s6 = peg$FAILED;
                    if (peg$silentFails === 0) { peg$fail(peg$c23); }
                  }
                  if (s6 !== peg$FAILED) {
                    while (s6 !== peg$FAILED) {
                      s5.push(s6);
                      if (peg$c22.test(input.charAt(peg$currPos))) {
                        s6 = input.charAt(peg$currPos);
                        peg$currPos++;
                      } else {
                        s6 = peg$FAILED;
                        if (peg$silentFails === 0) { peg$fail(peg$c23); }
                      }
                    }
                  } else {
                    s5 = peg$FAILED;
                  }
                  if (s5 !== peg$FAILED) {
                    s4 = input.substring(s4, peg$currPos);
                  } else {
                    s4 = s5;
                  }
                  if (s4 !== peg$FAILED) {
                    peg$savedPos = peg$currPos;
                    s5 = peg$c119(s4);
                    if (s5) {
                      s5 = void 0;
                    } else {
                      s5 = peg$FAILED;
                    }
                    if (s5 !== peg$FAILED) {
                      s6 = [];
                      s7 = peg$parseOptionalArgument();
                      while (s7 !== peg$FAILED) {
                        s6.push(s7);
                        s7 = peg$parseOptionalArgument();
                      }
                      if (s6 !== peg$FAILED) {
                        s7 = peg$parse__h();
                        if (s7 !== peg$FAILED) {
                          s8 = peg$parseRequiredArgument();
                          if (s8 !== peg$FAILED) {
                            s9 = peg$parseRequiredArgument();
                            if (s9 !== peg$FAILED) {
                              peg$savedPos = s0;
                              s1 = peg$c120(s4, s6, s8, s9);
                              s0 = s1;
                            } else {
                              peg$currPos = s0;
                              s0 = peg$FAILED;
                            }
                          } else {
                            peg$currPos = s0;
                            s0 = peg$FAILED;
                          }
                        } else {
                          peg$currPos = s0;
                          s0 = peg$FAILED;
                        }
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
            if (s0 === peg$FAILED) {
              s0 = peg$currPos;
              if (input.charCodeAt(peg$currPos) === 92) {
                s1 = peg$c80;
                peg$currPos++;
              } else {
                s1 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c81); }
              }
              if (s1 !== peg$FAILED) {
                s2 = peg$currPos;
                peg$silentFails++;
                if (input.substr(peg$currPos, 5) === peg$c111) {
                  s3 = peg$c111;
                  peg$currPos += 5;
                } else {
                  s3 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c112); }
                }
                peg$silentFails--;
                if (s3 === peg$FAILED) {
                  s2 = void 0;
                } else {
                  peg$currPos = s2;
                  s2 = peg$FAILED;
                }
                if (s2 !== peg$FAILED) {
                  s3 = peg$currPos;
                  peg$silentFails++;
                  if (input.substr(peg$currPos, 3) === peg$c113) {
                    s4 = peg$c113;
                    peg$currPos += 3;
                  } else {
                    s4 = peg$FAILED;
                    if (peg$silentFails === 0) { peg$fail(peg$c114); }
                  }
                  peg$silentFails--;
                  if (s4 === peg$FAILED) {
                    s3 = void 0;
                  } else {
                    peg$currPos = s3;
                    s3 = peg$FAILED;
                  }
                  if (s3 !== peg$FAILED) {
                    s4 = peg$currPos;
                    s5 = [];
                    if (peg$c22.test(input.charAt(peg$currPos))) {
                      s6 = input.charAt(peg$currPos);
                      peg$currPos++;
                    } else {
                      s6 = peg$FAILED;
                      if (peg$silentFails === 0) { peg$fail(peg$c23); }
                    }
                    if (s6 !== peg$FAILED) {
                      while (s6 !== peg$FAILED) {
                        s5.push(s6);
                        if (peg$c22.test(input.charAt(peg$currPos))) {
                          s6 = input.charAt(peg$currPos);
                          peg$currPos++;
                        } else {
                          s6 = peg$FAILED;
                          if (peg$silentFails === 0) { peg$fail(peg$c23); }
                        }
                      }
                    } else {
                      s5 = peg$FAILED;
                    }
                    if (s5 !== peg$FAILED) {
                      s4 = input.substring(s4, peg$currPos);
                    } else {
                      s4 = s5;
                    }
                    if (s4 !== peg$FAILED) {
                      peg$savedPos = peg$currPos;
                      s5 = peg$c121(s4);
                      if (s5) {
                        s5 = void 0;
                      } else {
                        s5 = peg$FAILED;
                      }
                      if (s5 !== peg$FAILED) {
                        s6 = [];
                        s7 = peg$parseOptionalArgument();
                        while (s7 !== peg$FAILED) {
                          s6.push(s7);
                          s7 = peg$parseOptionalArgument();
                        }
                        if (s6 !== peg$FAILED) {
                          s7 = peg$parse__h();
                          if (s7 !== peg$FAILED) {
                            s8 = peg$parseRequiredArgument();
                            if (s8 !== peg$FAILED) {
                              peg$savedPos = s0;
                              s1 = peg$c122(s4, s6, s8);
                              s0 = s1;
                            } else {
                              peg$currPos = s0;
                              s0 = peg$FAILED;
                            }
                          } else {
                            peg$currPos = s0;
                            s0 = peg$FAILED;
                          }
                        } else {
                          peg$currPos = s0;
                          s0 = peg$FAILED;
                        }
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
              if (s0 === peg$FAILED) {
                s0 = peg$currPos;
                if (input.charCodeAt(peg$currPos) === 92) {
                  s1 = peg$c80;
                  peg$currPos++;
                } else {
                  s1 = peg$FAILED;
                  if (peg$silentFails === 0) { peg$fail(peg$c81); }
                }
                if (s1 !== peg$FAILED) {
                  s2 = peg$currPos;
                  peg$silentFails++;
                  if (input.substr(peg$currPos, 5) === peg$c111) {
                    s3 = peg$c111;
                    peg$currPos += 5;
                  } else {
                    s3 = peg$FAILED;
                    if (peg$silentFails === 0) { peg$fail(peg$c112); }
                  }
                  peg$silentFails--;
                  if (s3 === peg$FAILED) {
                    s2 = void 0;
                  } else {
                    peg$currPos = s2;
                    s2 = peg$FAILED;
                  }
                  if (s2 !== peg$FAILED) {
                    s3 = peg$currPos;
                    peg$silentFails++;
                    if (input.substr(peg$currPos, 3) === peg$c113) {
                      s4 = peg$c113;
                      peg$currPos += 3;
                    } else {
                      s4 = peg$FAILED;
                      if (peg$silentFails === 0) { peg$fail(peg$c114); }
                    }
                    peg$silentFails--;
                    if (s4 === peg$FAILED) {
                      s3 = void 0;
                    } else {
                      peg$currPos = s3;
                      s3 = peg$FAILED;
                    }
                    if (s3 !== peg$FAILED) {
                      s4 = peg$currPos;
                      s5 = [];
                      if (peg$c22.test(input.charAt(peg$currPos))) {
                        s6 = input.charAt(peg$currPos);
                        peg$currPos++;
                      } else {
                        s6 = peg$FAILED;
                        if (peg$silentFails === 0) { peg$fail(peg$c23); }
                      }
                      if (s6 !== peg$FAILED) {
                        while (s6 !== peg$FAILED) {
                          s5.push(s6);
                          if (peg$c22.test(input.charAt(peg$currPos))) {
                            s6 = input.charAt(peg$currPos);
                            peg$currPos++;
                          } else {
                            s6 = peg$FAILED;
                            if (peg$silentFails === 0) { peg$fail(peg$c23); }
                          }
                        }
                      } else {
                        s5 = peg$FAILED;
                      }
                      if (s5 !== peg$FAILED) {
                        s4 = input.substring(s4, peg$currPos);
                      } else {
                        s4 = s5;
                      }
                      if (s4 !== peg$FAILED) {
                        s5 = [];
                        s6 = peg$parseOptionalArgument();
                        while (s6 !== peg$FAILED) {
                          s5.push(s6);
                          s6 = peg$parseOptionalArgument();
                        }
                        if (s5 !== peg$FAILED) {
                          s6 = peg$parse__();
                          if (s6 !== peg$FAILED) {
                            peg$savedPos = s0;
                            s1 = peg$c123(s4, s5);
                            s0 = s1;
                          } else {
                            peg$currPos = s0;
                            s0 = peg$FAILED;
                          }
                        } else {
                          peg$currPos = s0;
                          s0 = peg$FAILED;
                        }
                      } else {
                        peg$currPos = s0;
                        s0 = peg$FAILED;
                      }
                    } else {
                      peg$currPos = s0;
                      s0 = peg$FAILED;
                    }
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              }
            }
          }
        }
      }

      return s0;
    }

    function peg$parseOptionalArgument() {
      var s0, s1, s2, s3, s4, s5;

      s0 = peg$currPos;
      if (input.charCodeAt(peg$currPos) === 91) {
        s1 = peg$c124;
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c125); }
      }
      if (s1 !== peg$FAILED) {
        s2 = peg$parse__h();
        if (s2 !== peg$FAILED) {
          s3 = peg$currPos;
          s4 = [];
          if (peg$c126.test(input.charAt(peg$currPos))) {
            s5 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s5 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c127); }
          }
          if (s5 !== peg$FAILED) {
            while (s5 !== peg$FAILED) {
              s4.push(s5);
              if (peg$c126.test(input.charAt(peg$currPos))) {
                s5 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s5 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c127); }
              }
            }
          } else {
            s4 = peg$FAILED;
          }
          if (s4 !== peg$FAILED) {
            s3 = input.substring(s3, peg$currPos);
          } else {
            s3 = s4;
          }
          if (s3 !== peg$FAILED) {
            s4 = peg$parse__h();
            if (s4 !== peg$FAILED) {
              if (input.charCodeAt(peg$currPos) === 93) {
                s5 = peg$c128;
                peg$currPos++;
              } else {
                s5 = peg$FAILED;
                if (peg$silentFails === 0) { peg$fail(peg$c129); }
              }
              if (s5 !== peg$FAILED) {
                peg$savedPos = s0;
                s1 = peg$c130(s3);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseRequiredArgument() {
      var s0, s1, s2;

      s0 = peg$currPos;
      s1 = peg$parse__h();
      if (s1 !== peg$FAILED) {
        if (peg$c131.test(input.charAt(peg$currPos))) {
          s2 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s2 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c132); }
        }
        if (s2 !== peg$FAILED) {
          peg$savedPos = s0;
          s1 = peg$c133(s2);
          s0 = s1;
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }
      if (s0 === peg$FAILED) {
        s0 = peg$currPos;
        s1 = peg$parseBlock();
        if (s1 === peg$FAILED) {
          s1 = peg$parseCommand();
        }
        if (s1 !== peg$FAILED) {
          peg$savedPos = s0;
          s1 = peg$c52(s1);
        }
        s0 = s1;
      }

      return s0;
    }

    function peg$parseVariableName() {
      var s0, s1, s2, s3, s4;

      s0 = peg$currPos;
      s1 = peg$currPos;
      if (peg$c134.test(input.charAt(peg$currPos))) {
        s2 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s2 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c135); }
      }
      if (s2 !== peg$FAILED) {
        s3 = [];
        if (peg$c136.test(input.charAt(peg$currPos))) {
          s4 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s4 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c137); }
        }
        while (s4 !== peg$FAILED) {
          s3.push(s4);
          if (peg$c136.test(input.charAt(peg$currPos))) {
            s4 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s4 = peg$FAILED;
            if (peg$silentFails === 0) { peg$fail(peg$c137); }
          }
        }
        if (s3 !== peg$FAILED) {
          s2 = [s2, s3];
          s1 = s2;
        } else {
          peg$currPos = s1;
          s1 = peg$FAILED;
        }
      } else {
        peg$currPos = s1;
        s1 = peg$FAILED;
      }
      if (s1 !== peg$FAILED) {
        s0 = input.substring(s0, peg$currPos);
      } else {
        s0 = s1;
      }

      return s0;
    }

    function peg$parseSimpleDiacritic() {
      var s0;

      if (peg$c138.test(input.charAt(peg$currPos))) {
        s0 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s0 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c139); }
      }

      return s0;
    }

    function peg$parseExtendedDiacritic() {
      var s0;

      if (peg$c140.test(input.charAt(peg$currPos))) {
        s0 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s0 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c141); }
      }

      return s0;
    }

    function peg$parseFieldSeparator() {
      var s0, s1, s2, s3;

      s0 = peg$currPos;
      s1 = peg$parse__();
      if (s1 !== peg$FAILED) {
        if (input.charCodeAt(peg$currPos) === 61) {
          s2 = peg$c142;
          peg$currPos++;
        } else {
          s2 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c143); }
        }
        if (s2 !== peg$FAILED) {
          s3 = peg$parse__();
          if (s3 !== peg$FAILED) {
            s1 = [s1, s2, s3];
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseFieldTerminator() {
      var s0, s1, s2, s3, s4, s5;

      s0 = peg$currPos;
      s1 = peg$parse__();
      if (s1 !== peg$FAILED) {
        if (input.charCodeAt(peg$currPos) === 44) {
          s2 = peg$c37;
          peg$currPos++;
        } else {
          s2 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c38); }
        }
        if (s2 === peg$FAILED) {
          s2 = null;
        }
        if (s2 !== peg$FAILED) {
          s3 = peg$parse__h();
          if (s3 !== peg$FAILED) {
            s4 = [];
            s5 = peg$parseLineComment();
            if (s5 === peg$FAILED) {
              s5 = peg$parseEOL();
            }
            while (s5 !== peg$FAILED) {
              s4.push(s5);
              s5 = peg$parseLineComment();
              if (s5 === peg$FAILED) {
                s5 = peg$parseEOL();
              }
            }
            if (s4 !== peg$FAILED) {
              s1 = [s1, s2, s3, s4];
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseConcat() {
      var s0, s1, s2, s3;

      s0 = peg$currPos;
      s1 = peg$parse__();
      if (s1 !== peg$FAILED) {
        if (input.charCodeAt(peg$currPos) === 35) {
          s2 = peg$c144;
          peg$currPos++;
        } else {
          s2 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c145); }
        }
        if (s2 !== peg$FAILED) {
          s3 = peg$parse__();
          if (s3 !== peg$FAILED) {
            s1 = [s1, s2, s3];
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }
      } else {
        peg$currPos = s0;
        s0 = peg$FAILED;
      }

      return s0;
    }

    function peg$parseEOL() {
      var s0;

      if (peg$c146.test(input.charAt(peg$currPos))) {
        s0 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s0 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c147); }
      }

      return s0;
    }

    function peg$parse__h() {
      var s0, s1;

      peg$silentFails++;
      s0 = [];
      if (peg$c149.test(input.charAt(peg$currPos))) {
        s1 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c150); }
      }
      while (s1 !== peg$FAILED) {
        s0.push(s1);
        if (peg$c149.test(input.charAt(peg$currPos))) {
          s1 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c150); }
        }
      }
      peg$silentFails--;
      if (s0 === peg$FAILED) {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c151); }
      }

      return s0;
    }

    function peg$parse__() {
      var s0, s1;

      peg$silentFails++;
      s0 = [];
      if (peg$c155.test(input.charAt(peg$currPos))) {
        s1 = input.charAt(peg$currPos);
        peg$currPos++;
      } else {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c156); }
      }
      while (s1 !== peg$FAILED) {
        s0.push(s1);
        if (peg$c155.test(input.charAt(peg$currPos))) {
          s1 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s1 = peg$FAILED;
          if (peg$silentFails === 0) { peg$fail(peg$c156); }
        }
      }
      peg$silentFails--;
      if (s0 === peg$FAILED) {
        s1 = peg$FAILED;
        if (peg$silentFails === 0) { peg$fail(peg$c157); }
      }

      return s0;
    }


      /*
        MIT License

        Copyright (c) 2017 Derek P Sifford, parts copyright (c) 2019 by Emiliano Heyns

        Permission is hereby granted, free of charge, to any person obtaining a copy
        of this software and associated documentation files (the "Software"), to deal
        in the Software without restriction, including without limitation the rights
        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        copies of the Software, and to permit persons to whom the Software is
        furnished to do so, subject to the following conditions:

        The above copyright notice and this permission notice shall be included in all
        copies or substantial portions of the Software.

        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
        SOFTWARE.
      */

      const markup = {
        sl: 'italics',
        em: 'italics',
        it: 'italics',
        itshape: 'italics',

        bf: 'bold',
        bfseries: 'bold',

        sc: 'smallCaps',
        scshape: 'smallCaps',

        tt: 'fixedWidth',
        rm: 'roman',
        sf: 'sansSerif',
        verb: 'verbatim',
      };

      const unnestFields = (options.unnestFields || []).map(field => field.toLowerCase());
      const verbatimFields = (options.verbatimFields || [ 'urlraw', 'url', 'doi', 'file', 'files', 'eprint', 'verba', 'verbb', 'verbc' ]).map(field => typeof field === 'string' ? field.toLowerCase() : field);
      const verbatimCommands = (options.verbatimCommands || ['texttt', 'url', 'href']);

      function isVerbatimField(name) {
        return verbatimFields.find(p => (typeof p === 'string') ? name === p : name.match(p))
      }

      function normalizeWhitespace(textArr) {
        return textArr.reduce((prev, curr) => {
          if (/\s/.test(curr)) {
            if (/\s/.test(prev[prev.length - 1])) {
              return prev;
            } else {
              return prev + ' ';
            }
          }
          return prev + curr;
        }, '');
      }

      const has_arguments = {
        ElsevierGlyph: 1,
        end: 1,
        begin: 1,
        bibcyr: 1,
        bibstring: 1,
        chsf: 1,
        cite: 1,
        cyrchar: 1,
        ding: 1,
        emph: 1,
        enquote: 1,
        frac: 2,
        href: 2,
        hspace: 1,
        mathrm: 1,
        mbox: 1,
        mkbibbold: 1,
        mkbibemph: 1,
        mkbibitalic: 1,
        mkbibquote: 1,
        newcommand: 2,
        noopsort: 1,
        ocirc: 1,
        section: 1,
        sb: 1,
        sp: 1,
        subsection: 1,
        subsubsection: 1,
        subsubsubsection: 1,
        t: 1,
        textbf: 1,
        textit: 1,
        textrm: 1,
        textsc: 1,
        textsubscript: 1,
        textsuperscript: 1,
        texttt: 1,
        url: 1,
        vphantom: 1,
        vspace: 1,
      };

      if (options.combiningDiacritics) {
        for (const cmd of options.combiningDiacritics) {
          has_arguments[cmd] = 1;
        }
      }

      const math = {
        on: false,

        set: function(state) {
          this.on = state;
          return true
        }
      };

      function basicTextConversions(node) {
        if (node.kind !== 'Text') throw new Error(node.kind + ' is not a Text node')

        switch (node.mode) {
          case 'verbatim':
            break

          case 'math':
            node.value = node.value.replace(/~/g, '\u00A0');
            break

          case 'text':
            node.value = node.value
              .replace(/---/g, '\u2014')
              .replace(/--/g, '\u2013')
              .replace(/</g, '\u00A1')
              .replace(/>/g, '\u00BF')
              .replace(/~/g, '\u00A0')
              .replace(/``/g, options.markup.enquote.open)
              .replace(/''/g, options.markup.enquote.close);
            break

          default:
            throw new Error(`Unexpected text mode ${node.mode}`)
        }

        return node
      }

      function protect(v) {
        let source;
        if (Array.isArray(v)) {
          source = v.map(e => e.source).join('');
        } else {
          v = [ v ];
          source = v.source;
        }

        return {
          kind: 'Block',
          value: v,
          markup: {},
          case: 'protect',
          source: source,
        }
      }

      function handle_markup_switches(block) {
        const value = block.value;
        if (!Array.isArray(value)) return block

        block.value = [];

        const pseudo = {
          block: null,
          markup: {},
        };
        function pseudo_block() {
          pseudo.block = {
            kind: 'Block',
            loc: location(),
            source: '',
            value: [],
            markup: JSON.parse(JSON.stringify(pseudo.markup)),
            pseudo: true,
          };
          block.value.push(pseudo.block);
        }
        for (const node of value) {
          if (node.kind === 'Environment' || node.kind === 'Block') {
            block.value.push(node);

            if (Object.keys(pseudo.markup).length) {
              pseudo_block();
            } else {
              pseudo.block = null;
            }
            continue
          }

          if (node.kind === 'RegularCommand' && markup[node.command]) {
            if (pseudo.markup.italics) { // https://github.com/citation-js/bibtex-parser-experiments/commit/cae475f075a05d1c074485a061b08ed245170c7e
              delete pseudo.markup.italics;
              if (markup[node.command] !== 'italics') pseudo.markup[markup[node.command]] = true;
            } else {
              pseudo.markup[markup[node.command]] = true;
            }

            if (Object.keys(pseudo.markup).length) {
              pseudo_block();
            } else {
               pseudo.block = null;
            }
          }

          if (pseudo.block) {
            pseudo.block.source += node.source;
            pseudo.block.value.push(node);

          } else {
            block.value.push(node);

          }
        }

        block.value = block.value.filter(node => !(node.pseudo && node.value.length === 0));

        return block
      }


    peg$result = peg$startRuleFunction();

    if (peg$result !== peg$FAILED && peg$currPos === input.length) {
      return peg$result;
    } else {
      if (peg$result !== peg$FAILED && peg$currPos < input.length) {
        peg$fail(peg$endExpectation());
      }

      throw peg$buildStructuredError(
        peg$maxFailExpected,
        peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,
        peg$maxFailPos < input.length
          ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)
          : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)
      );
    }
  }

  var grammar = {
    SyntaxError: peg$SyntaxError,
    parse:       peg$parse
  };

  var chunker = createCommonjsModule(function (module, exports) {
  // Original work by Henrik Muehe (c) 2010
  //
  // CommonJS port by Mikola Lysenko 2013
  //
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.parse = void 0;
  class ParseError extends Error {
      constructor(message, parser) {
          message += ` @ ${parser.pos}`;
          if (parser.parsing)
              message += ` in ${JSON.stringify(parser.parsing)}`;
          super(message);
          this.name = 'ParseError';
      }
  }
  // tslint:disable-next-line prefer-template
  const letter = new RegExp('[' + [
      // Letter, Uppercase
      /\u0041-\u005A\u00C0-\u00D6\u00D8-\u00DE\u0100\u0102\u0104\u0106\u0108\u010A\u010C\u010E\u0110\u0112\u0114\u0116\u0118\u011A\u011C\u011E\u0120\u0122\u0124\u0126\u0128\u012A\u012C\u012E\u0130\u0132\u0134\u0136\u0139\u013B\u013D\u013F\u0141\u0143\u0145\u0147\u014A\u014C\u014E\u0150\u0152\u0154\u0156\u0158\u015A\u015C\u015E\u0160\u0162\u0164\u0166\u0168\u016A\u016C\u016E\u0170\u0172\u0174\u0176\u0178-\u0179\u017B\u017D\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018B\u018E-\u0191\u0193-\u0194\u0196-\u0198\u019C-\u019D\u019F-\u01A0\u01A2\u01A4\u01A6-\u01A7\u01A9\u01AC\u01AE-\u01AF\u01B1-\u01B3\u01B5\u01B7-\u01B8\u01BC\u01C4\u01C7\u01CA\u01CD\u01CF\u01D1\u01D3\u01D5\u01D7\u01D9\u01DB\u01DE\u01E0\u01E2\u01E4\u01E6\u01E8\u01EA\u01EC\u01EE\u01F1\u01F4\u01F6-\u01F8\u01FA\u01FC\u01FE\u0200\u0202\u0204\u0206\u0208\u020A\u020C\u020E\u0210\u0212\u0214\u0216\u0218\u021A\u021C\u021E\u0220\u0222\u0224\u0226\u0228\u022A\u022C\u022E\u0230\u0232\u023A-\u023B\u023D-\u023E\u0241\u0243-\u0246\u0248\u024A\u024C\u024E\u0370\u0372\u0376\u037F\u0386\u0388-\u038A\u038C\u038E-\u038F\u0391-\u03A1\u03A3-\u03AB\u03CF\u03D2-\u03D4\u03D8\u03DA\u03DC\u03DE\u03E0\u03E2\u03E4\u03E6\u03E8\u03EA\u03EC\u03EE\u03F4\u03F7\u03F9-\u03FA\u03FD-\u042F\u0460\u0462\u0464\u0466\u0468\u046A\u046C\u046E\u0470\u0472\u0474\u0476\u0478\u047A\u047C\u047E\u0480\u048A\u048C\u048E\u0490\u0492\u0494\u0496\u0498\u049A\u049C\u049E\u04A0\u04A2\u04A4\u04A6\u04A8\u04AA\u04AC\u04AE\u04B0\u04B2\u04B4\u04B6\u04B8\u04BA\u04BC\u04BE\u04C0-\u04C1\u04C3\u04C5\u04C7\u04C9\u04CB\u04CD\u04D0\u04D2\u04D4\u04D6\u04D8\u04DA\u04DC\u04DE\u04E0\u04E2\u04E4\u04E6\u04E8\u04EA\u04EC\u04EE\u04F0\u04F2\u04F4\u04F6\u04F8\u04FA\u04FC\u04FE\u0500\u0502\u0504\u0506\u0508\u050A\u050C\u050E\u0510\u0512\u0514\u0516\u0518\u051A\u051C\u051E\u0520\u0522\u0524\u0526\u0528\u052A\u052C\u052E\u0531-\u0556\u10A0-\u10C5\u10C7\u10CD\u13A0-\u13F5\u1E00\u1E02\u1E04\u1E06\u1E08\u1E0A\u1E0C\u1E0E\u1E10\u1E12\u1E14\u1E16\u1E18\u1E1A\u1E1C\u1E1E\u1E20\u1E22\u1E24\u1E26\u1E28\u1E2A\u1E2C\u1E2E\u1E30\u1E32\u1E34\u1E36\u1E38\u1E3A\u1E3C\u1E3E\u1E40\u1E42\u1E44\u1E46\u1E48\u1E4A\u1E4C\u1E4E\u1E50\u1E52\u1E54\u1E56\u1E58\u1E5A\u1E5C\u1E5E\u1E60\u1E62\u1E64\u1E66\u1E68\u1E6A\u1E6C\u1E6E\u1E70\u1E72\u1E74\u1E76\u1E78\u1E7A\u1E7C\u1E7E\u1E80\u1E82\u1E84\u1E86\u1E88\u1E8A\u1E8C\u1E8E\u1E90\u1E92\u1E94\u1E9E\u1EA0\u1EA2\u1EA4\u1EA6\u1EA8\u1EAA\u1EAC\u1EAE\u1EB0\u1EB2\u1EB4\u1EB6\u1EB8\u1EBA\u1EBC\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6\u1EC8\u1ECA\u1ECC\u1ECE\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u1EDA\u1EDC\u1EDE\u1EE0\u1EE2\u1EE4\u1EE6\u1EE8\u1EEA\u1EEC\u1EEE\u1EF0\u1EF2\u1EF4\u1EF6\u1EF8\u1EFA\u1EFC\u1EFE\u1F08-\u1F0F\u1F18-\u1F1D\u1F28-\u1F2F\u1F38-\u1F3F\u1F48-\u1F4D\u1F59\u1F5B\u1F5D\u1F5F\u1F68-\u1F6F\u1FB8-\u1FBB\u1FC8-\u1FCB\u1FD8-\u1FDB\u1FE8-\u1FEC\u1FF8-\u1FFB\u2102\u2107\u210B-\u210D\u2110-\u2112\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u2130-\u2133\u213E-\u213F\u2145\u2183\u2C00-\u2C2E\u2C60\u2C62-\u2C64\u2C67\u2C69\u2C6B\u2C6D-\u2C70\u2C72\u2C75\u2C7E-\u2C80\u2C82\u2C84\u2C86\u2C88\u2C8A\u2C8C\u2C8E\u2C90\u2C92\u2C94\u2C96\u2C98\u2C9A\u2C9C\u2C9E\u2CA0\u2CA2\u2CA4\u2CA6\u2CA8\u2CAA\u2CAC\u2CAE\u2CB0\u2CB2\u2CB4\u2CB6\u2CB8\u2CBA\u2CBC\u2CBE\u2CC0\u2CC2\u2CC4\u2CC6\u2CC8\u2CCA\u2CCC\u2CCE\u2CD0\u2CD2\u2CD4\u2CD6\u2CD8\u2CDA\u2CDC\u2CDE\u2CE0\u2CE2\u2CEB\u2CED\u2CF2\uA640\uA642\uA644\uA646\uA648\uA64A\uA64C\uA64E\uA650\uA652\uA654\uA656\uA658\uA65A\uA65C\uA65E\uA660\uA662\uA664\uA666\uA668\uA66A\uA66C\uA680\uA682\uA684\uA686\uA688\uA68A\uA68C\uA68E\uA690\uA692\uA694\uA696\uA698\uA69A\uA722\uA724\uA726\uA728\uA72A\uA72C\uA72E\uA732\uA734\uA736\uA738\uA73A\uA73C\uA73E\uA740\uA742\uA744\uA746\uA748\uA74A\uA74C\uA74E\uA750\uA752\uA754\uA756\uA758\uA75A\uA75C\uA75E\uA760\uA762\uA764\uA766\uA768\uA76A\uA76C\uA76E\uA779\uA77B\uA77D-\uA77E\uA780\uA782\uA784\uA786\uA78B\uA78D\uA790\uA792\uA796\uA798\uA79A\uA79C\uA79E\uA7A0\uA7A2\uA7A4\uA7A6\uA7A8\uA7AA-\uA7AD\uA7B0-\uA7B4\uA7B6\uFF21-\uFF3A/.source,
      // Letter, Titlecase
      /\u01C5\u01C8\u01CB\u01F2\u1F88-\u1F8F\u1F98-\u1F9F\u1FA8-\u1FAF\u1FBC\u1FCC\u1FFC/.source,
      // Letter, Lowercase
      /\u0061-\u007A\u00B5\u00DF-\u00F6\u00F8-\u00FF\u0101\u0103\u0105\u0107\u0109\u010B\u010D\u010F\u0111\u0113\u0115\u0117\u0119\u011B\u011D\u011F\u0121\u0123\u0125\u0127\u0129\u012B\u012D\u012F\u0131\u0133\u0135\u0137-\u0138\u013A\u013C\u013E\u0140\u0142\u0144\u0146\u0148-\u0149\u014B\u014D\u014F\u0151\u0153\u0155\u0157\u0159\u015B\u015D\u015F\u0161\u0163\u0165\u0167\u0169\u016B\u016D\u016F\u0171\u0173\u0175\u0177\u017A\u017C\u017E-\u0180\u0183\u0185\u0188\u018C-\u018D\u0192\u0195\u0199-\u019B\u019E\u01A1\u01A3\u01A5\u01A8\u01AA-\u01AB\u01AD\u01B0\u01B4\u01B6\u01B9-\u01BA\u01BD-\u01BF\u01C6\u01C9\u01CC\u01CE\u01D0\u01D2\u01D4\u01D6\u01D8\u01DA\u01DC-\u01DD\u01DF\u01E1\u01E3\u01E5\u01E7\u01E9\u01EB\u01ED\u01EF-\u01F0\u01F3\u01F5\u01F9\u01FB\u01FD\u01FF\u0201\u0203\u0205\u0207\u0209\u020B\u020D\u020F\u0211\u0213\u0215\u0217\u0219\u021B\u021D\u021F\u0221\u0223\u0225\u0227\u0229\u022B\u022D\u022F\u0231\u0233-\u0239\u023C\u023F-\u0240\u0242\u0247\u0249\u024B\u024D\u024F-\u0293\u0295-\u02AF\u0371\u0373\u0377\u037B-\u037D\u0390\u03AC-\u03CE\u03D0-\u03D1\u03D5-\u03D7\u03D9\u03DB\u03DD\u03DF\u03E1\u03E3\u03E5\u03E7\u03E9\u03EB\u03ED\u03EF-\u03F3\u03F5\u03F8\u03FB-\u03FC\u0430-\u045F\u0461\u0463\u0465\u0467\u0469\u046B\u046D\u046F\u0471\u0473\u0475\u0477\u0479\u047B\u047D\u047F\u0481\u048B\u048D\u048F\u0491\u0493\u0495\u0497\u0499\u049B\u049D\u049F\u04A1\u04A3\u04A5\u04A7\u04A9\u04AB\u04AD\u04AF\u04B1\u04B3\u04B5\u04B7\u04B9\u04BB\u04BD\u04BF\u04C2\u04C4\u04C6\u04C8\u04CA\u04CC\u04CE-\u04CF\u04D1\u04D3\u04D5\u04D7\u04D9\u04DB\u04DD\u04DF\u04E1\u04E3\u04E5\u04E7\u04E9\u04EB\u04ED\u04EF\u04F1\u04F3\u04F5\u04F7\u04F9\u04FB\u04FD\u04FF\u0501\u0503\u0505\u0507\u0509\u050B\u050D\u050F\u0511\u0513\u0515\u0517\u0519\u051B\u051D\u051F\u0521\u0523\u0525\u0527\u0529\u052B\u052D\u052F\u0561-\u0587\u13F8-\u13FD\u1D00-\u1D2B\u1D6B-\u1D77\u1D79-\u1D9A\u1E01\u1E03\u1E05\u1E07\u1E09\u1E0B\u1E0D\u1E0F\u1E11\u1E13\u1E15\u1E17\u1E19\u1E1B\u1E1D\u1E1F\u1E21\u1E23\u1E25\u1E27\u1E29\u1E2B\u1E2D\u1E2F\u1E31\u1E33\u1E35\u1E37\u1E39\u1E3B\u1E3D\u1E3F\u1E41\u1E43\u1E45\u1E47\u1E49\u1E4B\u1E4D\u1E4F\u1E51\u1E53\u1E55\u1E57\u1E59\u1E5B\u1E5D\u1E5F\u1E61\u1E63\u1E65\u1E67\u1E69\u1E6B\u1E6D\u1E6F\u1E71\u1E73\u1E75\u1E77\u1E79\u1E7B\u1E7D\u1E7F\u1E81\u1E83\u1E85\u1E87\u1E89\u1E8B\u1E8D\u1E8F\u1E91\u1E93\u1E95-\u1E9D\u1E9F\u1EA1\u1EA3\u1EA5\u1EA7\u1EA9\u1EAB\u1EAD\u1EAF\u1EB1\u1EB3\u1EB5\u1EB7\u1EB9\u1EBB\u1EBD\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7\u1EC9\u1ECB\u1ECD\u1ECF\u1ED1\u1ED3\u1ED5\u1ED7\u1ED9\u1EDB\u1EDD\u1EDF\u1EE1\u1EE3\u1EE5\u1EE7\u1EE9\u1EEB\u1EED\u1EEF\u1EF1\u1EF3\u1EF5\u1EF7\u1EF9\u1EFB\u1EFD\u1EFF-\u1F07\u1F10-\u1F15\u1F20-\u1F27\u1F30-\u1F37\u1F40-\u1F45\u1F50-\u1F57\u1F60-\u1F67\u1F70-\u1F7D\u1F80-\u1F87\u1F90-\u1F97\u1FA0-\u1FA7\u1FB0-\u1FB4\u1FB6-\u1FB7\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FC7\u1FD0-\u1FD3\u1FD6-\u1FD7\u1FE0-\u1FE7\u1FF2-\u1FF4\u1FF6-\u1FF7\u210A\u210E-\u210F\u2113\u212F\u2134\u2139\u213C-\u213D\u2146-\u2149\u214E\u2184\u2C30-\u2C5E\u2C61\u2C65-\u2C66\u2C68\u2C6A\u2C6C\u2C71\u2C73-\u2C74\u2C76-\u2C7B\u2C81\u2C83\u2C85\u2C87\u2C89\u2C8B\u2C8D\u2C8F\u2C91\u2C93\u2C95\u2C97\u2C99\u2C9B\u2C9D\u2C9F\u2CA1\u2CA3\u2CA5\u2CA7\u2CA9\u2CAB\u2CAD\u2CAF\u2CB1\u2CB3\u2CB5\u2CB7\u2CB9\u2CBB\u2CBD\u2CBF\u2CC1\u2CC3\u2CC5\u2CC7\u2CC9\u2CCB\u2CCD\u2CCF\u2CD1\u2CD3\u2CD5\u2CD7\u2CD9\u2CDB\u2CDD\u2CDF\u2CE1\u2CE3-\u2CE4\u2CEC\u2CEE\u2CF3\u2D00-\u2D25\u2D27\u2D2D\uA641\uA643\uA645\uA647\uA649\uA64B\uA64D\uA64F\uA651\uA653\uA655\uA657\uA659\uA65B\uA65D\uA65F\uA661\uA663\uA665\uA667\uA669\uA66B\uA66D\uA681\uA683\uA685\uA687\uA689\uA68B\uA68D\uA68F\uA691\uA693\uA695\uA697\uA699\uA69B\uA723\uA725\uA727\uA729\uA72B\uA72D\uA72F-\uA731\uA733\uA735\uA737\uA739\uA73B\uA73D\uA73F\uA741\uA743\uA745\uA747\uA749\uA74B\uA74D\uA74F\uA751\uA753\uA755\uA757\uA759\uA75B\uA75D\uA75F\uA761\uA763\uA765\uA767\uA769\uA76B\uA76D\uA76F\uA771-\uA778\uA77A\uA77C\uA77F\uA781\uA783\uA785\uA787\uA78C\uA78E\uA791\uA793-\uA795\uA797\uA799\uA79B\uA79D\uA79F\uA7A1\uA7A3\uA7A5\uA7A7\uA7A9\uA7B5\uA7B7\uA7FA\uAB30-\uAB5A\uAB60-\uAB65\uAB70-\uABBF\uFB00-\uFB06\uFB13-\uFB17\uFF41-\uFF5A/.source,
      // Letter, Modifier
      /\u02B0-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0374\u037A\u0559\u0640\u06E5-\u06E6\u07F4-\u07F5\u07FA\u081A\u0824\u0828\u0971\u0E46\u0EC6\u10FC\u17D7\u1843\u1AA7\u1C78-\u1C7D\u1D2C-\u1D6A\u1D78\u1D9B-\u1DBF\u2071\u207F\u2090-\u209C\u2C7C-\u2C7D\u2D6F\u2E2F\u3005\u3031-\u3035\u303B\u309D-\u309E\u30FC-\u30FE\uA015\uA4F8-\uA4FD\uA60C\uA67F\uA69C-\uA69D\uA717-\uA71F\uA770\uA788\uA7F8-\uA7F9\uA9CF\uA9E6\uAA70\uAADD\uAAF3-\uAAF4\uAB5C-\uAB5F\uFF70\uFF9E-\uFF9F/.source,
      // Letter, Other
      /\u00AA\u00BA\u01BB\u01C0-\u01C3\u0294\u05D0-\u05EA\u05F0-\u05F2\u0620-\u063F\u0641-\u064A\u066E-\u066F\u0671-\u06D3\u06D5\u06EE-\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u0800-\u0815\u0840-\u0858\u08A0-\u08B4\u0904-\u0939\u093D\u0950\u0958-\u0961\u0972-\u0980\u0985-\u098C\u098F-\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC-\u09DD\u09DF-\u09E1\u09F0-\u09F1\u0A05-\u0A0A\u0A0F-\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32-\u0A33\u0A35-\u0A36\u0A38-\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2-\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0-\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F-\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32-\u0B33\u0B35-\u0B39\u0B3D\u0B5C-\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99-\u0B9A\u0B9C\u0B9E-\u0B9F\u0BA3-\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60-\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0-\u0CE1\u0CF1-\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32-\u0E33\u0E40-\u0E45\u0E81-\u0E82\u0E84\u0E87-\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA-\u0EAB\u0EAD-\u0EB0\u0EB2-\u0EB3\u0EBD\u0EC0-\u0EC4\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065-\u1066\u106E-\u1070\u1075-\u1081\u108E\u10D0-\u10FA\u10FD-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17DC\u1820-\u1842\u1844-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE-\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C77\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5-\u1CF6\u2135-\u2138\u2D30-\u2D67\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3006\u303C\u3041-\u3096\u309F\u30A1-\u30FA\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA014\uA016-\uA48C\uA4D0-\uA4F7\uA500-\uA60B\uA610-\uA61F\uA62A-\uA62B\uA66E\uA6A0-\uA6E5\uA78F\uA7F7\uA7FB-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9E0-\uA9E4\uA9E7-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA6F\uAA71-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5-\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADC\uAAE0-\uAAEA\uAAF2\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40-\uFB41\uFB43-\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF66-\uFF6F\uFF71-\uFF9D\uFFA0-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC/.source,
  ].join('') + ']');
  class BibtexParser {
      parse(input, options = {}) {
          // this._progress = 0
          this.pos = 0;
          this.input = input;
          this.max_entries = options.max_entries || 0;
          this.entries = 0;
          this.parsing = null;
          this.chunks = [];
          if (options.async) {
              return this.bibtexAsync().then(() => this.chunks);
          }
          else {
              this.bibtex();
              return this.chunks;
          }
      }
      isWhitespace(s, horizontalOnly = false) {
          return (s === ' ' || s === '\t' || (!horizontalOnly && (s === '\r' || s === '\n')));
      }
      match(s) {
          this.skipWhitespace();
          if (this.input.substr(this.pos, s.length) !== s) {
              throw new ParseError(`Token mismatch, expected ${JSON.stringify(s)}, found ${JSON.stringify(this.input.substr(this.pos, 20))}...`, this); // tslint:disable-line no-magic-numbers
          }
          this.pos += s.length;
          this.skipWhitespace();
      }
      tryMatch(s) {
          this.skipWhitespace();
          return (this.input.substr(this.pos, s.length) === s);
          // this.skipWhitespace()
      }
      skipWhitespace() {
          while (this.pos < this.input.length && this.isWhitespace(this.input[this.pos]))
              this.pos++;
          // shady
          if (this.input[this.pos] === '%') {
              while (this.pos < this.input.length && this.input[this.pos] !== '\n')
                  this.pos++;
              while (this.pos < this.input.length && this.isWhitespace(this.input[this.pos]))
                  this.pos++;
          }
      }
      value_braces() {
          let bracecount = 0;
          this.match('{');
          const start = this.pos;
          let math = false;
          while (true) {
              switch (this.input[this.pos]) {
                  case '\\':
                      this.pos += 1;
                      break;
                  case '{':
                      bracecount++;
                      break;
                  case '}':
                      if (bracecount === 0) {
                          if (math)
                              throw new ParseError('Unclosed math section', this);
                          this.pos++;
                          return this.input.substring(start, this.pos - 1);
                      }
                      bracecount--;
                      break;
                  case '$':
                      math = !math;
                      break;
              }
              this.pos++;
              if (this.pos >= this.input.length) {
                  throw new ParseError(`Unterminated brace-value ${JSON.stringify(this.input.substr(start, 20))}`, this); // tslint:disable-line no-magic-numbers
              }
          }
      }
      value_quotes() {
          this.match('"');
          const start = this.pos;
          let bracecount = 0;
          while (true) {
              switch (this.input[this.pos]) {
                  case '\\':
                      this.pos += 1;
                      break;
                  case '{':
                      bracecount++;
                      break;
                  case '}':
                      bracecount--;
                      break;
                  case '"':
                      if (bracecount <= 0) {
                          this.pos++;
                          return this.input.substring(start, this.pos - 1);
                      }
              }
              this.pos++;
              if (this.pos >= this.input.length) {
                  throw new ParseError(`Unterminated quote-value ${JSON.stringify(this.input.substr(start, 20))}`, this); // tslint:disable-line no-magic-numbers
              }
          }
      }
      single_value() {
          if (this.tryMatch('{')) {
              return this.value_braces();
          }
          else if (this.tryMatch('"')) {
              return this.value_quotes();
          }
          else {
              return this.key();
          }
      }
      value() {
          const values = [];
          values.push(this.single_value());
          while (this.tryMatch('#')) {
              this.match('#');
              values.push(this.single_value());
          }
          return values.join('');
      }
      key(allowUnicode = false) {
          const start = this.pos;
          while (true) {
              if (this.pos === this.input.length) {
                  throw new ParseError('Runaway key', this);
              }
              if (this.input[this.pos].match(/['a-zA-Z0-9&;_:\\./-]/)) {
                  this.pos++;
              }
              else if (allowUnicode && this.input[this.pos].match(letter)) {
                  this.pos++;
              }
              else {
                  return this.input.substring(start, this.pos);
              }
          }
      }
      key_equals_value() {
          const key = this.key();
          if (!this.tryMatch('=')) {
              throw new ParseError(`... = value expected, equals sign missing: ${JSON.stringify(this.input.substr(this.pos, 20))}...`, this); // tslint:disable-line no-magic-numbers
          }
          this.match('=');
          const val = this.value();
          return [key, val];
      }
      key_value_list() {
          this.key_equals_value();
          while (this.tryMatch(',')) {
              this.match(',');
              // fixes problems with commas at the end of a list
              if (this.tryMatch('}')) {
                  break;
              }
              this.key_equals_value();
          }
      }
      entry(d) {
          this.parsing = this.key(true);
          this.match(',');
          this.key_value_list();
      }
      directive() {
          this.match('@');
          return `@${this.key()}`.toLowerCase();
      }
      string() {
          this.key_equals_value();
      }
      preamble() {
          this.value();
      }
      comment() {
          while (this.isWhitespace(this.input[this.pos], true))
              this.pos++;
          if (this.input[this.pos] === '{') {
              this.value_braces();
              return;
          }
          while (this.input[this.pos] !== '\n' && this.pos < this.input.length)
              this.pos++;
      }
      /*
      private progress() {
        const progress = Math.round((this.pos / this.input.length * 100) / 5) * 5 // tslint:disable-line no-magic-numbers
        if (this._progress !== progress) {
          this._progress = progress
          process.stdout.write(` (${this._progress}%) `)
        }
      }
      */
      hasMore() {
          if (this.max_entries && this.entries >= this.max_entries)
              return false;
          return (this.pos < this.input.length);
      }
      bibtex() {
          while (this.hasMore()) {
              this.parseNext();
          }
      }
      bibtexAsync() {
          return this.hasMore() ? (new Promise(resolve => resolve(this.parseNext()))).then(() => this.bibtexAsync()) : Promise.resolve(null);
      }
      parseNext() {
          // this.progress()
          const chunk = {
              offset: {
                  pos: this.pos,
                  line: this.input.substring(0, this.pos).split('\n').length - 1,
              },
              error: null,
              text: null,
          };
          this.skipWhitespace();
          if (this.pos >= this.input.length)
              return;
          let guard = '';
          try {
              const d = this.directive();
              switch (d) {
                  case '@string':
                      this.match('{');
                      this.string();
                      this.match('}');
                      chunk.stringDeclaration = true;
                      break;
                  case '@preamble':
                      this.match('{');
                      this.preamble();
                      this.match('}');
                      chunk.preamble = true;
                      break;
                  case '@comment':
                      this.comment();
                      chunk.comment = true;
                      break;
                  default:
                      if (this.tryMatch('{')) {
                          guard = '{}';
                      }
                      else if (this.tryMatch('(')) {
                          guard = '()';
                      }
                      else {
                          throw new ParseError(`Token mismatch, expected '{' or '(', found ${JSON.stringify(this.input.substr(this.pos, 20))}...`, this); // tslint:disable-line no-magic-numbers
                      }
                      this.match(guard[0]);
                      this.entry(d);
                      this.match(guard[1]);
                      chunk.entry = true;
                      this.entries++;
                      break;
              }
          }
          catch (err) {
              if (err.name !== 'ParseError')
                  throw err;
              chunk.error = err.message,
                  // skip ahead to the next @ and try again
                  this.pos = chunk.offset.pos + 1;
              while (this.pos < this.input.length && this.input[this.pos] !== '@')
                  this.pos++;
          }
          const text = this.input.substring(chunk.offset.pos, this.pos);
          const last = this.chunks.length - 1;
          if (chunk.error && this.chunks.length && this.chunks[last].error) {
              this.chunks[last].text += text;
          }
          else {
              chunk.text = text;
              this.chunks.push(chunk);
          }
      }
  }
  /**
   * Reads the bibtex input and splits it into separate chunks of `@string`s, `@comment`s, and bibtex entries. Useful for detecting if a file is bibtex file and for filtering out basic errors that would
   * make the more sophisticated [[bibtex.parse]] reject the whole file
   *
   * @returns array of chunks, with markers for type and errors (if any) found.
   */
  function parse(input, options = {}) {
      return (new BibtexParser).parse(input, options);
  }
  exports.parse = parse;

  });

  var $ = {
  	math: "\\$",
  	text: "\\$"
  };
  var _ = {
  	math: "\\_",
  	text: "\\_"
  };
  var require$$0 = {
  	"#": {
  	math: "\\#",
  	text: "\\#"
  },
  	$: $,
  	"%": {
  	math: "\\%",
  	text: "\\%"
  },
  	"&": {
  	math: "\\&",
  	text: "\\&"
  },
  	"/​": {
  	text: "\\slash",
  	commandspacer: true
  },
  	"<": {
  	math: "<"
  },
  	">": {
  	math: ">"
  },
  	"\\": {
  	math: "\\backslash",
  	text: "\\textbackslash",
  	commandspacer: true
  },
  	"^": {
  	math: "\\sphat",
  	text: "\\^"
  },
  	_: _,
  	"i︠a︡": {
  	text: "\\t{ia}"
  },
  	"{": {
  	math: "\\lbrace",
  	text: "\\{"
  },
  	"}": {
  	math: "\\rbrace",
  	text: "\\}"
  },
  	"~": {
  	math: "\\sptilde",
  	text: "\\textasciitilde",
  	commandspacer: true
  },
  	" ": {
  	math: "~",
  	space: true,
  	text: "~"
  },
  	"¡": {
  	text: "\\textexclamdown",
  	commandspacer: true
  },
  	"¢": {
  	math: "\\cent",
  	text: "\\textcent",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"£": {
  	math: "\\pounds",
  	text: "\\textsterling",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"¤": {
  	text: "\\textcurrency",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"¥": {
  	math: "\\yen",
  	text: "\\textyen",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"¦": {
  	text: "\\textbrokenbar",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"§": {
  	text: "\\textsection",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"¨": {
  	math: "\\spddot",
  	text: "\\textasciidieresis",
  	commandspacer: true
  },
  	"©": {
  	text: "\\textcopyright",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"ª": {
  	text: "\\textordfeminine",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"«": {
  	text: "\\guillemotleft",
  	commandspacer: true
  },
  	"¬": {
  	math: "\\lnot"
  },
  	"­": {
  	math: "\\-",
  	text: "\\-"
  },
  	"®": {
  	math: "\\circledR",
  	text: "\\textregistered",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"¯": {
  	text: "\\textasciimacron",
  	commandspacer: true
  },
  	"°": {
  	math: "^\\circ",
  	text: "\\textdegree",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"±": {
  	math: "\\pm"
  },
  	"²": {
  	math: "^{2}"
  },
  	"³": {
  	math: "^{3}"
  },
  	"´": {
  	text: "\\textasciiacute",
  	commandspacer: true
  },
  	"µ": {
  	text: "\\textmu",
  	commandspacer: true
  },
  	"¶": {
  	text: "\\textparagraph",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"·": {
  	math: "\\cdot"
  },
  	"¸": {
  	text: "\\c",
  	commandspacer: true
  },
  	"¹": {
  	math: "^{1}"
  },
  	"º": {
  	text: "\\textordmasculine",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"»": {
  	text: "\\guillemotright",
  	commandspacer: true
  },
  	"¼": {
  	math: "\\frac{1}{4}"
  },
  	"½": {
  	math: "\\frac{1}{2}"
  },
  	"¾": {
  	math: "\\frac{3}{4}"
  },
  	"¿": {
  	text: "\\textquestiondown",
  	commandspacer: true
  },
  	"À": {
  	text: "\\`A"
  },
  	"Á": {
  	text: "\\'A"
  },
  	"Â": {
  	text: "\\^A"
  },
  	"Ã": {
  	text: "\\~A"
  },
  	"Ä": {
  	text: "\\\"A"
  },
  	"Å": {
  	text: "\\AA",
  	commandspacer: true
  },
  	"Æ": {
  	text: "\\AE",
  	commandspacer: true
  },
  	"Ç": {
  	text: "\\c{C}"
  },
  	"È": {
  	text: "\\`E"
  },
  	"É": {
  	text: "\\'E"
  },
  	"Ê": {
  	text: "\\^E"
  },
  	"Ë": {
  	text: "\\\"E"
  },
  	"Ì": {
  	text: "\\`I"
  },
  	"Í": {
  	text: "\\'I"
  },
  	"Î": {
  	text: "\\^I"
  },
  	"Ï": {
  	text: "\\\"I"
  },
  	"Ð": {
  	text: "\\DH",
  	commandspacer: true
  },
  	"Ñ": {
  	text: "\\~N"
  },
  	"Ò": {
  	text: "\\`O"
  },
  	"Ó": {
  	text: "\\'O"
  },
  	"Ô": {
  	text: "\\^O"
  },
  	"Õ": {
  	text: "\\~O"
  },
  	"Ö": {
  	text: "\\\"O"
  },
  	"×": {
  	math: "\\times",
  	text: "\\texttimes",
  	commandspacer: true
  },
  	"Ø": {
  	text: "\\O",
  	commandspacer: true
  },
  	"Ù": {
  	text: "\\`U"
  },
  	"Ú": {
  	text: "\\'U"
  },
  	"Û": {
  	text: "\\^U"
  },
  	"Ü": {
  	text: "\\\"U"
  },
  	"Ý": {
  	text: "\\'Y"
  },
  	"Þ": {
  	text: "\\TH",
  	commandspacer: true
  },
  	"ß": {
  	text: "\\ss",
  	commandspacer: true
  },
  	"à": {
  	text: "\\`a"
  },
  	"á": {
  	text: "\\'a"
  },
  	"â": {
  	text: "\\^a"
  },
  	"ã": {
  	text: "\\~a"
  },
  	"ä": {
  	text: "\\\"a"
  },
  	"å": {
  	text: "\\aa",
  	commandspacer: true
  },
  	"æ": {
  	text: "\\ae",
  	commandspacer: true
  },
  	"ç": {
  	text: "\\c{c}"
  },
  	"è": {
  	text: "\\`e"
  },
  	"é": {
  	text: "\\'e"
  },
  	"ê": {
  	text: "\\^e"
  },
  	"ë": {
  	text: "\\\"e"
  },
  	"ì": {
  	text: "\\`i"
  },
  	"í": {
  	text: "\\'i"
  },
  	"î": {
  	text: "\\^i"
  },
  	"ï": {
  	text: "\\\"i"
  },
  	"ð": {
  	math: "\\eth",
  	mathpackages: [
  		"amssymb",
  		"arevmath"
  	],
  	text: "\\dh",
  	commandspacer: true
  },
  	"ñ": {
  	text: "\\~n"
  },
  	"ò": {
  	text: "\\`o"
  },
  	"ó": {
  	text: "\\'o"
  },
  	"ô": {
  	text: "\\^o"
  },
  	"õ": {
  	text: "\\~o"
  },
  	"ö": {
  	text: "\\\"o"
  },
  	"÷": {
  	math: "\\div"
  },
  	"ø": {
  	text: "\\o",
  	commandspacer: true
  },
  	"ù": {
  	text: "\\`u"
  },
  	"ú": {
  	text: "\\'u"
  },
  	"û": {
  	text: "\\^u"
  },
  	"ü": {
  	text: "\\\"u"
  },
  	"ý": {
  	text: "\\'y"
  },
  	"þ": {
  	text: "\\th",
  	commandspacer: true
  },
  	"ÿ": {
  	text: "\\\"y"
  },
  	"Ā": {
  	text: "\\=A"
  },
  	"ā": {
  	text: "\\=a"
  },
  	"Ă": {
  	text: "\\u{A}"
  },
  	"ă": {
  	text: "\\u{a}"
  },
  	"Ą": {
  	text: "\\k{A}"
  },
  	"ą": {
  	text: "\\k{a}"
  },
  	"Ć": {
  	text: "\\'C"
  },
  	"ć": {
  	text: "\\'c"
  },
  	"Ĉ": {
  	text: "\\^C"
  },
  	"ĉ": {
  	text: "\\^c"
  },
  	"Ċ": {
  	text: "\\.C"
  },
  	"ċ": {
  	text: "\\.c"
  },
  	"Č": {
  	text: "\\v{C}"
  },
  	"č": {
  	text: "\\v{c}"
  },
  	"Ď": {
  	text: "\\v{D}"
  },
  	"ď": {
  	text: "\\v{d}"
  },
  	"Đ": {
  	text: "\\DJ",
  	commandspacer: true
  },
  	"đ": {
  	text: "\\dj",
  	commandspacer: true
  },
  	"Ē": {
  	text: "\\=E"
  },
  	"ē": {
  	text: "\\=e"
  },
  	"Ĕ": {
  	text: "\\u{E}"
  },
  	"ĕ": {
  	text: "\\u{e}"
  },
  	"Ė": {
  	text: "\\.E"
  },
  	"ė": {
  	text: "\\.e"
  },
  	"Ę": {
  	text: "\\k{E}"
  },
  	"ę": {
  	text: "\\k{e}"
  },
  	"Ě": {
  	text: "\\v{E}"
  },
  	"ě": {
  	text: "\\v{e}"
  },
  	"Ĝ": {
  	text: "\\^G"
  },
  	"ĝ": {
  	text: "\\^g"
  },
  	"Ğ": {
  	text: "\\u{G}"
  },
  	"ğ": {
  	text: "\\u{g}"
  },
  	"Ġ": {
  	text: "\\.G"
  },
  	"ġ": {
  	text: "\\.g"
  },
  	"Ģ": {
  	text: "\\c{G}"
  },
  	"ģ": {
  	text: "\\c{g}"
  },
  	"Ĥ": {
  	text: "\\^H"
  },
  	"ĥ": {
  	text: "\\^h"
  },
  	"Ħ": {
  	text: "{\\fontencoding{LELA}\\selectfont\\char40}"
  },
  	"ħ": {
  	math: "\\Elzxh"
  },
  	"Ĩ": {
  	text: "\\~I"
  },
  	"ĩ": {
  	text: "\\~i"
  },
  	"Ī": {
  	text: "\\=I"
  },
  	"ī": {
  	text: "\\=i"
  },
  	"Ĭ": {
  	text: "\\u{I}"
  },
  	"ĭ": {
  	text: "{\\u \\i}"
  },
  	"Į": {
  	text: "\\k{I}"
  },
  	"į": {
  	text: "\\k{i}"
  },
  	"İ": {
  	text: "\\.I"
  },
  	"ı": {
  	math: "\\imath",
  	text: "\\i",
  	commandspacer: true
  },
  	"Ĳ": {
  	text: "IJ"
  },
  	"ĳ": {
  	text: "ij"
  },
  	"Ĵ": {
  	text: "\\^J"
  },
  	"ĵ": {
  	text: "\\^\\j",
  	commandspacer: true
  },
  	"Ķ": {
  	text: "\\c{K}"
  },
  	"ķ": {
  	text: "\\c{k}"
  },
  	"ĸ": {
  	text: "{\\fontencoding{LELA}\\selectfont\\char91}"
  },
  	"Ĺ": {
  	text: "\\'L"
  },
  	"ĺ": {
  	text: "\\'l"
  },
  	"Ļ": {
  	text: "\\c{L}"
  },
  	"ļ": {
  	text: "\\c{l}"
  },
  	"Ľ": {
  	text: "\\v{L}"
  },
  	"ľ": {
  	text: "\\v{l}"
  },
  	"Ŀ": {
  	text: "{\\fontencoding{LELA}\\selectfont\\char201}"
  },
  	"ŀ": {
  	text: "{\\fontencoding{LELA}\\selectfont\\char202}"
  },
  	"Ł": {
  	text: "\\L",
  	commandspacer: true
  },
  	"ł": {
  	text: "\\l",
  	commandspacer: true
  },
  	"Ń": {
  	text: "\\'N"
  },
  	"ń": {
  	text: "\\'n"
  },
  	"Ņ": {
  	text: "\\c{N}"
  },
  	"ņ": {
  	text: "\\c{n}"
  },
  	"Ň": {
  	text: "\\v{N}"
  },
  	"ň": {
  	text: "\\v{n}"
  },
  	"ŉ": {
  	text: "'n"
  },
  	"Ŋ": {
  	text: "\\NG",
  	commandspacer: true
  },
  	"ŋ": {
  	text: "\\ng",
  	commandspacer: true
  },
  	"Ō": {
  	text: "\\=O"
  },
  	"ō": {
  	text: "\\=o"
  },
  	"Ŏ": {
  	text: "\\u{O}"
  },
  	"ŏ": {
  	text: "\\u{o}"
  },
  	"Ő": {
  	text: "\\H{O}"
  },
  	"ő": {
  	text: "\\H{o}"
  },
  	"Œ": {
  	text: "\\OE",
  	commandspacer: true
  },
  	"œ": {
  	text: "\\oe",
  	commandspacer: true
  },
  	"Ŕ": {
  	text: "\\'R"
  },
  	"ŕ": {
  	text: "\\'r"
  },
  	"Ŗ": {
  	text: "\\c{R}"
  },
  	"ŗ": {
  	text: "\\c{r}"
  },
  	"Ř": {
  	text: "\\v{R}"
  },
  	"ř": {
  	text: "\\v{r}"
  },
  	"Ś": {
  	text: "\\'S"
  },
  	"ś": {
  	text: "\\'s"
  },
  	"Ŝ": {
  	text: "\\^S"
  },
  	"ŝ": {
  	text: "\\^s"
  },
  	"Ş": {
  	text: "\\c{S}"
  },
  	"ş": {
  	text: "\\c{s}"
  },
  	"Š": {
  	text: "\\v{S}"
  },
  	"š": {
  	text: "\\v{s}"
  },
  	"Ţ": {
  	text: "\\c{T}"
  },
  	"ţ": {
  	text: "\\c{t}"
  },
  	"Ť": {
  	text: "\\v{T}"
  },
  	"ť": {
  	text: "\\v{t}"
  },
  	"Ŧ": {
  	text: "{\\fontencoding{LELA}\\selectfont\\char47}"
  },
  	"ŧ": {
  	text: "{\\fontencoding{LELA}\\selectfont\\char63}"
  },
  	"Ũ": {
  	text: "\\~U"
  },
  	"ũ": {
  	text: "\\~u"
  },
  	"Ū": {
  	text: "\\=U"
  },
  	"ū": {
  	text: "\\=u"
  },
  	"Ŭ": {
  	text: "\\u{U}"
  },
  	"ŭ": {
  	text: "\\u{u}"
  },
  	"Ů": {
  	text: "\\r{U}"
  },
  	"ů": {
  	text: "\\r{u}"
  },
  	"Ű": {
  	text: "\\H{U}"
  },
  	"ű": {
  	text: "\\H{u}"
  },
  	"Ų": {
  	text: "\\k{U}"
  },
  	"ų": {
  	text: "\\k{u}"
  },
  	"Ŵ": {
  	text: "\\^W"
  },
  	"ŵ": {
  	text: "\\^w"
  },
  	"Ŷ": {
  	text: "\\^Y"
  },
  	"ŷ": {
  	text: "\\^y"
  },
  	"Ÿ": {
  	text: "\\\"Y"
  },
  	"Ź": {
  	text: "\\'Z"
  },
  	"ź": {
  	text: "\\'z"
  },
  	"Ż": {
  	text: "\\.Z"
  },
  	"ż": {
  	text: "\\.z"
  },
  	"Ž": {
  	text: "\\v{Z}"
  },
  	"ž": {
  	text: "\\v{z}"
  },
  	"ſ": {
  	text: "s"
  },
  	"ƒ": {
  	math: "f"
  },
  	"ƕ": {
  	text: "\\texthvlig",
  	commandspacer: true
  },
  	"ƞ": {
  	text: "\\textnrleg",
  	commandspacer: true
  },
  	"ƪ": {
  	text: "\\textesh",
  	commandspacer: true
  },
  	"Ƶ": {
  	math: "\\Zbar"
  },
  	"ƺ": {
  	text: "{\\fontencoding{LELA}\\selectfont\\char195}"
  },
  	"ǂ": {
  	text: "\\textdoublepipe",
  	commandspacer: true
  },
  	"Ǎ": {
  	text: "\\v{A}"
  },
  	"ǎ": {
  	text: "\\v{a}"
  },
  	"Ǐ": {
  	text: "\\v{I}"
  },
  	"ǐ": {
  	text: "\\v{i}"
  },
  	"Ǒ": {
  	text: "\\v{O}"
  },
  	"ǒ": {
  	text: "\\v{o}"
  },
  	"Ǔ": {
  	text: "\\v{U}"
  },
  	"ǔ": {
  	text: "\\v{u}"
  },
  	"Ǧ": {
  	text: "\\v{G}"
  },
  	"ǧ": {
  	text: "\\v{g}"
  },
  	"Ǩ": {
  	text: "\\v{K}"
  },
  	"ǩ": {
  	text: "\\v{k}"
  },
  	"Ǫ": {
  	text: "\\k{O}"
  },
  	"ǫ": {
  	text: "\\k{o}"
  },
  	"ǰ": {
  	text: "\\v{j}"
  },
  	"Ǵ": {
  	text: "\\'G"
  },
  	"ǵ": {
  	text: "\\'g"
  },
  	"Ȩ": {
  	text: "\\c{E}"
  },
  	"ȩ": {
  	text: "\\c{e}"
  },
  	"ȷ": {
  	math: "\\jmath"
  },
  	"ɐ": {
  	math: "\\Elztrna"
  },
  	"ɒ": {
  	math: "\\Elztrnsa"
  },
  	"ɔ": {
  	math: "\\Elzopeno"
  },
  	"ɖ": {
  	math: "\\Elzrtld"
  },
  	"ɘ": {
  	text: "{\\fontencoding{LEIP}\\selectfont\\char61}"
  },
  	"ə": {
  	math: "\\Elzschwa"
  },
  	"ɛ": {
  	math: "\\varepsilon"
  },
  	"ɡ": {
  	text: "g"
  },
  	"ɣ": {
  	math: "\\Elzpgamma"
  },
  	"ɤ": {
  	math: "\\Elzpbgam"
  },
  	"ɥ": {
  	math: "\\Elztrnh"
  },
  	"ɬ": {
  	math: "\\Elzbtdl"
  },
  	"ɭ": {
  	math: "\\Elzrtll"
  },
  	"ɯ": {
  	math: "\\Elztrnm"
  },
  	"ɰ": {
  	math: "\\Elztrnmlr"
  },
  	"ɱ": {
  	math: "\\Elzltlmr"
  },
  	"ɲ": {
  	text: "\\Elzltln",
  	commandspacer: true
  },
  	"ɳ": {
  	math: "\\Elzrtln"
  },
  	"ɷ": {
  	math: "\\Elzclomeg"
  },
  	"ɸ": {
  	text: "\\textphi",
  	commandspacer: true
  },
  	"ɹ": {
  	math: "\\Elztrnr"
  },
  	"ɺ": {
  	math: "\\Elztrnrl"
  },
  	"ɻ": {
  	math: "\\Elzrttrnr"
  },
  	"ɼ": {
  	math: "\\Elzrl"
  },
  	"ɽ": {
  	math: "\\Elzrtlr"
  },
  	"ɾ": {
  	math: "\\Elzfhr"
  },
  	"ɿ": {
  	text: "{\\fontencoding{LEIP}\\selectfont\\char202}"
  },
  	"ʂ": {
  	math: "\\Elzrtls"
  },
  	"ʃ": {
  	math: "\\Elzesh"
  },
  	"ʇ": {
  	math: "\\Elztrnt"
  },
  	"ʈ": {
  	math: "\\Elzrtlt"
  },
  	"ʊ": {
  	math: "\\Elzpupsil"
  },
  	"ʋ": {
  	math: "\\Elzpscrv"
  },
  	"ʌ": {
  	math: "\\Elzinvv"
  },
  	"ʍ": {
  	math: "\\Elzinvw"
  },
  	"ʎ": {
  	math: "\\Elztrny"
  },
  	"ʐ": {
  	math: "\\Elzrtlz"
  },
  	"ʒ": {
  	math: "\\Elzyogh"
  },
  	"ʔ": {
  	math: "\\Elzglst"
  },
  	"ʕ": {
  	math: "\\Elzreglst"
  },
  	"ʖ": {
  	math: "\\Elzinglst"
  },
  	"ʞ": {
  	text: "\\textturnk",
  	commandspacer: true
  },
  	"ʤ": {
  	math: "\\Elzdyogh"
  },
  	"ʧ": {
  	math: "\\Elztesh"
  },
  	"ʰ": {
  	math: "^{h}",
  	text: "\\textsuperscript{h}"
  },
  	"ʲ": {
  	math: "^{j}",
  	text: "\\textsuperscript{j}"
  },
  	"ʳ": {
  	math: "^{r}",
  	text: "\\textsuperscript{r}"
  },
  	"ʷ": {
  	math: "^{w}",
  	text: "\\textsuperscript{w}"
  },
  	"ʸ": {
  	math: "^{y}",
  	text: "\\textsuperscript{y}"
  },
  	"ʹ": {
  	text: "'"
  },
  	"ʻ": {
  	text: "'"
  },
  	"ʼ": {
  	text: "'"
  },
  	"ʽ": {
  	text: "'"
  },
  	"ʿ": {
  	text: "\\lasp",
  	commandspacer: true,
  	textpackages: [
  		"mathscinet"
  	]
  },
  	"ˆ": {
  	text: "\\textasciicircum",
  	commandspacer: true
  },
  	"ˇ": {
  	text: "\\textasciicaron",
  	commandspacer: true
  },
  	"ˈ": {
  	math: "\\Elzverts"
  },
  	"ˉ": {
  	text: "-"
  },
  	"ˌ": {
  	math: "\\Elzverti"
  },
  	"ː": {
  	math: "\\Elzlmrk"
  },
  	"ˑ": {
  	math: "\\Elzhlmrk"
  },
  	"˒": {
  	math: "\\Elzsbrhr"
  },
  	"˓": {
  	math: "\\Elzsblhr"
  },
  	"˔": {
  	math: "\\Elzrais"
  },
  	"˕": {
  	math: "\\Elzlow"
  },
  	"˘": {
  	text: "\\textasciibreve",
  	commandspacer: true
  },
  	"˙": {
  	text: "\\textperiodcentered",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"˚": {
  	text: "\\r{}"
  },
  	"˛": {
  	text: "\\k{}"
  },
  	"˜": {
  	text: "\\texttildelow",
  	commandspacer: true
  },
  	"˝": {
  	text: "\\H{}"
  },
  	"ˡ": {
  	math: "^{l}",
  	text: "\\textsuperscript{l}"
  },
  	"ˢ": {
  	math: "^{s}",
  	text: "\\textsuperscript{s}"
  },
  	"ˣ": {
  	math: "^{x}",
  	text: "\\textsuperscript{x}"
  },
  	"˥": {
  	text: "\\tone{55}"
  },
  	"˦": {
  	text: "\\tone{44}"
  },
  	"˧": {
  	text: "\\tone{33}"
  },
  	"˨": {
  	text: "\\tone{22}"
  },
  	"˩": {
  	text: "\\tone{11}"
  },
  	"̀": {
  	math: "\\grave",
  	combiningdiacritic: true,
  	text: "\\`"
  },
  	"̀̄": {
  	text: "\\textgravemacron",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̄̀": {
  	text: "\\textgravemacron",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̀̇": {
  	text: "\\textgravedot",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̇̀": {
  	text: "\\textgravedot",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"́": {
  	math: "\\acute",
  	combiningdiacritic: true,
  	text: "\\'"
  },
  	"́̄": {
  	text: "\\textacutemacron",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̄́": {
  	text: "\\textacutemacron",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"́̌": {
  	text: "\\textacutewedge",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̌́": {
  	text: "\\textacutewedge",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̂": {
  	math: "\\hat",
  	combiningdiacritic: true,
  	text: "\\^"
  },
  	"̂̇": {
  	text: "\\textcircumdot",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̇̂": {
  	text: "\\textcircumdot",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̃": {
  	math: "\\tilde",
  	combiningdiacritic: true,
  	text: "\\~"
  },
  	"̃̇": {
  	text: "\\texttildedot",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̇̃": {
  	text: "\\texttildedot",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̄": {
  	math: "\\bar",
  	combiningdiacritic: true,
  	text: "\\="
  },
  	"̅": {
  	math: "\\overline",
  	combiningdiacritic: true
  },
  	"̆": {
  	math: "\\breve",
  	combiningdiacritic: true,
  	text: "\\u",
  	commandspacer: true
  },
  	"̆̄": {
  	text: "\\textbrevemacron",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̄̆": {
  	text: "\\textbrevemacron",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̇": {
  	math: "\\dot",
  	combiningdiacritic: true,
  	text: "\\."
  },
  	"̇́": {
  	text: "\\textdotacute",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"́̇": {
  	text: "\\textdotacute",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̇̆": {
  	text: "\\textdotbreve",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̆̇": {
  	text: "\\textdotbreve",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̈": {
  	math: "\\ddot",
  	combiningdiacritic: true,
  	text: "\\\""
  },
  	"̉": {
  	math: "\\ovhook"
  },
  	"̊": {
  	math: "\\mathring",
  	combiningdiacritic: true,
  	text: "\\r",
  	commandspacer: true
  },
  	"̊̄": {
  	text: "\\textringmacron",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̄̊": {
  	text: "\\textringmacron",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̋": {
  	text: "\\H",
  	commandspacer: true,
  	combiningdiacritic: true
  },
  	"̌": {
  	math: "\\check",
  	text: "\\v",
  	commandspacer: true,
  	combiningdiacritic: true
  },
  	"̍": {
  	text: "\\textvbaraccent",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̎": {
  	text: "\\textdoublevbaraccent",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̏": {
  	text: "\\textdoublegrave",
  	commandspacer: true,
  	combiningdiacritic: true
  },
  	"̐": {
  	text: "\\textdotbreve",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̑": {
  	text: "{\\fontencoding{LECO}\\selectfont\\char177}"
  },
  	"̒": {
  	math: "\\oturnedcomma"
  },
  	"̕": {
  	math: "\\ocommatopright"
  },
  	"̖": {
  	text: "\\textsubgrave",
  	commandspacer: true,
  	combiningdiacritic: true
  },
  	"̘": {
  	text: "\\textadvancing",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̙": {
  	text: "\\textretracting",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̚": {
  	math: "\\droang",
  	text: "\\textcorner",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̜": {
  	text: "\\textsublhalfring",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̝": {
  	text: "\\textraising",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̞": {
  	text: "\\textlowering",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̟": {
  	text: "\\textsubplus",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̡": {
  	math: "\\Elzpalh"
  },
  	"̢": {
  	text: "\\Elzrh",
  	commandspacer: true
  },
  	"̣": {
  	text: "\\d",
  	commandspacer: true,
  	combiningdiacritic: true
  },
  	"̤": {
  	text: "\\textsubumlaut",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̥": {
  	text: "\\textsubring",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̧": {
  	text: "\\c",
  	commandspacer: true,
  	combiningdiacritic: true
  },
  	"̨": {
  	text: "\\k",
  	commandspacer: true,
  	combiningdiacritic: true
  },
  	"̩": {
  	text: "\\textsyllabic",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̪": {
  	math: "\\Elzsbbrg",
  	text: "\\textsubbridge",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̫": {
  	text: "{\\fontencoding{LECO}\\selectfont\\char203}"
  },
  	"̬": {
  	text: "\\textsubwedge",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̯": {
  	text: "\\textsubarch",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̰": {
  	math: "\\utilde",
  	text: "\\textsubtilde",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̱": {
  	math: "\\underbar",
  	combiningdiacritic: true,
  	text: "\\textsubbar",
  	commandspacer: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̲": {
  	math: "\\underline"
  },
  	"̴": {
  	text: "\\textsuperimposetilde",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̵": {
  	text: "\\Elzxl",
  	commandspacer: true
  },
  	"̶": {
  	text: "\\Elzbar",
  	commandspacer: true
  },
  	"̷": {
  	text: "{\\fontencoding{LECO}\\selectfont\\char215}"
  },
  	"̸": {
  	math: "\\not"
  },
  	"̹": {
  	text: "\\textsubrhalfring",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̺": {
  	text: "\\textinvsubbridge",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̻": {
  	text: "\\textsubsquare",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̼": {
  	text: "\\textseagull",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̽": {
  	text: "\\textovercross",
  	commandspacer: true,
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"͡": {
  	text: "{\\fontencoding{LECO}\\selectfont\\char225}"
  },
  	"ʹ": {
  	text: "'"
  },
  	"͵": {
  	text: ","
  },
  	";": {
  	text: ";"
  },
  	"Ά": {
  	text: "\\'A"
  },
  	"Έ": {
  	text: "\\'E"
  },
  	"Ή": {
  	text: "\\'H"
  },
  	"Ί": {
  	text: "{\\'{}I}"
  },
  	"Ό": {
  	text: "{\\'{}O}"
  },
  	"Ύ": {
  	math: "\\mathrm{'Y}"
  },
  	"Ώ": {
  	math: "\\mathrm{'\\Omega}"
  },
  	"ΐ": {
  	math: "\\acute{\\ddot{\\iota}}"
  },
  	"Α": {
  	math: "A"
  },
  	"Β": {
  	math: "B"
  },
  	"Γ": {
  	math: "\\Gamma"
  },
  	"Δ": {
  	math: "\\Delta"
  },
  	"Ε": {
  	math: "E"
  },
  	"Ζ": {
  	math: "Z"
  },
  	"Η": {
  	math: "H"
  },
  	"Θ": {
  	math: "\\Theta"
  },
  	"Ι": {
  	math: "I"
  },
  	"Κ": {
  	math: "K"
  },
  	"Λ": {
  	math: "\\Lambda"
  },
  	"Μ": {
  	math: "M"
  },
  	"Ν": {
  	math: "N"
  },
  	"Ξ": {
  	math: "\\Xi"
  },
  	"Ο": {
  	math: "O"
  },
  	"Π": {
  	math: "\\Pi"
  },
  	"Ρ": {
  	math: "P"
  },
  	"Σ": {
  	math: "\\Sigma"
  },
  	"Τ": {
  	math: "T"
  },
  	"Υ": {
  	math: "\\Upsilon"
  },
  	"Φ": {
  	math: "\\Phi"
  },
  	"Χ": {
  	math: "X"
  },
  	"Ψ": {
  	math: "\\Psi"
  },
  	"Ω": {
  	math: "\\Omega"
  },
  	"Ϊ": {
  	math: "\\mathrm{\\ddot{I}}"
  },
  	"Ϋ": {
  	math: "\\mathrm{\\ddot{Y}}"
  },
  	"ά": {
  	text: "{\\'$\\alpha$}"
  },
  	"έ": {
  	math: "\\acute{\\epsilon}"
  },
  	"ή": {
  	math: "\\acute{\\eta}"
  },
  	"ί": {
  	math: "\\acute{\\iota}"
  },
  	"ΰ": {
  	math: "\\acute{\\ddot{\\upsilon}}"
  },
  	"α": {
  	math: "\\alpha"
  },
  	"β": {
  	math: "\\beta"
  },
  	"γ": {
  	math: "\\gamma"
  },
  	"δ": {
  	math: "\\delta"
  },
  	"ε": {
  	math: "\\epsilon"
  },
  	"ζ": {
  	math: "\\zeta"
  },
  	"η": {
  	math: "\\eta"
  },
  	"θ": {
  	math: "\\theta",
  	text: "\\texttheta",
  	commandspacer: true
  },
  	"ι": {
  	math: "\\iota"
  },
  	"κ": {
  	math: "\\kappa"
  },
  	"λ": {
  	math: "\\lambda"
  },
  	"μ": {
  	math: "\\mu"
  },
  	"ν": {
  	math: "\\nu"
  },
  	"ξ": {
  	math: "\\xi"
  },
  	"ο": {
  	math: "o"
  },
  	"π": {
  	math: "\\pi"
  },
  	"ρ": {
  	math: "\\rho"
  },
  	"ς": {
  	math: "\\varsigma"
  },
  	"σ": {
  	math: "\\sigma"
  },
  	"τ": {
  	math: "\\tau"
  },
  	"υ": {
  	math: "\\upsilon"
  },
  	"φ": {
  	math: "\\varphi"
  },
  	"χ": {
  	math: "\\chi"
  },
  	"ψ": {
  	math: "\\psi"
  },
  	"ω": {
  	math: "\\omega"
  },
  	"ϊ": {
  	math: "\\ddot{\\iota}"
  },
  	"ϋ": {
  	math: "\\ddot{\\upsilon}"
  },
  	"ό": {
  	text: "\\'o"
  },
  	"ύ": {
  	math: "\\acute{\\upsilon}"
  },
  	"ώ": {
  	math: "\\acute{\\omega}"
  },
  	"ϐ": {
  	math: "\\varbeta",
  	text: "\\Pisymbol{ppi022}{87}"
  },
  	"ϑ": {
  	math: "\\vartheta",
  	text: "\\textvartheta",
  	commandspacer: true
  },
  	"ϒ": {
  	math: "\\Upsilon"
  },
  	"ϕ": {
  	math: "\\phi"
  },
  	"ϖ": {
  	math: "\\varpi"
  },
  	"Ϙ": {
  	math: "\\Qoppa"
  },
  	"ϙ": {
  	math: "\\qoppa"
  },
  	"Ϛ": {
  	math: "\\Stigma"
  },
  	"ϛ": {
  	math: "\\stigma"
  },
  	"Ϝ": {
  	math: "\\Digamma"
  },
  	"ϝ": {
  	math: "\\digamma"
  },
  	"Ϟ": {
  	math: "\\Koppa"
  },
  	"ϟ": {
  	math: "\\koppa"
  },
  	"Ϡ": {
  	math: "\\Sampi"
  },
  	"ϡ": {
  	math: "\\sampi"
  },
  	"ϰ": {
  	math: "\\varkappa"
  },
  	"ϱ": {
  	math: "\\varrho"
  },
  	"ϴ": {
  	math: "\\upvarTheta",
  	text: "\\textTheta",
  	commandspacer: true
  },
  	"ϵ": {
  	math: "\\epsilon"
  },
  	"϶": {
  	math: "\\backepsilon"
  },
  	"Ё": {
  	text: "\\cyrchar\\CYRYO",
  	commandspacer: true
  },
  	"Ђ": {
  	text: "\\cyrchar\\CYRDJE",
  	commandspacer: true
  },
  	"Ѓ": {
  	text: "\\cyrchar{\\'\\CYRG}"
  },
  	"Є": {
  	text: "\\cyrchar\\CYRIE",
  	commandspacer: true
  },
  	"Ѕ": {
  	text: "\\cyrchar\\CYRDZE",
  	commandspacer: true
  },
  	"І": {
  	text: "\\cyrchar\\CYRII",
  	commandspacer: true
  },
  	"Ї": {
  	text: "\\cyrchar\\CYRYI",
  	commandspacer: true
  },
  	"Ј": {
  	text: "\\cyrchar\\CYRJE",
  	commandspacer: true
  },
  	"Љ": {
  	text: "\\cyrchar\\CYRLJE",
  	commandspacer: true
  },
  	"Њ": {
  	text: "\\cyrchar\\CYRNJE",
  	commandspacer: true
  },
  	"Ћ": {
  	text: "\\cyrchar\\CYRTSHE",
  	commandspacer: true
  },
  	"Ќ": {
  	text: "\\cyrchar{\\'\\CYRK}"
  },
  	"Ў": {
  	text: "\\cyrchar\\CYRUSHRT",
  	commandspacer: true
  },
  	"Џ": {
  	text: "\\cyrchar\\CYRDZHE",
  	commandspacer: true
  },
  	"А": {
  	text: "\\cyrchar\\CYRA",
  	commandspacer: true
  },
  	"Б": {
  	text: "\\cyrchar\\CYRB",
  	commandspacer: true
  },
  	"В": {
  	text: "\\cyrchar\\CYRV",
  	commandspacer: true
  },
  	"Г": {
  	text: "\\cyrchar\\CYRG",
  	commandspacer: true
  },
  	"Д": {
  	text: "\\cyrchar\\CYRD",
  	commandspacer: true
  },
  	"Е": {
  	text: "\\cyrchar\\CYRE",
  	commandspacer: true
  },
  	"Ж": {
  	text: "\\cyrchar\\CYRZH",
  	commandspacer: true
  },
  	"З": {
  	text: "\\cyrchar\\CYRZ",
  	commandspacer: true
  },
  	"И": {
  	text: "\\cyrchar\\CYRI",
  	commandspacer: true
  },
  	"Й": {
  	text: "\\cyrchar\\CYRISHRT",
  	commandspacer: true
  },
  	"К": {
  	text: "\\cyrchar\\CYRK",
  	commandspacer: true
  },
  	"Л": {
  	text: "\\cyrchar\\CYRL",
  	commandspacer: true
  },
  	"М": {
  	text: "\\cyrchar\\CYRM",
  	commandspacer: true
  },
  	"Н": {
  	text: "\\cyrchar\\CYRN",
  	commandspacer: true
  },
  	"О": {
  	text: "\\cyrchar\\CYRO",
  	commandspacer: true
  },
  	"П": {
  	text: "\\cyrchar\\CYRP",
  	commandspacer: true
  },
  	"Р": {
  	text: "\\cyrchar\\CYRR",
  	commandspacer: true
  },
  	"С": {
  	text: "\\cyrchar\\CYRS",
  	commandspacer: true
  },
  	"Т": {
  	text: "\\cyrchar\\CYRT",
  	commandspacer: true
  },
  	"У": {
  	text: "\\cyrchar\\CYRU",
  	commandspacer: true
  },
  	"Ф": {
  	text: "\\cyrchar\\CYRF",
  	commandspacer: true
  },
  	"Х": {
  	text: "\\cyrchar\\CYRH",
  	commandspacer: true
  },
  	"Ц": {
  	text: "\\cyrchar\\CYRC",
  	commandspacer: true
  },
  	"Ч": {
  	text: "\\cyrchar\\CYRCH",
  	commandspacer: true
  },
  	"Ш": {
  	text: "\\cyrchar\\CYRSH",
  	commandspacer: true
  },
  	"Щ": {
  	text: "\\cyrchar\\CYRSHCH",
  	commandspacer: true
  },
  	"Ъ": {
  	text: "\\cyrchar\\CYRHRDSN",
  	commandspacer: true
  },
  	"Ы": {
  	text: "\\cyrchar\\CYRERY",
  	commandspacer: true
  },
  	"Ь": {
  	text: "\\cyrchar\\CYRSFTSN",
  	commandspacer: true
  },
  	"Э": {
  	text: "\\cyrchar\\CYREREV",
  	commandspacer: true
  },
  	"Ю": {
  	text: "\\cyrchar\\CYRYU",
  	commandspacer: true
  },
  	"Я": {
  	text: "\\cyrchar\\CYRYA",
  	commandspacer: true
  },
  	"а": {
  	text: "\\cyrchar\\cyra",
  	commandspacer: true
  },
  	"б": {
  	text: "\\cyrchar\\cyrb",
  	commandspacer: true
  },
  	"в": {
  	text: "\\cyrchar\\cyrv",
  	commandspacer: true
  },
  	"г": {
  	text: "\\cyrchar\\cyrg",
  	commandspacer: true
  },
  	"д": {
  	text: "\\cyrchar\\cyrd",
  	commandspacer: true
  },
  	"е": {
  	text: "\\cyrchar\\cyre",
  	commandspacer: true
  },
  	"ж": {
  	text: "\\cyrchar\\cyrzh",
  	commandspacer: true
  },
  	"з": {
  	text: "\\cyrchar\\cyrz",
  	commandspacer: true
  },
  	"и": {
  	text: "\\cyrchar\\cyri",
  	commandspacer: true
  },
  	"й": {
  	text: "\\cyrchar\\cyrishrt",
  	commandspacer: true
  },
  	"к": {
  	text: "\\cyrchar\\cyrk",
  	commandspacer: true
  },
  	"л": {
  	text: "\\cyrchar\\cyrl",
  	commandspacer: true
  },
  	"м": {
  	text: "\\cyrchar\\cyrm",
  	commandspacer: true
  },
  	"н": {
  	text: "\\cyrchar\\cyrn",
  	commandspacer: true
  },
  	"о": {
  	text: "\\cyrchar\\cyro",
  	commandspacer: true
  },
  	"п": {
  	text: "\\cyrchar\\cyrp",
  	commandspacer: true
  },
  	"р": {
  	text: "\\cyrchar\\cyrr",
  	commandspacer: true
  },
  	"с": {
  	text: "\\cyrchar\\cyrs",
  	commandspacer: true
  },
  	"т": {
  	text: "\\cyrchar\\cyrt",
  	commandspacer: true
  },
  	"у": {
  	text: "\\cyrchar\\cyru",
  	commandspacer: true
  },
  	"ф": {
  	text: "\\cyrchar\\cyrf",
  	commandspacer: true
  },
  	"х": {
  	text: "\\cyrchar\\cyrh",
  	commandspacer: true
  },
  	"ц": {
  	text: "\\cyrchar\\cyrc",
  	commandspacer: true
  },
  	"ч": {
  	text: "\\cyrchar\\cyrch",
  	commandspacer: true
  },
  	"ш": {
  	text: "\\cyrchar\\cyrsh",
  	commandspacer: true
  },
  	"щ": {
  	text: "\\cyrchar\\cyrshch",
  	commandspacer: true
  },
  	"ъ": {
  	text: "\\cyrchar\\cyrhrdsn",
  	commandspacer: true
  },
  	"ы": {
  	text: "\\cyrchar\\cyrery",
  	commandspacer: true
  },
  	"ь": {
  	text: "\\cyrchar\\cyrsftsn",
  	commandspacer: true
  },
  	"э": {
  	text: "\\cyrchar\\cyrerev",
  	commandspacer: true
  },
  	"ю": {
  	text: "\\cyrchar\\cyryu",
  	commandspacer: true
  },
  	"я": {
  	text: "\\cyrchar\\cyrya",
  	commandspacer: true
  },
  	"ё": {
  	text: "\\cyrchar\\cyryo",
  	commandspacer: true
  },
  	"ђ": {
  	text: "\\cyrchar\\cyrdje",
  	commandspacer: true
  },
  	"ѓ": {
  	text: "\\cyrchar{\\'\\cyrg}"
  },
  	"є": {
  	text: "\\cyrchar\\cyrie",
  	commandspacer: true
  },
  	"ѕ": {
  	text: "\\cyrchar\\cyrdze",
  	commandspacer: true
  },
  	"і": {
  	text: "\\cyrchar\\cyrii",
  	commandspacer: true
  },
  	"ї": {
  	text: "\\cyrchar\\cyryi",
  	commandspacer: true
  },
  	"ј": {
  	text: "\\cyrchar\\cyrje",
  	commandspacer: true
  },
  	"љ": {
  	text: "\\cyrchar\\cyrlje",
  	commandspacer: true
  },
  	"њ": {
  	text: "\\cyrchar\\cyrnje",
  	commandspacer: true
  },
  	"ћ": {
  	text: "\\cyrchar\\cyrtshe",
  	commandspacer: true
  },
  	"ќ": {
  	text: "\\cyrchar{\\'\\cyrk}"
  },
  	"ў": {
  	text: "\\cyrchar\\cyrushrt",
  	commandspacer: true
  },
  	"џ": {
  	text: "\\cyrchar\\cyrdzhe",
  	commandspacer: true
  },
  	"Ѡ": {
  	text: "\\cyrchar\\CYROMEGA",
  	commandspacer: true
  },
  	"ѡ": {
  	text: "\\cyrchar\\cyromega",
  	commandspacer: true
  },
  	"Ѣ": {
  	text: "\\cyrchar\\CYRYAT",
  	commandspacer: true
  },
  	"Ѥ": {
  	text: "\\cyrchar\\CYRIOTE",
  	commandspacer: true
  },
  	"ѥ": {
  	text: "\\cyrchar\\cyriote",
  	commandspacer: true
  },
  	"Ѧ": {
  	text: "\\cyrchar\\CYRLYUS",
  	commandspacer: true
  },
  	"ѧ": {
  	text: "\\cyrchar\\cyrlyus",
  	commandspacer: true
  },
  	"Ѩ": {
  	text: "\\cyrchar\\CYRIOTLYUS",
  	commandspacer: true
  },
  	"ѩ": {
  	text: "\\cyrchar\\cyriotlyus",
  	commandspacer: true
  },
  	"Ѫ": {
  	text: "\\cyrchar\\CYRBYUS",
  	commandspacer: true
  },
  	"Ѭ": {
  	text: "\\cyrchar\\CYRIOTBYUS",
  	commandspacer: true
  },
  	"ѭ": {
  	text: "\\cyrchar\\cyriotbyus",
  	commandspacer: true
  },
  	"Ѯ": {
  	text: "\\cyrchar\\CYRKSI",
  	commandspacer: true
  },
  	"ѯ": {
  	text: "\\cyrchar\\cyrksi",
  	commandspacer: true
  },
  	"Ѱ": {
  	text: "\\cyrchar\\CYRPSI",
  	commandspacer: true
  },
  	"ѱ": {
  	text: "\\cyrchar\\cyrpsi",
  	commandspacer: true
  },
  	"Ѳ": {
  	text: "\\cyrchar\\CYRFITA",
  	commandspacer: true
  },
  	"Ѵ": {
  	text: "\\cyrchar\\CYRIZH",
  	commandspacer: true
  },
  	"Ѹ": {
  	text: "\\cyrchar\\CYRUK",
  	commandspacer: true
  },
  	"ѹ": {
  	text: "\\cyrchar\\cyruk",
  	commandspacer: true
  },
  	"Ѻ": {
  	text: "\\cyrchar\\CYROMEGARND",
  	commandspacer: true
  },
  	"ѻ": {
  	text: "\\cyrchar\\cyromegarnd",
  	commandspacer: true
  },
  	"Ѽ": {
  	text: "\\cyrchar\\CYROMEGATITLO",
  	commandspacer: true
  },
  	"ѽ": {
  	text: "\\cyrchar\\cyromegatitlo",
  	commandspacer: true
  },
  	"Ѿ": {
  	text: "\\cyrchar\\CYROT",
  	commandspacer: true
  },
  	"ѿ": {
  	text: "\\cyrchar\\cyrot",
  	commandspacer: true
  },
  	"Ҁ": {
  	text: "\\cyrchar\\CYRKOPPA",
  	commandspacer: true
  },
  	"ҁ": {
  	text: "\\cyrchar\\cyrkoppa",
  	commandspacer: true
  },
  	"҂": {
  	text: "\\cyrchar\\cyrthousands",
  	commandspacer: true
  },
  	"҈": {
  	text: "\\cyrchar\\cyrhundredthousands",
  	commandspacer: true
  },
  	"҉": {
  	text: "\\cyrchar\\cyrmillions",
  	commandspacer: true
  },
  	"Ҍ": {
  	text: "\\cyrchar\\CYRSEMISFTSN",
  	commandspacer: true
  },
  	"ҍ": {
  	text: "\\cyrchar\\cyrsemisftsn",
  	commandspacer: true
  },
  	"Ҏ": {
  	text: "\\cyrchar\\CYRRTICK",
  	commandspacer: true
  },
  	"ҏ": {
  	text: "\\cyrchar\\cyrrtick",
  	commandspacer: true
  },
  	"Ґ": {
  	text: "\\cyrchar\\CYRGUP",
  	commandspacer: true
  },
  	"ґ": {
  	text: "\\cyrchar\\cyrgup",
  	commandspacer: true
  },
  	"Ғ": {
  	text: "\\cyrchar\\CYRGHCRS",
  	commandspacer: true
  },
  	"ғ": {
  	text: "\\cyrchar\\cyrghcrs",
  	commandspacer: true
  },
  	"Ҕ": {
  	text: "\\cyrchar\\CYRGHK",
  	commandspacer: true
  },
  	"ҕ": {
  	text: "\\cyrchar\\cyrghk",
  	commandspacer: true
  },
  	"Җ": {
  	text: "\\cyrchar\\CYRZHDSC",
  	commandspacer: true
  },
  	"җ": {
  	text: "\\cyrchar\\cyrzhdsc",
  	commandspacer: true
  },
  	"Ҙ": {
  	text: "\\cyrchar\\CYRZDSC",
  	commandspacer: true
  },
  	"ҙ": {
  	text: "\\cyrchar\\cyrzdsc",
  	commandspacer: true
  },
  	"Қ": {
  	text: "\\cyrchar\\CYRKDSC",
  	commandspacer: true
  },
  	"қ": {
  	text: "\\cyrchar\\cyrkdsc",
  	commandspacer: true
  },
  	"Ҝ": {
  	text: "\\cyrchar\\CYRKVCRS",
  	commandspacer: true
  },
  	"ҝ": {
  	text: "\\cyrchar\\cyrkvcrs",
  	commandspacer: true
  },
  	"Ҟ": {
  	text: "\\cyrchar\\CYRKHCRS",
  	commandspacer: true
  },
  	"ҟ": {
  	text: "\\cyrchar\\cyrkhcrs",
  	commandspacer: true
  },
  	"Ҡ": {
  	text: "\\cyrchar\\CYRKBEAK",
  	commandspacer: true
  },
  	"ҡ": {
  	text: "\\cyrchar\\cyrkbeak",
  	commandspacer: true
  },
  	"Ң": {
  	text: "\\cyrchar\\CYRNDSC",
  	commandspacer: true
  },
  	"ң": {
  	text: "\\cyrchar\\cyrndsc",
  	commandspacer: true
  },
  	"Ҥ": {
  	text: "\\cyrchar\\CYRNG",
  	commandspacer: true
  },
  	"ҥ": {
  	text: "\\cyrchar\\cyrng",
  	commandspacer: true
  },
  	"Ҧ": {
  	text: "\\cyrchar\\CYRPHK",
  	commandspacer: true
  },
  	"ҧ": {
  	text: "\\cyrchar\\cyrphk",
  	commandspacer: true
  },
  	"Ҩ": {
  	text: "\\cyrchar\\CYRABHHA",
  	commandspacer: true
  },
  	"ҩ": {
  	text: "\\cyrchar\\cyrabhha",
  	commandspacer: true
  },
  	"Ҫ": {
  	text: "\\cyrchar\\CYRSDSC",
  	commandspacer: true
  },
  	"ҫ": {
  	text: "\\cyrchar\\cyrsdsc",
  	commandspacer: true
  },
  	"Ҭ": {
  	text: "\\cyrchar\\CYRTDSC",
  	commandspacer: true
  },
  	"ҭ": {
  	text: "\\cyrchar\\cyrtdsc",
  	commandspacer: true
  },
  	"Ү": {
  	text: "\\cyrchar\\CYRY",
  	commandspacer: true
  },
  	"ү": {
  	text: "\\cyrchar\\cyry",
  	commandspacer: true
  },
  	"Ұ": {
  	text: "\\cyrchar\\CYRYHCRS",
  	commandspacer: true
  },
  	"ұ": {
  	text: "\\cyrchar\\cyryhcrs",
  	commandspacer: true
  },
  	"Ҳ": {
  	text: "\\cyrchar\\CYRHDSC",
  	commandspacer: true
  },
  	"ҳ": {
  	text: "\\cyrchar\\cyrhdsc",
  	commandspacer: true
  },
  	"Ҵ": {
  	text: "\\cyrchar\\CYRTETSE",
  	commandspacer: true
  },
  	"ҵ": {
  	text: "\\cyrchar\\cyrtetse",
  	commandspacer: true
  },
  	"Ҷ": {
  	text: "\\cyrchar\\CYRCHRDSC",
  	commandspacer: true
  },
  	"ҷ": {
  	text: "\\cyrchar\\cyrchrdsc",
  	commandspacer: true
  },
  	"Ҹ": {
  	text: "\\cyrchar\\CYRCHVCRS",
  	commandspacer: true
  },
  	"ҹ": {
  	text: "\\cyrchar\\cyrchvcrs",
  	commandspacer: true
  },
  	"Һ": {
  	text: "\\cyrchar\\CYRSHHA",
  	commandspacer: true
  },
  	"һ": {
  	text: "\\cyrchar\\cyrshha",
  	commandspacer: true
  },
  	"Ҽ": {
  	text: "\\cyrchar\\CYRABHCH",
  	commandspacer: true
  },
  	"ҽ": {
  	text: "\\cyrchar\\cyrabhch",
  	commandspacer: true
  },
  	"Ҿ": {
  	text: "\\cyrchar\\CYRABHCHDSC",
  	commandspacer: true
  },
  	"ҿ": {
  	text: "\\cyrchar\\cyrabhchdsc",
  	commandspacer: true
  },
  	"Ӏ": {
  	text: "\\cyrchar\\CYRpalochka",
  	commandspacer: true
  },
  	"Ӄ": {
  	text: "\\cyrchar\\CYRKHK",
  	commandspacer: true
  },
  	"ӄ": {
  	text: "\\cyrchar\\cyrkhk",
  	commandspacer: true
  },
  	"Ӈ": {
  	text: "\\cyrchar\\CYRNHK",
  	commandspacer: true
  },
  	"ӈ": {
  	text: "\\cyrchar\\cyrnhk",
  	commandspacer: true
  },
  	"Ӌ": {
  	text: "\\cyrchar\\CYRCHLDSC",
  	commandspacer: true
  },
  	"ӌ": {
  	text: "\\cyrchar\\cyrchldsc",
  	commandspacer: true
  },
  	"Ӕ": {
  	text: "\\cyrchar\\CYRAE",
  	commandspacer: true
  },
  	"ӕ": {
  	text: "\\cyrchar\\cyrae",
  	commandspacer: true
  },
  	"Ә": {
  	text: "\\cyrchar\\CYRSCHWA",
  	commandspacer: true
  },
  	"ә": {
  	text: "\\cyrchar\\cyrschwa",
  	commandspacer: true
  },
  	"Ӡ": {
  	text: "\\cyrchar\\CYRABHDZE",
  	commandspacer: true
  },
  	"ӡ": {
  	text: "\\cyrchar\\cyrabhdze",
  	commandspacer: true
  },
  	"Ө": {
  	text: "\\cyrchar\\CYROTLD",
  	commandspacer: true
  },
  	"ө": {
  	text: "\\cyrchar\\cyrotld",
  	commandspacer: true
  },
  	"ࡱ": {
  	math: "\\\\backslash"
  },
  	"ᵃ": {
  	math: "^{a}",
  	text: "\\textsuperscript{a}"
  },
  	"ᵇ": {
  	math: "^{b}",
  	text: "\\textsuperscript{b}"
  },
  	"ᵈ": {
  	math: "^{d}",
  	text: "\\textsuperscript{d}"
  },
  	"ᵉ": {
  	math: "^{e}",
  	text: "\\textsuperscript{e}"
  },
  	"ᵍ": {
  	math: "^{g}",
  	text: "\\textsuperscript{g}"
  },
  	"ᵏ": {
  	math: "^{k}",
  	text: "\\textsuperscript{k}"
  },
  	"ᵐ": {
  	math: "^{m}",
  	text: "\\textsuperscript{m}"
  },
  	"ᵒ": {
  	math: "^{o}",
  	text: "\\textsuperscript{o}"
  },
  	"ᵖ": {
  	math: "^{p}",
  	text: "\\textsuperscript{p}"
  },
  	"ᵗ": {
  	math: "^{t}",
  	text: "\\textsuperscript{t}"
  },
  	"ᵘ": {
  	math: "^{u}",
  	text: "\\textsuperscript{u}"
  },
  	"ᵛ": {
  	math: "^{v}",
  	text: "\\textsuperscript{v}"
  },
  	"ᶜ": {
  	math: "^{c}",
  	text: "\\textsuperscript{c}"
  },
  	"ᶠ": {
  	math: "^{f}",
  	text: "\\textsuperscript{f}"
  },
  	"ᶻ": {
  	math: "^{z}",
  	text: "\\textsuperscript{z}"
  },
  	"Ḃ": {
  	text: "\\.B"
  },
  	"ḃ": {
  	text: "\\.b"
  },
  	"Ḅ": {
  	text: "\\d{B}"
  },
  	"ḅ": {
  	text: "\\d{b}"
  },
  	"Ḇ": {
  	text: "\\b{B}"
  },
  	"ḇ": {
  	text: "\\b{b}"
  },
  	"Ḋ": {
  	text: "\\.D"
  },
  	"ḋ": {
  	text: "\\.d"
  },
  	"Ḍ": {
  	text: "\\d{D}"
  },
  	"ḍ": {
  	text: "\\d{d}"
  },
  	"Ḏ": {
  	text: "\\b{D}"
  },
  	"ḏ": {
  	text: "\\b{d}"
  },
  	"Ḑ": {
  	text: "\\c{D}"
  },
  	"ḑ": {
  	text: "\\c{d}"
  },
  	"Ḝ": {
  	text: "\\c{\\u{E}}"
  },
  	"ḝ": {
  	text: "\\c{\\u{e}}"
  },
  	"Ḟ": {
  	text: "\\.F"
  },
  	"ḟ": {
  	text: "\\.f"
  },
  	"Ḡ": {
  	text: "\\=G"
  },
  	"ḡ": {
  	text: "\\=g"
  },
  	"Ḣ": {
  	text: "\\.H"
  },
  	"ḣ": {
  	text: "\\.h"
  },
  	"Ḥ": {
  	text: "\\d{H}"
  },
  	"ḥ": {
  	text: "\\d{h}"
  },
  	"Ḧ": {
  	text: "\\\"H"
  },
  	"ḧ": {
  	text: "\\\"h"
  },
  	"Ḩ": {
  	text: "\\c{H}"
  },
  	"ḩ": {
  	text: "\\c{h}"
  },
  	"Ḱ": {
  	text: "\\'K"
  },
  	"ḱ": {
  	text: "\\'k"
  },
  	"Ḳ": {
  	text: "\\d{K}"
  },
  	"ḳ": {
  	text: "\\d{k}"
  },
  	"Ḵ": {
  	text: "\\b{K}"
  },
  	"ḵ": {
  	text: "\\b{k}"
  },
  	"Ḷ": {
  	text: "\\d{L}"
  },
  	"ḷ": {
  	text: "\\d{l}"
  },
  	"Ḻ": {
  	text: "\\b{L}"
  },
  	"ḻ": {
  	text: "\\b{l}"
  },
  	"Ḿ": {
  	text: "\\'M"
  },
  	"ḿ": {
  	text: "\\'m"
  },
  	"Ṁ": {
  	text: "\\.M"
  },
  	"ṁ": {
  	text: "\\.m"
  },
  	"Ṃ": {
  	text: "\\d{M}"
  },
  	"ṃ": {
  	text: "\\d{m}"
  },
  	"Ṅ": {
  	text: "\\.N"
  },
  	"ṅ": {
  	text: "\\.n"
  },
  	"Ṇ": {
  	text: "\\d{N}"
  },
  	"ṇ": {
  	text: "\\d{n}"
  },
  	"Ṉ": {
  	text: "\\b{N}"
  },
  	"ṉ": {
  	text: "\\b{n}"
  },
  	"Ṕ": {
  	text: "\\'P"
  },
  	"ṕ": {
  	text: "\\'p"
  },
  	"Ṗ": {
  	text: "\\.P"
  },
  	"ṗ": {
  	text: "\\.p"
  },
  	"Ṙ": {
  	text: "\\.R"
  },
  	"ṙ": {
  	text: "\\.r"
  },
  	"Ṛ": {
  	text: "\\d{R}"
  },
  	"ṛ": {
  	text: "\\d{r}"
  },
  	"Ṟ": {
  	text: "\\b{R}"
  },
  	"ṟ": {
  	text: "\\b{r}"
  },
  	"Ṡ": {
  	text: "\\.S"
  },
  	"ṡ": {
  	text: "\\.s"
  },
  	"Ṣ": {
  	text: "\\d{S}"
  },
  	"ṣ": {
  	text: "\\d{s}"
  },
  	"Ṫ": {
  	text: "\\.T"
  },
  	"ṫ": {
  	text: "\\.t"
  },
  	"Ṭ": {
  	text: "\\d{T}"
  },
  	"ṭ": {
  	text: "\\d{t}"
  },
  	"Ṯ": {
  	text: "\\b{T}"
  },
  	"ṯ": {
  	text: "\\b{t}"
  },
  	"Ṽ": {
  	text: "\\~V"
  },
  	"ṽ": {
  	text: "\\~v"
  },
  	"Ṿ": {
  	text: "\\d{V}"
  },
  	"ṿ": {
  	text: "\\d{v}"
  },
  	"Ẁ": {
  	text: "\\`W"
  },
  	"ẁ": {
  	text: "\\`w"
  },
  	"Ẃ": {
  	text: "\\'W"
  },
  	"ẃ": {
  	text: "\\'w"
  },
  	"Ẅ": {
  	text: "\\\"W"
  },
  	"ẅ": {
  	text: "\\\"w"
  },
  	"Ẇ": {
  	text: "\\.W"
  },
  	"ẇ": {
  	text: "\\.w"
  },
  	"Ẉ": {
  	text: "\\d{W}"
  },
  	"ẉ": {
  	text: "\\d{w}"
  },
  	"Ẋ": {
  	text: "\\.X"
  },
  	"ẋ": {
  	text: "\\.x"
  },
  	"Ẍ": {
  	text: "\\\"X"
  },
  	"ẍ": {
  	text: "\\\"x"
  },
  	"Ẏ": {
  	text: "\\.Y"
  },
  	"ẏ": {
  	text: "\\.y"
  },
  	"Ẑ": {
  	text: "\\^Z"
  },
  	"ẑ": {
  	text: "\\^z"
  },
  	"Ẓ": {
  	text: "\\d{Z}"
  },
  	"ẓ": {
  	text: "\\d{z}"
  },
  	"Ẕ": {
  	text: "\\b{Z}"
  },
  	"ẕ": {
  	text: "\\b{z}"
  },
  	"ẖ": {
  	text: "\\b{h}"
  },
  	"ẗ": {
  	text: "\\\"t"
  },
  	"ẘ": {
  	text: "\\r{w}"
  },
  	"ẙ": {
  	text: "\\r{y}"
  },
  	"Ạ": {
  	text: "\\d{A}"
  },
  	"ạ": {
  	text: "\\d{a}"
  },
  	"Ẹ": {
  	text: "\\d{E}"
  },
  	"ẹ": {
  	text: "\\d{e}"
  },
  	"Ẽ": {
  	text: "\\~E"
  },
  	"ẽ": {
  	text: "\\~e"
  },
  	"Ị": {
  	text: "\\d{I}"
  },
  	"ị": {
  	text: "\\d{i}"
  },
  	"Ọ": {
  	text: "\\d{O}"
  },
  	"ọ": {
  	text: "\\d{o}"
  },
  	"Ụ": {
  	text: "\\d{U}"
  },
  	"ụ": {
  	text: "\\d{u}"
  },
  	"Ỳ": {
  	text: "\\`Y"
  },
  	"ỳ": {
  	text: "\\`y"
  },
  	"Ỵ": {
  	text: "\\d{Y}"
  },
  	"ỵ": {
  	text: "\\d{y}"
  },
  	"Ỹ": {
  	text: "\\~Y"
  },
  	"ỹ": {
  	text: "\\~y"
  },
  	" ": {
  	text: " ",
  	space: true
  },
  	" ": {
  	math: "\\quad",
  	space: true
  },
  	" ": {
  	text: "\\hspace{0.6em}",
  	space: true
  },
  	" ": {
  	math: "\\quad",
  	space: true,
  	text: "\\hspace{1em}"
  },
  	" ": {
  	text: "\\;",
  	space: true
  },
  	" ": {
  	text: "\\hspace{0.25em}",
  	space: true
  },
  	" ": {
  	text: "\\hspace{0.166em}",
  	space: true
  },
  	" ": {
  	text: "\\hphantom{0}",
  	space: true
  },
  	" ": {
  	text: "\\hphantom{,}",
  	space: true
  },
  	" ": {
  	text: "\\,",
  	space: true
  },
  	" ": {
  	math: "\\mkern1mu",
  	space: true
  },
  	"​": {
  	text: "\\mbox",
  	commandspacer: true,
  	space: true
  },
  	"‌": {
  	text: "{\\aftergroup\\ignorespaces}"
  },
  	"‐": {
  	text: "-"
  },
  	"‑": {
  	text: "-"
  },
  	"‒": {
  	text: "-"
  },
  	"–": {
  	text: "\\textendash",
  	commandspacer: true
  },
  	"—": {
  	text: "\\textemdash",
  	commandspacer: true
  },
  	"―": {
  	math: "\\horizbar",
  	text: "\\rule{1em}{1pt}"
  },
  	"‖": {
  	math: "\\Vert"
  },
  	"‗": {
  	math: "\\twolowline"
  },
  	"‘": {
  	text: "`"
  },
  	"’": {
  	text: "'"
  },
  	"‚": {
  	text: ","
  },
  	"‛": {
  	math: "\\Elzreapos"
  },
  	"“": {
  	text: "``"
  },
  	"”": {
  	text: "''"
  },
  	"„": {
  	text: ",,"
  },
  	"‟": {
  	text: "\\quotedblbase",
  	commandspacer: true
  },
  	"†": {
  	math: "\\dagger",
  	text: "\\textdagger",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"‡": {
  	math: "\\ddagger",
  	text: "\\textdaggerdbl",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"•": {
  	math: "\\bullet",
  	text: "\\textbullet",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"‣": {
  	text: ">"
  },
  	"․": {
  	text: "."
  },
  	"‥": {
  	math: "\\enleadertwodots",
  	text: ".."
  },
  	"…": {
  	math: "\\ldots",
  	text: "\\ldots",
  	commandspacer: true
  },
  	"‧": {
  	text: "-"
  },
  	" ": {
  	text: " ",
  	space: true
  },
  	"‰": {
  	text: "\\textperthousand",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"‱": {
  	text: "\\textpertenthousand",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"′": {
  	math: "{'}"
  },
  	"″": {
  	math: "{''}"
  },
  	"‴": {
  	math: "{'''}"
  },
  	"‵": {
  	math: "\\backprime"
  },
  	"‶": {
  	math: "\\backdprime"
  },
  	"‷": {
  	math: "\\backtrprime"
  },
  	"‸": {
  	math: "\\caretinsert"
  },
  	"‹": {
  	text: "\\guilsinglleft",
  	commandspacer: true
  },
  	"›": {
  	text: "\\guilsinglright",
  	commandspacer: true
  },
  	"‼": {
  	math: "\\Exclam"
  },
  	"‾": {
  	text: "-"
  },
  	"⁃": {
  	math: "\\hyphenbullet"
  },
  	"⁄": {
  	math: "\\fracslash"
  },
  	"⁇": {
  	math: "\\Question"
  },
  	"⁈": {
  	text: "?!"
  },
  	"⁉": {
  	text: "!?"
  },
  	"⁊": {
  	text: "7"
  },
  	"⁐": {
  	math: "\\closure"
  },
  	"⁗": {
  	math: "''''"
  },
  	" ": {
  	math: "\\:",
  	space: true,
  	text: "\\:"
  },
  	"⁠": {
  	text: "\\nolinebreak",
  	commandspacer: true
  },
  	"⁰": {
  	math: "^{0}"
  },
  	"ⁱ": {
  	math: "^{i}",
  	text: "\\textsuperscript{i}"
  },
  	"⁴": {
  	math: "^{4}"
  },
  	"⁵": {
  	math: "^{5}"
  },
  	"⁶": {
  	math: "^{6}"
  },
  	"⁷": {
  	math: "^{7}"
  },
  	"⁸": {
  	math: "^{8}"
  },
  	"⁹": {
  	math: "^{9}"
  },
  	"⁺": {
  	math: "^{+}"
  },
  	"⁻": {
  	math: "^{-}"
  },
  	"⁼": {
  	math: "^{=}"
  },
  	"⁽": {
  	math: "^{(}"
  },
  	"⁾": {
  	math: "^{)}"
  },
  	"ⁿ": {
  	math: "^{n}",
  	text: "\\textsuperscript{n}"
  },
  	"₀": {
  	math: "_{0}"
  },
  	"₁": {
  	math: "_{1}"
  },
  	"₂": {
  	math: "_{2}"
  },
  	"₃": {
  	math: "_{3}"
  },
  	"₄": {
  	math: "_{4}"
  },
  	"₅": {
  	math: "_{5}"
  },
  	"₆": {
  	math: "_{6}"
  },
  	"₇": {
  	math: "_{7}"
  },
  	"₈": {
  	math: "_{8}"
  },
  	"₉": {
  	math: "_{9}"
  },
  	"₊": {
  	math: "_{+}"
  },
  	"₋": {
  	math: "_{-}"
  },
  	"₌": {
  	math: "_{=}"
  },
  	"₍": {
  	math: "_{(}"
  },
  	"₎": {
  	math: "_{)}"
  },
  	"ₐ": {
  	math: "_{a}",
  	text: "\\textsubscript{a}"
  },
  	"ₑ": {
  	math: "_{e}",
  	text: "\\textsubscript{e}"
  },
  	"ₒ": {
  	math: "_{o}",
  	text: "\\textsubscript{o}"
  },
  	"ₓ": {
  	math: "_{x}",
  	text: "\\textsubscript{x}"
  },
  	"ₔ": {
  	text: "\\textsubscript{\\textschwa}",
  	textpackages: [
  		"tipa"
  	]
  },
  	"ₕ": {
  	math: "_{h}",
  	text: "\\textsubscript{h}"
  },
  	"ₖ": {
  	math: "_{k}",
  	text: "\\textsubscript{k}"
  },
  	"ₗ": {
  	math: "_{l}",
  	text: "\\textsubscript{l}"
  },
  	"ₘ": {
  	math: "_{m}",
  	text: "\\textsubscript{m}"
  },
  	"ₙ": {
  	math: "_{n}",
  	text: "\\textsubscript{n}"
  },
  	"ₚ": {
  	math: "_{p}",
  	text: "\\textsubscript{p}"
  },
  	"ₛ": {
  	math: "_{s}",
  	text: "\\textsubscript{s}"
  },
  	"ₜ": {
  	math: "_{t}",
  	text: "\\textsubscript{t}"
  },
  	"₧": {
  	text: "\\ensuremath{\\Elzpes}"
  },
  	"€": {
  	math: "\\euro",
  	text: "\\texteuro",
  	commandspacer: true
  },
  	"⃐": {
  	math: "\\lvec"
  },
  	"⃑": {
  	math: "\\rightharpoonup",
  	mathpackages: [
  		"amsmath",
  		"amssymb"
  	]
  },
  	"⃒": {
  	math: "\\vertoverlay"
  },
  	"⃖": {
  	math: "\\LVec"
  },
  	"⃗": {
  	math: "\\vec"
  },
  	"⃛": {
  	math: "\\dddot"
  },
  	"⃜": {
  	math: "\\ddddot"
  },
  	"⃝": {
  	math: "\\enclosecircle"
  },
  	"⃞": {
  	math: "\\enclosesquare"
  },
  	"⃟": {
  	math: "\\enclosediamond"
  },
  	"⃡": {
  	math: "\\overleftrightarrow"
  },
  	"⃤": {
  	math: "\\enclosetriangle"
  },
  	"⃧": {
  	math: "\\annuity"
  },
  	"⃨": {
  	math: "\\threeunderdot"
  },
  	"⃩": {
  	math: "\\widebridgeabove"
  },
  	"⃬": {
  	math: "\\underrightharpoondown"
  },
  	"⃭": {
  	math: "\\underleftharpoondown"
  },
  	"⃮": {
  	math: "\\underleftarrow"
  },
  	"⃯": {
  	math: "\\underrightarrow"
  },
  	"⃰": {
  	math: "\\asteraccent"
  },
  	"℀": {
  	text: "a/c"
  },
  	"℁": {
  	text: "a/s"
  },
  	"ℂ": {
  	math: "\\mathbb{C}"
  },
  	"℃": {
  	text: "\\textcelsius",
  	commandspacer: true
  },
  	"℅": {
  	text: "c/o"
  },
  	"℆": {
  	text: "c/u"
  },
  	"ℇ": {
  	math: "\\Euler"
  },
  	"℉": {
  	text: "F"
  },
  	"ℊ": {
  	math: "\\mathscr{g}"
  },
  	"ℋ": {
  	math: "\\mathscr{H}"
  },
  	"ℌ": {
  	math: "\\mathfrak{H}"
  },
  	"ℍ": {
  	math: "\\mathbb{H}"
  },
  	"ℎ": {
  	math: "\\Planckconst"
  },
  	"ℏ": {
  	math: "\\hslash"
  },
  	"ℐ": {
  	math: "\\mathscr{I}"
  },
  	"ℑ": {
  	math: "\\mathfrak{I}"
  },
  	"ℒ": {
  	math: "\\mathscr{L}"
  },
  	"ℓ": {
  	math: "\\mathscr{l}"
  },
  	"ℕ": {
  	math: "\\mathbb{N}"
  },
  	"№": {
  	text: "\\cyrchar\\textnumero",
  	commandspacer: true
  },
  	"℗": {
  	text: "\\textcircledP",
  	commandspacer: true
  },
  	"℘": {
  	math: "\\wp"
  },
  	"ℙ": {
  	math: "\\mathbb{P}"
  },
  	"ℚ": {
  	math: "\\mathbb{Q}"
  },
  	"ℛ": {
  	math: "\\mathscr{R}"
  },
  	"ℜ": {
  	math: "\\mathfrak{R}"
  },
  	"ℝ": {
  	math: "\\mathbb{R}"
  },
  	"℞": {
  	math: "\\Elzxrat"
  },
  	"℠": {
  	text: "\\textservicemark",
  	commandspacer: true
  },
  	"℡": {
  	text: "TEL"
  },
  	"™": {
  	text: "\\texttrademark",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"ℤ": {
  	math: "\\mathbb{Z}"
  },
  	"Ω": {
  	math: "\\Omega"
  },
  	"℧": {
  	math: "\\mho"
  },
  	"ℨ": {
  	math: "\\mathfrak{Z}"
  },
  	"℩": {
  	text: "\\textriota",
  	commandspacer: true
  },
  	"K": {
  	text: "K"
  },
  	"Å": {
  	math: "\\Angstroem",
  	text: "\\AA",
  	commandspacer: true
  },
  	"ℬ": {
  	math: "\\mathscr{B}"
  },
  	"ℭ": {
  	math: "\\mathfrak{C}"
  },
  	"℮": {
  	text: "\\textestimated",
  	commandspacer: true
  },
  	"ℯ": {
  	math: "\\mathscr{e}"
  },
  	"ℰ": {
  	math: "\\mathscr{E}"
  },
  	"ℱ": {
  	math: "\\mathscr{F}"
  },
  	"Ⅎ": {
  	math: "\\Finv"
  },
  	"ℳ": {
  	math: "\\mathscr{M}"
  },
  	"ℴ": {
  	math: "\\mathscr{o}"
  },
  	"ℵ": {
  	math: "\\aleph"
  },
  	"ℶ": {
  	math: "\\beth"
  },
  	"ℷ": {
  	math: "\\gimel"
  },
  	"ℸ": {
  	math: "\\daleth"
  },
  	"ℼ": {
  	math: "\\mathbb{\\pi}"
  },
  	"ℽ": {
  	math: "\\mathbb{\\gamma}"
  },
  	"ℾ": {
  	math: "\\mathbb{\\Gamma}"
  },
  	"ℿ": {
  	math: "\\mathbb{\\Pi}"
  },
  	"⅀": {
  	math: "\\mathbb{\\Sigma}"
  },
  	"⅁": {
  	math: "\\Game"
  },
  	"⅂": {
  	math: "\\sansLturned"
  },
  	"⅃": {
  	math: "\\sansLmirrored"
  },
  	"⅄": {
  	math: "\\Yup"
  },
  	"ⅅ": {
  	math: "\\CapitalDifferentialD"
  },
  	"ⅆ": {
  	math: "\\DifferentialD"
  },
  	"ⅇ": {
  	math: "\\ExponetialE"
  },
  	"ⅈ": {
  	math: "\\ComplexI"
  },
  	"ⅉ": {
  	math: "\\ComplexJ"
  },
  	"⅊": {
  	math: "\\PropertyLine"
  },
  	"⅋": {
  	math: "\\invamp"
  },
  	"⅐": {
  	math: "\\frac{1}{7}"
  },
  	"⅑": {
  	math: "\\frac{1}{9}"
  },
  	"⅒": {
  	math: "\\frac{1}{10}"
  },
  	"⅓": {
  	math: "\\frac{1}{3}"
  },
  	"⅔": {
  	math: "\\frac{2}{3}"
  },
  	"⅕": {
  	math: "\\frac{1}{5}"
  },
  	"⅖": {
  	math: "\\frac{2}{5}"
  },
  	"⅗": {
  	math: "\\frac{3}{5}"
  },
  	"⅘": {
  	math: "\\frac{4}{5}"
  },
  	"⅙": {
  	math: "\\frac{1}{6}"
  },
  	"⅚": {
  	math: "\\frac{5}{6}"
  },
  	"⅛": {
  	math: "\\frac{1}{8}"
  },
  	"⅜": {
  	math: "\\frac{3}{8}"
  },
  	"⅝": {
  	math: "\\frac{5}{8}"
  },
  	"⅞": {
  	math: "\\frac{7}{8}"
  },
  	"⅟": {
  	math: "\\frac{1}"
  },
  	"Ⅰ": {
  	text: "I"
  },
  	"Ⅱ": {
  	text: "II"
  },
  	"Ⅲ": {
  	text: "III"
  },
  	"Ⅳ": {
  	text: "IV"
  },
  	"Ⅴ": {
  	text: "V"
  },
  	"Ⅵ": {
  	text: "VI"
  },
  	"Ⅶ": {
  	text: "VII"
  },
  	"Ⅷ": {
  	text: "VIII"
  },
  	"Ⅸ": {
  	text: "IX"
  },
  	"Ⅹ": {
  	text: "X"
  },
  	"Ⅺ": {
  	text: "XI"
  },
  	"Ⅻ": {
  	text: "XII"
  },
  	"Ⅼ": {
  	text: "L"
  },
  	"Ⅽ": {
  	text: "C"
  },
  	"Ⅾ": {
  	text: "D"
  },
  	"Ⅿ": {
  	text: "M"
  },
  	"ⅰ": {
  	text: "i"
  },
  	"ⅱ": {
  	text: "ii"
  },
  	"ⅲ": {
  	text: "iii"
  },
  	"ⅳ": {
  	text: "iv"
  },
  	"ⅴ": {
  	text: "v"
  },
  	"ⅵ": {
  	text: "vi"
  },
  	"ⅶ": {
  	text: "vii"
  },
  	"ⅷ": {
  	text: "viii"
  },
  	"ⅸ": {
  	text: "ix"
  },
  	"ⅹ": {
  	text: "x"
  },
  	"ⅺ": {
  	text: "xi"
  },
  	"ⅻ": {
  	text: "xii"
  },
  	"ⅼ": {
  	text: "l"
  },
  	"ⅽ": {
  	text: "c"
  },
  	"ⅾ": {
  	text: "d"
  },
  	"ⅿ": {
  	text: "m"
  },
  	"↉": {
  	math: "\\frac{0}{3}"
  },
  	"←": {
  	math: "\\leftarrow"
  },
  	"↑": {
  	math: "\\uparrow"
  },
  	"→": {
  	math: "\\rightarrow",
  	text: "\\textrightarrow",
  	commandspacer: true,
  	textpackages: [
  		"textcomp"
  	]
  },
  	"↓": {
  	math: "\\downarrow"
  },
  	"↔": {
  	math: "\\leftrightarrow"
  },
  	"↕": {
  	math: "\\updownarrow"
  },
  	"↖": {
  	math: "\\nwarrow"
  },
  	"↗": {
  	math: "\\nearrow"
  },
  	"↘": {
  	math: "\\searrow"
  },
  	"↙": {
  	math: "\\swarrow"
  },
  	"↚": {
  	math: "\\nleftarrow"
  },
  	"↛": {
  	math: "\\nrightarrow"
  },
  	"↜": {
  	math: "\\arrowwaveleft"
  },
  	"↝": {
  	math: "\\arrowwaveright"
  },
  	"↞": {
  	math: "\\twoheadleftarrow"
  },
  	"↟": {
  	math: "\\twoheaduparrow"
  },
  	"↠": {
  	math: "\\twoheadrightarrow"
  },
  	"↡": {
  	math: "\\twoheaddownarrow"
  },
  	"↢": {
  	math: "\\leftarrowtail"
  },
  	"↣": {
  	math: "\\rightarrowtail"
  },
  	"↤": {
  	math: "\\mapsfrom"
  },
  	"↥": {
  	math: "\\MapsUp"
  },
  	"↦": {
  	math: "\\mapsto"
  },
  	"↧": {
  	math: "\\MapsDown"
  },
  	"↨": {
  	math: "\\updownarrowbar"
  },
  	"↩": {
  	math: "\\hookleftarrow"
  },
  	"↪": {
  	math: "\\hookrightarrow"
  },
  	"↫": {
  	math: "\\looparrowleft"
  },
  	"↬": {
  	math: "\\looparrowright"
  },
  	"↭": {
  	math: "\\leftrightsquigarrow"
  },
  	"↮": {
  	math: "\\nleftrightarrow"
  },
  	"↯": {
  	math: "\\lightning"
  },
  	"↰": {
  	math: "\\Lsh"
  },
  	"↱": {
  	math: "\\Rsh"
  },
  	"↲": {
  	math: "\\dlsh"
  },
  	"↳": {
  	text: "\\reflectbox{\\carriagereturn}",
  	textpackages: [
  		"graphics",
  		"unicode-math"
  	]
  },
  	"↴": {
  	math: "\\linefeed"
  },
  	"↵": {
  	math: "\\carriagereturn"
  },
  	"↶": {
  	math: "\\curvearrowleft"
  },
  	"↷": {
  	math: "\\curvearrowright"
  },
  	"↸": {
  	math: "\\barovernorthwestarrow"
  },
  	"↹": {
  	math: "\\barleftarrowrightarrowba"
  },
  	"↺": {
  	math: "\\circlearrowleft"
  },
  	"↻": {
  	math: "\\circlearrowright"
  },
  	"↼": {
  	math: "\\leftharpoonup"
  },
  	"↽": {
  	math: "\\leftharpoondown"
  },
  	"↾": {
  	math: "\\upharpoonright"
  },
  	"↿": {
  	math: "\\upharpoonleft"
  },
  	"⇀": {
  	math: "\\rightharpoonup",
  	mathpackages: [
  		"amsmath",
  		"amssymb"
  	]
  },
  	"⇁": {
  	math: "\\rightharpoondown"
  },
  	"⇂": {
  	math: "\\downharpoonright"
  },
  	"⇃": {
  	math: "\\downharpoonleft"
  },
  	"⇄": {
  	math: "\\rightleftarrows"
  },
  	"⇅": {
  	math: "\\dblarrowupdown"
  },
  	"⇆": {
  	math: "\\leftrightarrows"
  },
  	"⇇": {
  	math: "\\leftleftarrows"
  },
  	"⇈": {
  	math: "\\upuparrows"
  },
  	"⇉": {
  	math: "\\rightrightarrows"
  },
  	"⇊": {
  	math: "\\downdownarrows"
  },
  	"⇋": {
  	math: "\\leftrightharpoons"
  },
  	"⇌": {
  	math: "\\rightleftharpoons"
  },
  	"⇍": {
  	math: "\\nLeftarrow"
  },
  	"⇎": {
  	math: "\\nLeftrightarrow"
  },
  	"⇏": {
  	math: "\\nRightarrow"
  },
  	"⇐": {
  	math: "\\Leftarrow"
  },
  	"⇑": {
  	math: "\\Uparrow"
  },
  	"⇒": {
  	math: "\\Rightarrow"
  },
  	"⇓": {
  	math: "\\Downarrow"
  },
  	"⇔": {
  	math: "\\Leftrightarrow"
  },
  	"⇕": {
  	math: "\\Updownarrow"
  },
  	"⇖": {
  	math: "\\Nwarrow"
  },
  	"⇗": {
  	math: "\\Nearrow"
  },
  	"⇘": {
  	math: "\\Searrow"
  },
  	"⇙": {
  	math: "\\Swarrow"
  },
  	"⇚": {
  	math: "\\Lleftarrow"
  },
  	"⇛": {
  	math: "\\Rrightarrow"
  },
  	"⇜": {
  	math: "\\leftsquigarrow"
  },
  	"⇝": {
  	math: "\\rightsquigarrow"
  },
  	"⇞": {
  	math: "\\nHuparrow"
  },
  	"⇟": {
  	math: "\\nHdownarrow"
  },
  	"⇠": {
  	math: "\\dashleftarrow"
  },
  	"⇡": {
  	math: "\\updasharrow"
  },
  	"⇢": {
  	math: "\\dashrightarrow"
  },
  	"⇣": {
  	math: "\\downdasharrow"
  },
  	"⇤": {
  	math: "\\LeftArrowBar"
  },
  	"⇥": {
  	math: "\\RightArrowBar"
  },
  	"⇦": {
  	math: "\\leftwhitearrow"
  },
  	"⇧": {
  	math: "\\upwhitearrow"
  },
  	"⇨": {
  	math: "\\rightwhitearrow"
  },
  	"⇩": {
  	math: "\\downwhitearrow"
  },
  	"⇪": {
  	math: "\\whitearrowupfrombar"
  },
  	"⇴": {
  	math: "\\circleonrightarrow"
  },
  	"⇵": {
  	math: "\\DownArrowUpArrow"
  },
  	"⇶": {
  	math: "\\rightthreearrows"
  },
  	"⇷": {
  	math: "\\nvleftarrow"
  },
  	"⇸": {
  	math: "\\pfun"
  },
  	"⇹": {
  	math: "\\nvleftrightarrow"
  },
  	"⇺": {
  	math: "\\nVleftarrow"
  },
  	"⇻": {
  	math: "\\ffun"
  },
  	"⇼": {
  	math: "\\nVleftrightarrow"
  },
  	"⇽": {
  	math: "\\leftarrowtriangle"
  },
  	"⇾": {
  	math: "\\rightarrowtriangle"
  },
  	"⇿": {
  	math: "\\leftrightarrowtriangle"
  },
  	"∀": {
  	math: "\\forall"
  },
  	"∁": {
  	math: "\\complement"
  },
  	"∂": {
  	math: "\\partial"
  },
  	"∃": {
  	math: "\\exists"
  },
  	"∄": {
  	math: "\\nexists"
  },
  	"∅": {
  	math: "\\varnothing"
  },
  	"∆": {
  	math: "\\increment"
  },
  	"∇": {
  	math: "\\nabla"
  },
  	"∈": {
  	math: "\\in"
  },
  	"∉": {
  	math: "\\not\\in"
  },
  	"∊": {
  	math: "\\smallin"
  },
  	"∋": {
  	math: "\\ni"
  },
  	"∌": {
  	math: "\\not\\ni"
  },
  	"∍": {
  	math: "\\smallni"
  },
  	"∎": {
  	math: "\\QED"
  },
  	"∏": {
  	math: "\\prod"
  },
  	"∐": {
  	math: "\\coprod"
  },
  	"∑": {
  	math: "\\sum"
  },
  	"−": {
  	math: "-",
  	text: "-"
  },
  	"∓": {
  	math: "\\mp"
  },
  	"∔": {
  	math: "\\dotplus"
  },
  	"∕": {
  	text: "/"
  },
  	"∖": {
  	math: "\\setminus"
  },
  	"∗": {
  	math: "{_\\ast}"
  },
  	"∘": {
  	math: "\\circ"
  },
  	"∙": {
  	math: "\\bullet"
  },
  	"√": {
  	math: "\\surd"
  },
  	"∛": {
  	math: "\\sqrt[3]"
  },
  	"∜": {
  	math: "\\sqrt[4]"
  },
  	"∝": {
  	math: "\\propto"
  },
  	"∞": {
  	math: "\\infty"
  },
  	"∟": {
  	math: "\\rightangle"
  },
  	"∠": {
  	math: "\\angle"
  },
  	"∡": {
  	math: "\\measuredangle"
  },
  	"∢": {
  	math: "\\sphericalangle"
  },
  	"∣": {
  	math: "\\mid"
  },
  	"∤": {
  	math: "\\nmid"
  },
  	"∥": {
  	math: "\\parallel"
  },
  	"∦": {
  	math: "\\nparallel"
  },
  	"∧": {
  	math: "\\wedge"
  },
  	"∨": {
  	math: "\\vee"
  },
  	"∩": {
  	math: "\\cap"
  },
  	"∪": {
  	math: "\\cup"
  },
  	"∫": {
  	math: "\\int"
  },
  	"∬": {
  	math: "{\\int\\!\\int}"
  },
  	"∭": {
  	math: "{\\int\\!\\int\\!\\int}"
  },
  	"∮": {
  	math: "\\oint"
  },
  	"∯": {
  	math: "\\surfintegral"
  },
  	"∰": {
  	math: "\\volintegral"
  },
  	"∱": {
  	math: "\\clwintegral"
  },
  	"∲": {
  	math: "\\lcirclerightint",
  	mathpackages: [
  		"MnSymbol"
  	]
  },
  	"∳": {
  	math: "\\rcirclerightint",
  	mathpackages: [
  		"MnSymbol"
  	]
  },
  	"∴": {
  	math: "\\therefore"
  },
  	"∵": {
  	math: "\\because"
  },
  	"∶": {
  	math: ":"
  },
  	"∷": {
  	math: "\\Colon"
  },
  	"∸": {
  	math: "\\dotdiv",
  	mathpackages: [
  		"mathabx"
  	]
  },
  	"∹": {
  	math: "\\eqcolon"
  },
  	"∺": {
  	math: "\\mathbin{{:}\\!\\!{-}\\!\\!{:}}"
  },
  	"∻": {
  	math: "\\homothetic"
  },
  	"∼": {
  	math: "\\sim"
  },
  	"∽": {
  	math: "\\backsim"
  },
  	"∾": {
  	math: "\\lazysinv"
  },
  	"∿": {
  	math: "\\AC"
  },
  	"≀": {
  	math: "\\wr"
  },
  	"≁": {
  	math: "\\not\\sim"
  },
  	"≂": {
  	math: "\\texteqsim",
  	mathpackages: [
  		"xecjk"
  	]
  },
  	"≂̸": {
  	math: "\\NotEqualTilde"
  },
  	"≃": {
  	math: "\\simeq"
  },
  	"≄": {
  	math: "\\not\\simeq"
  },
  	"≅": {
  	math: "\\cong"
  },
  	"≆": {
  	math: "\\approxnotequal"
  },
  	"≇": {
  	math: "\\not\\cong"
  },
  	"≈": {
  	math: "\\approx"
  },
  	"≉": {
  	math: "\\not\\approx"
  },
  	"≊": {
  	math: "\\approxeq"
  },
  	"≋": {
  	math: "\\tildetrpl"
  },
  	"≋̸": {
  	math: "\\not\\apid"
  },
  	"≌": {
  	math: "\\allequal"
  },
  	"≍": {
  	math: "\\asymp"
  },
  	"≎": {
  	math: "\\Bumpeq"
  },
  	"≎̸": {
  	math: "\\NotHumpDownHump"
  },
  	"≏": {
  	math: "\\bumpeq"
  },
  	"≏̸": {
  	math: "\\NotHumpEqual"
  },
  	"≐": {
  	math: "\\doteq"
  },
  	"≐̸": {
  	math: "\\not\\doteq"
  },
  	"≑": {
  	math: "\\doteqdot"
  },
  	"≒": {
  	math: "\\fallingdotseq"
  },
  	"≓": {
  	math: "\\risingdotseq"
  },
  	"≔": {
  	math: "\\coloneq",
  	text: ":="
  },
  	"≕": {
  	math: "=:"
  },
  	"≖": {
  	math: "\\eqcirc"
  },
  	"≗": {
  	math: "\\circeq"
  },
  	"≘": {
  	math: "\\arceq"
  },
  	"≙": {
  	math: "\\estimates"
  },
  	"≛": {
  	math: "\\starequal"
  },
  	"≜": {
  	math: "\\triangleq"
  },
  	"≝": {
  	math: "\\eqdef"
  },
  	"≞": {
  	math: "\\measeq"
  },
  	"≠": {
  	math: "\\neq"
  },
  	"≡": {
  	math: "\\equiv"
  },
  	"≢": {
  	math: "\\not\\equiv"
  },
  	"≣": {
  	math: "\\Equiv"
  },
  	"≤": {
  	math: "\\leq"
  },
  	"≥": {
  	math: "\\geq"
  },
  	"≦": {
  	math: "\\leqq"
  },
  	"≧": {
  	math: "\\geqq"
  },
  	"≨": {
  	math: "\\lneqq"
  },
  	"≨︀": {
  	math: "\\lvertneqq"
  },
  	"≩": {
  	math: "\\gneqq"
  },
  	"≩︀": {
  	math: "\\gvertneqq"
  },
  	"≪": {
  	math: "\\ll"
  },
  	"≪̸": {
  	math: "\\NotLessLess"
  },
  	"≫": {
  	math: "\\gg"
  },
  	"≫̸": {
  	math: "\\NotGreaterGreater"
  },
  	"≬": {
  	math: "\\between"
  },
  	"≭": {
  	math: "{\\not\\kern-0.3em\\times}"
  },
  	"≮": {
  	math: "\\not<"
  },
  	"≯": {
  	math: "\\not>"
  },
  	"≰": {
  	math: "\\not\\leq"
  },
  	"≱": {
  	math: "\\not\\geq"
  },
  	"≲": {
  	math: "\\lessequivlnt"
  },
  	"≳": {
  	math: "\\greaterequivlnt"
  },
  	"≶": {
  	math: "\\lessgtr"
  },
  	"≷": {
  	math: "\\gtrless"
  },
  	"≸": {
  	math: "\\notlessgreater"
  },
  	"≹": {
  	math: "\\notgreaterless"
  },
  	"≺": {
  	math: "\\prec"
  },
  	"≻": {
  	math: "\\succ"
  },
  	"≼": {
  	math: "\\preccurlyeq"
  },
  	"≽": {
  	math: "\\succcurlyeq"
  },
  	"≾": {
  	math: "\\precapprox"
  },
  	"≾̸": {
  	math: "\\NotPrecedesTilde"
  },
  	"≿": {
  	math: "\\succapprox"
  },
  	"≿̸": {
  	math: "\\NotSucceedsTilde"
  },
  	"⊀": {
  	math: "\\not\\prec"
  },
  	"⊁": {
  	math: "\\not\\succ"
  },
  	"⊂": {
  	math: "\\subset"
  },
  	"⊃": {
  	math: "\\supset"
  },
  	"⊄": {
  	math: "\\not\\subset"
  },
  	"⊅": {
  	math: "\\not\\supset"
  },
  	"⊆": {
  	math: "\\subseteq"
  },
  	"⊇": {
  	math: "\\supseteq"
  },
  	"⊈": {
  	math: "\\not\\subseteq"
  },
  	"⊉": {
  	math: "\\not\\supseteq"
  },
  	"⊊": {
  	math: "\\subsetneq"
  },
  	"⊊︀": {
  	math: "\\varsubsetneqq"
  },
  	"⊋": {
  	math: "\\supsetneq"
  },
  	"⊋︀": {
  	math: "\\varsupsetneq"
  },
  	"⊌": {
  	math: "\\cupleftarrow"
  },
  	"⊍": {
  	math: "\\cupdot"
  },
  	"⊎": {
  	math: "\\uplus"
  },
  	"⊏": {
  	math: "\\sqsubset"
  },
  	"⊏̸": {
  	math: "\\NotSquareSubset"
  },
  	"⊐": {
  	math: "\\sqsupset"
  },
  	"⊐̸": {
  	math: "\\NotSquareSuperset"
  },
  	"⊑": {
  	math: "\\sqsubseteq"
  },
  	"⊒": {
  	math: "\\sqsupseteq"
  },
  	"⊓": {
  	math: "\\sqcap"
  },
  	"⊔": {
  	math: "\\sqcup"
  },
  	"⊕": {
  	math: "\\oplus"
  },
  	"⊖": {
  	math: "\\ominus"
  },
  	"⊗": {
  	math: "\\otimes"
  },
  	"⊘": {
  	math: "\\oslash"
  },
  	"⊙": {
  	math: "\\odot"
  },
  	"⊚": {
  	math: "\\circledcirc"
  },
  	"⊛": {
  	math: "\\circledast"
  },
  	"⊜": {
  	math: "\\circledequal"
  },
  	"⊝": {
  	math: "\\circleddash"
  },
  	"⊞": {
  	math: "\\boxplus"
  },
  	"⊟": {
  	math: "\\boxminus"
  },
  	"⊠": {
  	math: "\\boxtimes"
  },
  	"⊡": {
  	math: "\\boxdot"
  },
  	"⊢": {
  	math: "\\vdash"
  },
  	"⊣": {
  	math: "\\dashv"
  },
  	"⊤": {
  	math: "\\top"
  },
  	"⊥": {
  	math: "\\perp"
  },
  	"⊦": {
  	math: "\\assert"
  },
  	"⊧": {
  	math: "\\truestate"
  },
  	"⊨": {
  	math: "\\forcesextra"
  },
  	"⊩": {
  	math: "\\Vdash"
  },
  	"⊪": {
  	math: "\\Vvdash"
  },
  	"⊫": {
  	math: "\\VDash"
  },
  	"⊬": {
  	math: "\\nvdash"
  },
  	"⊭": {
  	math: "\\nvDash"
  },
  	"⊮": {
  	math: "\\nVdash"
  },
  	"⊯": {
  	math: "\\nVDash"
  },
  	"⊰": {
  	math: "\\prurel"
  },
  	"⊱": {
  	math: "\\scurel"
  },
  	"⊲": {
  	math: "\\vartriangleleft"
  },
  	"⊳": {
  	math: "\\vartriangleright"
  },
  	"⊴": {
  	math: "\\trianglelefteq"
  },
  	"⊵": {
  	math: "\\trianglerighteq"
  },
  	"⊶": {
  	math: "\\original"
  },
  	"⊷": {
  	math: "\\image"
  },
  	"⊸": {
  	math: "\\multimap"
  },
  	"⊹": {
  	math: "\\hermitconjmatrix"
  },
  	"⊺": {
  	math: "\\intercal"
  },
  	"⊻": {
  	math: "\\veebar"
  },
  	"⊼": {
  	math: "\\barwedge"
  },
  	"⊽": {
  	math: "\\barvee"
  },
  	"⊾": {
  	math: "\\rightanglearc"
  },
  	"⊿": {
  	math: "\\varlrtriangle"
  },
  	"⋂": {
  	math: "\\bigcap"
  },
  	"⋃": {
  	math: "\\bigcup"
  },
  	"⋄": {
  	math: "\\diamond"
  },
  	"⋅": {
  	math: "\\cdot"
  },
  	"⋆": {
  	math: "\\star"
  },
  	"⋇": {
  	math: "\\divideontimes"
  },
  	"⋈": {
  	math: "\\bowtie"
  },
  	"⋉": {
  	math: "\\ltimes"
  },
  	"⋊": {
  	math: "\\rtimes"
  },
  	"⋋": {
  	math: "\\leftthreetimes"
  },
  	"⋌": {
  	math: "\\rightthreetimes"
  },
  	"⋍": {
  	math: "\\backsimeq"
  },
  	"⋎": {
  	math: "\\curlyvee"
  },
  	"⋏": {
  	math: "\\curlywedge"
  },
  	"⋐": {
  	math: "\\Subset"
  },
  	"⋑": {
  	math: "\\Supset"
  },
  	"⋒": {
  	math: "\\Cap"
  },
  	"⋓": {
  	math: "\\Cup"
  },
  	"⋔": {
  	math: "\\pitchfork"
  },
  	"⋕": {
  	math: "\\hash"
  },
  	"⋖": {
  	math: "\\lessdot"
  },
  	"⋗": {
  	math: "\\gtrdot"
  },
  	"⋘": {
  	math: "\\verymuchless"
  },
  	"⋙": {
  	math: "\\verymuchgreater"
  },
  	"⋚": {
  	math: "\\lesseqgtr"
  },
  	"⋛": {
  	math: "\\gtreqless"
  },
  	"⋜": {
  	math: "\\eqless"
  },
  	"⋝": {
  	math: "\\eqgtr"
  },
  	"⋞": {
  	math: "\\curlyeqprec"
  },
  	"⋟": {
  	math: "\\curlyeqsucc"
  },
  	"⋠": {
  	math: "\\npreceq"
  },
  	"⋡": {
  	math: "\\nsucceq"
  },
  	"⋢": {
  	math: "\\not\\sqsubseteq"
  },
  	"⋣": {
  	math: "\\not\\sqsupseteq"
  },
  	"⋤": {
  	math: "\\sqsubsetneq"
  },
  	"⋥": {
  	math: "\\Elzsqspne"
  },
  	"⋦": {
  	math: "\\lnsim"
  },
  	"⋧": {
  	math: "\\gnsim"
  },
  	"⋨": {
  	math: "\\precedesnotsimilar"
  },
  	"⋩": {
  	math: "\\succnsim"
  },
  	"⋪": {
  	math: "\\ntriangleleft"
  },
  	"⋫": {
  	math: "\\ntriangleright"
  },
  	"⋬": {
  	math: "\\ntrianglelefteq"
  },
  	"⋭": {
  	math: "\\ntrianglerighteq"
  },
  	"⋮": {
  	math: "\\vdots"
  },
  	"⋯": {
  	math: "\\cdots"
  },
  	"⋰": {
  	math: "\\upslopeellipsis"
  },
  	"⋱": {
  	math: "\\downslopeellipsis"
  },
  	"⋲": {
  	math: "\\disin"
  },
  	"⋳": {
  	math: "\\varisins"
  },
  	"⋴": {
  	math: "\\isins"
  },
  	"⋵": {
  	math: "\\isindot"
  },
  	"⋶": {
  	math: "\\barin"
  },
  	"⋷": {
  	math: "\\isinobar"
  },
  	"⋸": {
  	math: "\\isinvb"
  },
  	"⋹": {
  	math: "\\isinE"
  },
  	"⋺": {
  	math: "\\nisd"
  },
  	"⋻": {
  	math: "\\varnis"
  },
  	"⋼": {
  	math: "\\nis"
  },
  	"⋽": {
  	math: "\\varniobar"
  },
  	"⋾": {
  	math: "\\niobar"
  },
  	"⋿": {
  	math: "\\bagmember"
  },
  	"⌀": {
  	math: "\\diameter"
  },
  	"⌂": {
  	math: "\\house"
  },
  	"⌅": {
  	math: "\\varbarwedge",
  	text: "\\barwedge",
  	commandspacer: true
  },
  	"⌆": {
  	math: "\\perspcorrespond"
  },
  	"⌈": {
  	math: "\\lceil"
  },
  	"⌉": {
  	math: "\\rceil"
  },
  	"⌊": {
  	math: "\\lfloor"
  },
  	"⌋": {
  	math: "\\rfloor"
  },
  	"⌐": {
  	math: "\\invneg"
  },
  	"⌑": {
  	math: "\\wasylozenge"
  },
  	"⌒": {
  	math: "\\profline"
  },
  	"⌓": {
  	math: "\\profsurf"
  },
  	"⌕": {
  	math: "\\recorder"
  },
  	"⌖": {
  	math: "{\\mathchar\"2208}"
  },
  	"⌗": {
  	math: "\\viewdata"
  },
  	"⌙": {
  	math: "\\turnednot"
  },
  	"⌜": {
  	math: "\\ulcorner"
  },
  	"⌝": {
  	math: "\\urcorner"
  },
  	"⌞": {
  	math: "\\llcorner"
  },
  	"⌟": {
  	math: "\\lrcorner"
  },
  	"⌠": {
  	math: "\\inttop"
  },
  	"⌡": {
  	math: "\\intbottom"
  },
  	"⌢": {
  	math: "\\frown"
  },
  	"⌣": {
  	math: "\\smile"
  },
  	"〈": {
  	math: "\\langle"
  },
  	"〉": {
  	math: "\\rangle"
  },
  	"⌬": {
  	math: "\\varhexagonlrbonds"
  },
  	"⌲": {
  	math: "\\conictaper"
  },
  	"⌶": {
  	math: "\\topbot"
  },
  	"⌹": {
  	math: "\\APLinv"
  },
  	"⌿": {
  	math: "\\notslash"
  },
  	"⍀": {
  	math: "\\notbackslash"
  },
  	"⍇": {
  	math: "\\APLleftarrowbox"
  },
  	"⍈": {
  	math: "\\APLrightarrowbox"
  },
  	"⍉": {
  	math: "\\invdiameter"
  },
  	"⍐": {
  	math: "\\APLuparrowbox"
  },
  	"⍓": {
  	math: "\\APLboxupcaret"
  },
  	"⍗": {
  	math: "\\APLdownarrowbox"
  },
  	"⍝": {
  	math: "\\APLcomment"
  },
  	"⍞": {
  	math: "\\APLinput"
  },
  	"⍟": {
  	math: "\\APLlog"
  },
  	"⍰": {
  	math: "\\APLboxquestion"
  },
  	"⍼": {
  	math: "\\rangledownzigzagarrow"
  },
  	"⎔": {
  	math: "\\hexagon"
  },
  	"⎛": {
  	math: "\\lparenuend"
  },
  	"⎜": {
  	math: "\\lparenextender"
  },
  	"⎝": {
  	math: "\\lparenlend"
  },
  	"⎞": {
  	math: "\\rparenuend"
  },
  	"⎟": {
  	math: "\\rparenextender"
  },
  	"⎠": {
  	math: "\\rparenlend"
  },
  	"⎡": {
  	math: "\\lbrackuend"
  },
  	"⎢": {
  	math: "\\lbrackextender"
  },
  	"⎣": {
  	math: "\\Elzdlcorn"
  },
  	"⎤": {
  	math: "\\rbrackuend"
  },
  	"⎥": {
  	math: "\\rbrackextender"
  },
  	"⎦": {
  	math: "\\rbracklend"
  },
  	"⎧": {
  	math: "\\lbraceuend"
  },
  	"⎨": {
  	math: "\\lbracemid"
  },
  	"⎩": {
  	math: "\\lbracelend"
  },
  	"⎪": {
  	math: "\\vbraceextender"
  },
  	"⎫": {
  	math: "\\rbraceuend"
  },
  	"⎬": {
  	math: "\\rbracemid"
  },
  	"⎭": {
  	math: "\\rbracelend"
  },
  	"⎮": {
  	math: "\\intextender"
  },
  	"⎯": {
  	math: "\\harrowextender"
  },
  	"⎰": {
  	math: "\\lmoustache"
  },
  	"⎱": {
  	math: "\\rmoustache"
  },
  	"⎲": {
  	math: "\\sumtop"
  },
  	"⎳": {
  	math: "\\sumbottom"
  },
  	"⎴": {
  	math: "\\overbracket"
  },
  	"⎵": {
  	math: "\\underbracket"
  },
  	"⎶": {
  	math: "\\bbrktbrk"
  },
  	"⎷": {
  	math: "\\sqrtbottom"
  },
  	"⎸": {
  	math: "\\lvboxline"
  },
  	"⎹": {
  	math: "\\rvboxline"
  },
  	"⏎": {
  	math: "\\varcarriagereturn"
  },
  	"⏜": {
  	math: "\\overparen"
  },
  	"⏝": {
  	math: "\\underparen"
  },
  	"⏞": {
  	math: "\\overbrace"
  },
  	"⏟": {
  	math: "\\underbrace"
  },
  	"⏠": {
  	math: "\\obrbrak"
  },
  	"⏡": {
  	math: "\\ubrbrak"
  },
  	"⏢": {
  	math: "\\trapezium"
  },
  	"⏣": {
  	math: "\\benzenr"
  },
  	"⏤": {
  	math: "\\strns"
  },
  	"⏥": {
  	math: "\\fltns"
  },
  	"⏦": {
  	math: "\\accurrent"
  },
  	"⏧": {
  	math: "\\elinters"
  },
  	"␀": {
  	text: "NUL"
  },
  	"␁": {
  	text: "SOH"
  },
  	"␂": {
  	text: "STX"
  },
  	"␃": {
  	text: "ETX"
  },
  	"␄": {
  	text: "EOT"
  },
  	"␅": {
  	text: "ENQ"
  },
  	"␆": {
  	text: "ACK"
  },
  	"␇": {
  	text: "BEL"
  },
  	"␈": {
  	text: "BS"
  },
  	"␉": {
  	text: "HT"
  },
  	"␊": {
  	text: "LF"
  },
  	"␋": {
  	text: "VT"
  },
  	"␌": {
  	text: "FF"
  },
  	"␍": {
  	text: "CR"
  },
  	"␎": {
  	text: "SO"
  },
  	"␏": {
  	text: "SI"
  },
  	"␐": {
  	text: "DLE"
  },
  	"␑": {
  	text: "DC1"
  },
  	"␒": {
  	text: "DC2"
  },
  	"␓": {
  	text: "DC3"
  },
  	"␔": {
  	text: "DC4"
  },
  	"␕": {
  	text: "NAK"
  },
  	"␖": {
  	text: "SYN"
  },
  	"␗": {
  	text: "ETB"
  },
  	"␘": {
  	text: "CAN"
  },
  	"␙": {
  	text: "EM"
  },
  	"␚": {
  	text: "SUB"
  },
  	"␛": {
  	text: "ESC"
  },
  	"␜": {
  	text: "FS"
  },
  	"␝": {
  	text: "GS"
  },
  	"␞": {
  	text: "RS"
  },
  	"␟": {
  	text: "US"
  },
  	"␠": {
  	text: "SP"
  },
  	"␡": {
  	text: "DEL"
  },
  	"␣": {
  	text: "\\textvisiblespace",
  	commandspacer: true
  },
  	"␤": {
  	text: "NL"
  },
  	"␥": {
  	text: "///"
  },
  	"␦": {
  	text: "?"
  },
  	"①": {
  	text: "\\ding{172}"
  },
  	"②": {
  	text: "\\ding{173}"
  },
  	"③": {
  	text: "\\ding{174}"
  },
  	"④": {
  	text: "\\ding{175}"
  },
  	"⑤": {
  	text: "\\ding{176}"
  },
  	"⑥": {
  	text: "\\ding{177}"
  },
  	"⑦": {
  	text: "\\ding{178}"
  },
  	"⑧": {
  	text: "\\ding{179}"
  },
  	"⑨": {
  	text: "\\ding{180}"
  },
  	"⑩": {
  	text: "\\ding{181}"
  },
  	"⑪": {
  	text: "(11)"
  },
  	"⑫": {
  	text: "(12)"
  },
  	"⑬": {
  	text: "(13)"
  },
  	"⑭": {
  	text: "(14)"
  },
  	"⑮": {
  	text: "(15)"
  },
  	"⑯": {
  	text: "(16)"
  },
  	"⑰": {
  	text: "(17)"
  },
  	"⑱": {
  	text: "(18)"
  },
  	"⑲": {
  	text: "(19)"
  },
  	"⑳": {
  	text: "(20)"
  },
  	"⑴": {
  	text: "(1)"
  },
  	"⑵": {
  	text: "(2)"
  },
  	"⑶": {
  	text: "(3)"
  },
  	"⑷": {
  	text: "(4)"
  },
  	"⑸": {
  	text: "(5)"
  },
  	"⑹": {
  	text: "(6)"
  },
  	"⑺": {
  	text: "(7)"
  },
  	"⑻": {
  	text: "(8)"
  },
  	"⑼": {
  	text: "(9)"
  },
  	"⑽": {
  	text: "(10)"
  },
  	"⑾": {
  	text: "(11)"
  },
  	"⑿": {
  	text: "(12)"
  },
  	"⒀": {
  	text: "(13)"
  },
  	"⒁": {
  	text: "(14)"
  },
  	"⒂": {
  	text: "(15)"
  },
  	"⒃": {
  	text: "(16)"
  },
  	"⒄": {
  	text: "(17)"
  },
  	"⒅": {
  	text: "(18)"
  },
  	"⒆": {
  	text: "(19)"
  },
  	"⒇": {
  	text: "(20)"
  },
  	"⒈": {
  	text: "1."
  },
  	"⒉": {
  	text: "2."
  },
  	"⒊": {
  	text: "3."
  },
  	"⒋": {
  	text: "4."
  },
  	"⒌": {
  	text: "5."
  },
  	"⒍": {
  	text: "6."
  },
  	"⒎": {
  	text: "7."
  },
  	"⒏": {
  	text: "8."
  },
  	"⒐": {
  	text: "9."
  },
  	"⒑": {
  	text: "10."
  },
  	"⒒": {
  	text: "11."
  },
  	"⒓": {
  	text: "12."
  },
  	"⒔": {
  	text: "13."
  },
  	"⒕": {
  	text: "14."
  },
  	"⒖": {
  	text: "15."
  },
  	"⒗": {
  	text: "16."
  },
  	"⒘": {
  	text: "17."
  },
  	"⒙": {
  	text: "18."
  },
  	"⒚": {
  	text: "19."
  },
  	"⒛": {
  	text: "20."
  },
  	"⒜": {
  	text: "(a)"
  },
  	"⒝": {
  	text: "(b)"
  },
  	"⒞": {
  	text: "(c)"
  },
  	"⒟": {
  	text: "(d)"
  },
  	"⒠": {
  	text: "(e)"
  },
  	"⒡": {
  	text: "(f)"
  },
  	"⒢": {
  	text: "(g)"
  },
  	"⒣": {
  	text: "(h)"
  },
  	"⒤": {
  	text: "(i)"
  },
  	"⒥": {
  	text: "(j)"
  },
  	"⒦": {
  	text: "(k)"
  },
  	"⒧": {
  	text: "(l)"
  },
  	"⒨": {
  	text: "(m)"
  },
  	"⒩": {
  	text: "(n)"
  },
  	"⒪": {
  	text: "(o)"
  },
  	"⒫": {
  	text: "(p)"
  },
  	"⒬": {
  	text: "(q)"
  },
  	"⒭": {
  	text: "(r)"
  },
  	"⒮": {
  	text: "(s)"
  },
  	"⒯": {
  	text: "(t)"
  },
  	"⒰": {
  	text: "(u)"
  },
  	"⒱": {
  	text: "(v)"
  },
  	"⒲": {
  	text: "(w)"
  },
  	"⒳": {
  	text: "(x)"
  },
  	"⒴": {
  	text: "(y)"
  },
  	"⒵": {
  	text: "(z)"
  },
  	"Ⓐ": {
  	text: "(A)"
  },
  	"Ⓑ": {
  	text: "(B)"
  },
  	"Ⓒ": {
  	text: "(C)"
  },
  	"Ⓓ": {
  	text: "(D)"
  },
  	"Ⓔ": {
  	text: "(E)"
  },
  	"Ⓕ": {
  	text: "(F)"
  },
  	"Ⓖ": {
  	text: "(G)"
  },
  	"Ⓗ": {
  	text: "(H)"
  },
  	"Ⓘ": {
  	text: "(I)"
  },
  	"Ⓙ": {
  	text: "(J)"
  },
  	"Ⓚ": {
  	text: "(K)"
  },
  	"Ⓛ": {
  	text: "(L)"
  },
  	"Ⓜ": {
  	text: "(M)"
  },
  	"Ⓝ": {
  	text: "(N)"
  },
  	"Ⓞ": {
  	text: "(O)"
  },
  	"Ⓟ": {
  	text: "(P)"
  },
  	"Ⓠ": {
  	text: "(Q)"
  },
  	"Ⓡ": {
  	text: "(R)"
  },
  	"Ⓢ": {
  	math: "\\circledS"
  },
  	"Ⓣ": {
  	text: "(T)"
  },
  	"Ⓤ": {
  	text: "(U)"
  },
  	"Ⓥ": {
  	text: "(V)"
  },
  	"Ⓦ": {
  	text: "(W)"
  },
  	"Ⓧ": {
  	text: "(X)"
  },
  	"Ⓨ": {
  	text: "(Y)"
  },
  	"Ⓩ": {
  	text: "(Z)"
  },
  	"ⓐ": {
  	text: "(a)"
  },
  	"ⓑ": {
  	text: "(b)"
  },
  	"ⓒ": {
  	text: "(c)"
  },
  	"ⓓ": {
  	text: "(d)"
  },
  	"ⓔ": {
  	text: "(e)"
  },
  	"ⓕ": {
  	text: "(f)"
  },
  	"ⓖ": {
  	text: "(g)"
  },
  	"ⓗ": {
  	text: "(h)"
  },
  	"ⓘ": {
  	text: "(i)"
  },
  	"ⓙ": {
  	text: "(j)"
  },
  	"ⓚ": {
  	text: "(k)"
  },
  	"ⓛ": {
  	text: "(l)"
  },
  	"ⓜ": {
  	text: "(m)"
  },
  	"ⓝ": {
  	text: "(n)"
  },
  	"ⓞ": {
  	text: "(o)"
  },
  	"ⓟ": {
  	text: "(p)"
  },
  	"ⓠ": {
  	text: "(q)"
  },
  	"ⓡ": {
  	text: "(r)"
  },
  	"ⓢ": {
  	text: "(s)"
  },
  	"ⓣ": {
  	text: "(t)"
  },
  	"ⓤ": {
  	text: "(u)"
  },
  	"ⓥ": {
  	text: "(v)"
  },
  	"ⓦ": {
  	text: "(w)"
  },
  	"ⓧ": {
  	text: "(x)"
  },
  	"ⓨ": {
  	text: "(y)"
  },
  	"ⓩ": {
  	text: "(z)"
  },
  	"⓪": {
  	text: "(0)"
  },
  	"─": {
  	text: "-"
  },
  	"━": {
  	text: "="
  },
  	"│": {
  	text: "|"
  },
  	"┃": {
  	text: "|"
  },
  	"┄": {
  	text: "-"
  },
  	"┅": {
  	text: "="
  },
  	"┆": {
  	math: "\\Elzdshfnc"
  },
  	"┇": {
  	text: "|"
  },
  	"┈": {
  	text: "-"
  },
  	"┉": {
  	text: "="
  },
  	"┊": {
  	text: "|"
  },
  	"┋": {
  	text: "|"
  },
  	"┌": {
  	text: "+"
  },
  	"┍": {
  	text: "+"
  },
  	"┎": {
  	text: "+"
  },
  	"┏": {
  	text: "+"
  },
  	"┐": {
  	text: "+"
  },
  	"┑": {
  	text: "+"
  },
  	"┒": {
  	text: "+"
  },
  	"┓": {
  	text: "+"
  },
  	"└": {
  	text: "+"
  },
  	"┕": {
  	text: "+"
  },
  	"┖": {
  	text: "+"
  },
  	"┗": {
  	text: "+"
  },
  	"┘": {
  	text: "+"
  },
  	"┙": {
  	math: "\\Elzsqfnw"
  },
  	"┚": {
  	text: "+"
  },
  	"┛": {
  	text: "+"
  },
  	"├": {
  	text: "+"
  },
  	"┝": {
  	text: "+"
  },
  	"┞": {
  	text: "+"
  },
  	"┟": {
  	text: "+"
  },
  	"┠": {
  	text: "+"
  },
  	"┡": {
  	text: "+"
  },
  	"┢": {
  	text: "+"
  },
  	"┣": {
  	text: "+"
  },
  	"┤": {
  	text: "+"
  },
  	"┥": {
  	text: "+"
  },
  	"┦": {
  	text: "+"
  },
  	"┧": {
  	text: "+"
  },
  	"┨": {
  	text: "+"
  },
  	"┩": {
  	text: "+"
  },
  	"┪": {
  	text: "+"
  },
  	"┫": {
  	text: "+"
  },
  	"┬": {
  	text: "+"
  },
  	"┭": {
  	text: "+"
  },
  	"┮": {
  	text: "+"
  },
  	"┯": {
  	text: "+"
  },
  	"┰": {
  	text: "+"
  },
  	"┱": {
  	text: "+"
  },
  	"┲": {
  	text: "+"
  },
  	"┳": {
  	text: "+"
  },
  	"┴": {
  	text: "+"
  },
  	"┵": {
  	text: "+"
  },
  	"┶": {
  	text: "+"
  },
  	"┷": {
  	text: "+"
  },
  	"┸": {
  	text: "+"
  },
  	"┹": {
  	text: "+"
  },
  	"┺": {
  	text: "+"
  },
  	"┻": {
  	text: "+"
  },
  	"┼": {
  	text: "+"
  },
  	"┽": {
  	text: "+"
  },
  	"┾": {
  	text: "+"
  },
  	"┿": {
  	text: "+"
  },
  	"╀": {
  	text: "+"
  },
  	"╁": {
  	text: "+"
  },
  	"╂": {
  	text: "+"
  },
  	"╃": {
  	text: "+"
  },
  	"╄": {
  	text: "+"
  },
  	"╅": {
  	text: "+"
  },
  	"╆": {
  	text: "+"
  },
  	"╇": {
  	text: "+"
  },
  	"╈": {
  	text: "+"
  },
  	"╉": {
  	text: "+"
  },
  	"╊": {
  	text: "+"
  },
  	"╋": {
  	text: "+"
  },
  	"╌": {
  	text: "-"
  },
  	"╍": {
  	text: "="
  },
  	"╎": {
  	text: "|"
  },
  	"╏": {
  	text: "|"
  },
  	"═": {
  	text: "="
  },
  	"║": {
  	text: "|"
  },
  	"╒": {
  	text: "+"
  },
  	"╓": {
  	text: "+"
  },
  	"╔": {
  	text: "+"
  },
  	"╕": {
  	text: "+"
  },
  	"╖": {
  	text: "+"
  },
  	"╗": {
  	text: "+"
  },
  	"╘": {
  	text: "+"
  },
  	"╙": {
  	text: "+"
  },
  	"╚": {
  	text: "+"
  },
  	"╛": {
  	text: "+"
  },
  	"╜": {
  	text: "+"
  },
  	"╝": {
  	text: "+"
  },
  	"╞": {
  	text: "+"
  },
  	"╟": {
  	text: "+"
  },
  	"╠": {
  	text: "+"
  },
  	"╡": {
  	text: "+"
  },
  	"╢": {
  	text: "+"
  },
  	"╣": {
  	text: "+"
  },
  	"╤": {
  	text: "+"
  },
  	"╥": {
  	text: "+"
  },
  	"╦": {
  	text: "+"
  },
  	"╧": {
  	text: "+"
  },
  	"╨": {
  	text: "+"
  },
  	"╩": {
  	text: "+"
  },
  	"╪": {
  	text: "+"
  },
  	"╫": {
  	text: "+"
  },
  	"╬": {
  	text: "+"
  },
  	"╭": {
  	text: "+"
  },
  	"╮": {
  	text: "+"
  },
  	"╯": {
  	text: "+"
  },
  	"╰": {
  	text: "+"
  },
  	"╱": {
  	math: "\\diagup"
  },
  	"╲": {
  	text: "\\"
  },
  	"╳": {
  	text: "X"
  },
  	"╼": {
  	text: "-"
  },
  	"╽": {
  	text: "|"
  },
  	"╾": {
  	text: "-"
  },
  	"╿": {
  	text: "|"
  },
  	"▀": {
  	math: "\\blockuphalf"
  },
  	"▄": {
  	math: "\\blocklowhalf"
  },
  	"█": {
  	math: "\\blockfull"
  },
  	"▌": {
  	math: "\\blocklefthalf"
  },
  	"▐": {
  	math: "\\blockrighthalf"
  },
  	"░": {
  	math: "\\blockqtrshaded"
  },
  	"▒": {
  	math: "\\blockhalfshaded"
  },
  	"▓": {
  	math: "\\blockthreeqtrshaded"
  },
  	"■": {
  	math: "\\mdlgblksquare",
  	text: "\\ding{110}"
  },
  	"□": {
  	math: "\\square"
  },
  	"▢": {
  	math: "\\squoval"
  },
  	"▣": {
  	math: "\\blackinwhitesquare"
  },
  	"▤": {
  	math: "\\squarehfill"
  },
  	"▥": {
  	math: "\\squarevfill"
  },
  	"▦": {
  	math: "\\squarehvfill"
  },
  	"▧": {
  	math: "\\squarenwsefill"
  },
  	"▨": {
  	math: "\\squareneswfill"
  },
  	"▩": {
  	math: "\\squarecrossfill"
  },
  	"▪": {
  	math: "\\blacksquare"
  },
  	"▫": {
  	math: "\\smwhtsquare"
  },
  	"▬": {
  	math: "\\hrectangleblack"
  },
  	"▭": {
  	math: "\\fbox{~~}"
  },
  	"▮": {
  	math: "\\vrectangleblack"
  },
  	"▯": {
  	math: "\\Elzvrecto"
  },
  	"▰": {
  	math: "\\parallelogramblack"
  },
  	"▲": {
  	math: "\\bigblacktriangleup",
  	text: "\\ding{115}"
  },
  	"△": {
  	math: "\\bigtriangleup"
  },
  	"▴": {
  	math: "\\blacktriangle"
  },
  	"▵": {
  	math: "\\vartriangle"
  },
  	"▶": {
  	math: "\\RHD"
  },
  	"▷": {
  	math: "\\rhd"
  },
  	"▸": {
  	math: "\\blacktriangleright"
  },
  	"▹": {
  	math: "\\triangleright"
  },
  	"►": {
  	math: "\\blackpointerright"
  },
  	"▻": {
  	math: "\\whitepointerright"
  },
  	"▼": {
  	math: "\\bigblacktriangledown",
  	text: "\\ding{116}"
  },
  	"▽": {
  	math: "\\bigtriangledown"
  },
  	"▾": {
  	math: "\\blacktriangledown"
  },
  	"▿": {
  	math: "\\triangledown"
  },
  	"◀": {
  	math: "\\LHD"
  },
  	"◁": {
  	math: "\\lhd"
  },
  	"◂": {
  	math: "\\blacktriangleleft"
  },
  	"◃": {
  	math: "\\triangleleft"
  },
  	"◄": {
  	math: "\\blackpointerleft"
  },
  	"◅": {
  	math: "\\whitepointerleft"
  },
  	"◆": {
  	math: "\\Diamondblack",
  	text: "\\ding{117}"
  },
  	"◇": {
  	math: "\\Diamond"
  },
  	"◈": {
  	math: "\\blackinwhitediamond"
  },
  	"◉": {
  	math: "\\fisheye"
  },
  	"◊": {
  	math: "\\lozenge"
  },
  	"○": {
  	math: "\\bigcirc"
  },
  	"◌": {
  	math: "\\dottedcircle"
  },
  	"◍": {
  	math: "\\circlevertfill"
  },
  	"◎": {
  	math: "\\bullseye"
  },
  	"●": {
  	math: "\\CIRCLE",
  	text: "\\ding{108}"
  },
  	"◐": {
  	math: "\\Elzcirfl"
  },
  	"◑": {
  	math: "\\Elzcirfr"
  },
  	"◒": {
  	math: "\\Elzcirfb"
  },
  	"◓": {
  	math: "\\circletophalfblack"
  },
  	"◔": {
  	math: "\\circleurquadblack"
  },
  	"◕": {
  	math: "\\blackcircleulquadwhite"
  },
  	"◖": {
  	math: "\\LEFTCIRCLE"
  },
  	"◗": {
  	math: "\\RIGHTCIRCLE",
  	text: "\\ding{119}"
  },
  	"◘": {
  	math: "\\Elzrvbull"
  },
  	"◙": {
  	math: "\\inversewhitecircle"
  },
  	"◚": {
  	math: "\\invwhiteupperhalfcircle"
  },
  	"◛": {
  	math: "\\invwhitelowerhalfcircle"
  },
  	"◜": {
  	math: "\\ularc"
  },
  	"◝": {
  	math: "\\urarc"
  },
  	"◞": {
  	math: "\\lrarc"
  },
  	"◟": {
  	math: "\\llarc"
  },
  	"◠": {
  	math: "\\topsemicircle"
  },
  	"◡": {
  	math: "\\botsemicircle"
  },
  	"◢": {
  	math: "\\lrblacktriangle"
  },
  	"◣": {
  	math: "\\llblacktriangle"
  },
  	"◤": {
  	math: "\\ulblacktriangle"
  },
  	"◥": {
  	math: "\\urblacktriangle"
  },
  	"◦": {
  	math: "\\smwhtcircle"
  },
  	"◧": {
  	math: "\\Elzsqfl"
  },
  	"◨": {
  	math: "\\Elzsqfr"
  },
  	"◩": {
  	math: "\\squareulblack"
  },
  	"◪": {
  	math: "\\Elzsqfse"
  },
  	"◫": {
  	math: "\\boxbar"
  },
  	"◬": {
  	math: "\\trianglecdot"
  },
  	"◭": {
  	math: "\\triangleleftblack"
  },
  	"◮": {
  	math: "\\trianglerightblack"
  },
  	"◯": {
  	math: "\\bigcirc"
  },
  	"◰": {
  	math: "\\squareulquad"
  },
  	"◱": {
  	math: "\\squarellquad"
  },
  	"◲": {
  	math: "\\squarelrquad"
  },
  	"◳": {
  	math: "\\squareurquad"
  },
  	"◴": {
  	math: "\\circleulquad"
  },
  	"◵": {
  	math: "\\circlellquad"
  },
  	"◶": {
  	math: "\\circlelrquad"
  },
  	"◷": {
  	math: "\\circleurquad"
  },
  	"◸": {
  	math: "\\ultriangle"
  },
  	"◹": {
  	math: "\\urtriangle"
  },
  	"◺": {
  	math: "\\lltriangle"
  },
  	"◻": {
  	math: "\\square"
  },
  	"◼": {
  	math: "\\blacksquare"
  },
  	"◽": {
  	math: "\\mdsmwhtsquare"
  },
  	"◾": {
  	math: "\\mdsmblksquare"
  },
  	"◿": {
  	math: "\\lrtriangle"
  },
  	"★": {
  	math: "\\bigstar",
  	text: "\\ding{72}"
  },
  	"☆": {
  	math: "\\bigwhitestar",
  	text: "\\ding{73}"
  },
  	"☉": {
  	math: "\\Sun"
  },
  	"☎": {
  	text: "\\ding{37}"
  },
  	"☐": {
  	math: "\\Square"
  },
  	"☑": {
  	math: "\\CheckedBox"
  },
  	"☒": {
  	math: "\\XBox"
  },
  	"☓": {
  	text: "X"
  },
  	"☕": {
  	math: "\\steaming"
  },
  	"☛": {
  	text: "\\ding{42}"
  },
  	"☞": {
  	math: "\\pointright",
  	text: "\\ding{43}"
  },
  	"☠": {
  	math: "\\skull"
  },
  	"☡": {
  	math: "\\danger"
  },
  	"☢": {
  	math: "\\radiation"
  },
  	"☣": {
  	math: "\\biohazard"
  },
  	"☯": {
  	math: "\\yinyang"
  },
  	"☹": {
  	math: "\\frownie"
  },
  	"☺": {
  	math: "\\smiley"
  },
  	"☻": {
  	math: "\\blacksmiley"
  },
  	"☼": {
  	math: "\\sun"
  },
  	"☽": {
  	text: "\\rightmoon",
  	commandspacer: true,
  	textpackages: [
  		"wasysym"
  	]
  },
  	"☾": {
  	text: "\\leftmoon",
  	commandspacer: true,
  	textpackages: [
  		"wasysym"
  	]
  },
  	"☿": {
  	math: "\\mercury",
  	text: "\\mercury",
  	commandspacer: true
  },
  	"♀": {
  	math: "\\female",
  	text: "\\venus",
  	commandspacer: true
  },
  	"♁": {
  	math: "\\earth"
  },
  	"♂": {
  	math: "\\male",
  	text: "\\male",
  	commandspacer: true
  },
  	"♃": {
  	math: "\\jupiter",
  	text: "\\jupiter",
  	commandspacer: true
  },
  	"♄": {
  	math: "\\saturn",
  	text: "\\saturn",
  	commandspacer: true
  },
  	"♅": {
  	math: "\\uranus",
  	text: "\\uranus",
  	commandspacer: true
  },
  	"♆": {
  	math: "\\neptune",
  	text: "\\neptune",
  	commandspacer: true
  },
  	"♇": {
  	math: "\\pluto",
  	text: "\\pluto",
  	commandspacer: true
  },
  	"♈": {
  	math: "\\aries",
  	text: "\\aries",
  	commandspacer: true
  },
  	"♉": {
  	math: "\\taurus",
  	text: "\\taurus",
  	commandspacer: true
  },
  	"♊": {
  	math: "\\gemini",
  	text: "\\gemini",
  	commandspacer: true
  },
  	"♋": {
  	math: "\\cancer",
  	text: "\\cancer",
  	commandspacer: true
  },
  	"♌": {
  	math: "\\leo",
  	text: "\\leo",
  	commandspacer: true
  },
  	"♍": {
  	math: "\\virgo",
  	text: "\\virgo",
  	commandspacer: true
  },
  	"♎": {
  	math: "\\libra",
  	text: "\\libra",
  	commandspacer: true
  },
  	"♏": {
  	math: "\\scorpio",
  	text: "\\scorpio",
  	commandspacer: true
  },
  	"♐": {
  	math: "\\sagittarius",
  	text: "\\sagittarius",
  	commandspacer: true
  },
  	"♑": {
  	math: "\\capricornus",
  	text: "\\capricornus",
  	commandspacer: true
  },
  	"♒": {
  	math: "\\aquarius",
  	text: "\\aquarius",
  	commandspacer: true
  },
  	"♓": {
  	math: "\\pisces",
  	text: "\\pisces",
  	commandspacer: true
  },
  	"♠": {
  	math: "\\spadesuit",
  	text: "\\ding{171}"
  },
  	"♡": {
  	math: "\\heartsuit"
  },
  	"♢": {
  	math: "\\diamond"
  },
  	"♣": {
  	math: "\\clubsuit",
  	text: "\\ding{168}"
  },
  	"♤": {
  	math: "\\varspadesuit"
  },
  	"♥": {
  	math: "\\varheartsuit",
  	text: "\\ding{170}"
  },
  	"♦": {
  	math: "\\vardiamondsuit",
  	text: "\\ding{169}"
  },
  	"♧": {
  	math: "\\varclubsuit"
  },
  	"♩": {
  	math: "\\quarternote",
  	text: "\\quarternote",
  	commandspacer: true
  },
  	"♪": {
  	math: "\\eighthnote",
  	text: "\\eighthnote",
  	commandspacer: true
  },
  	"♫": {
  	math: "\\twonotes"
  },
  	"♬": {
  	math: "\\sixteenthnote"
  },
  	"♭": {
  	math: "\\flat"
  },
  	"♮": {
  	math: "\\natural"
  },
  	"♯": {
  	math: "\\sharp"
  },
  	"♻": {
  	math: "\\recycle"
  },
  	"♾": {
  	math: "\\acidfree"
  },
  	"⚀": {
  	math: "\\dicei"
  },
  	"⚁": {
  	math: "\\diceii"
  },
  	"⚂": {
  	math: "\\diceiii"
  },
  	"⚃": {
  	math: "\\diceiv"
  },
  	"⚄": {
  	math: "\\dicev"
  },
  	"⚅": {
  	math: "\\dicevi"
  },
  	"⚆": {
  	math: "\\circledrightdot"
  },
  	"⚇": {
  	math: "\\circledtwodots"
  },
  	"⚈": {
  	math: "\\blackcircledrightdot"
  },
  	"⚉": {
  	math: "\\blackcircledtwodots"
  },
  	"⚓": {
  	math: "\\anchor"
  },
  	"⚔": {
  	math: "\\swords"
  },
  	"⚠": {
  	math: "\\warning"
  },
  	"⚥": {
  	math: "\\Hermaphrodite"
  },
  	"⚪": {
  	math: "\\medcirc"
  },
  	"⚫": {
  	math: "\\medbullet"
  },
  	"⚬": {
  	math: "\\mdsmwhtcircle"
  },
  	"⚲": {
  	math: "\\neuter"
  },
  	"✁": {
  	text: "\\ding{33}"
  },
  	"✂": {
  	text: "\\ding{34}"
  },
  	"✃": {
  	text: "\\ding{35}"
  },
  	"✄": {
  	text: "\\ding{36}"
  },
  	"✆": {
  	text: "\\ding{38}"
  },
  	"✇": {
  	text: "\\ding{39}"
  },
  	"✈": {
  	text: "\\ding{40}"
  },
  	"✉": {
  	text: "\\ding{41}"
  },
  	"✌": {
  	text: "\\ding{44}"
  },
  	"✍": {
  	text: "\\ding{45}"
  },
  	"✎": {
  	math: "\\pencil",
  	text: "\\ding{46}"
  },
  	"✏": {
  	text: "\\ding{47}"
  },
  	"✐": {
  	text: "\\ding{48}"
  },
  	"✑": {
  	text: "\\ding{49}"
  },
  	"✒": {
  	text: "\\ding{50}"
  },
  	"✓": {
  	math: "\\checkmark",
  	text: "\\ding{51}"
  },
  	"✔": {
  	text: "\\ding{52}"
  },
  	"✕": {
  	text: "\\ding{53}"
  },
  	"✖": {
  	text: "\\ding{54}"
  },
  	"✗": {
  	math: "\\ballotx",
  	text: "\\ding{55}"
  },
  	"✘": {
  	text: "\\ding{56}"
  },
  	"✙": {
  	text: "\\ding{57}"
  },
  	"✚": {
  	text: "\\ding{58}"
  },
  	"✛": {
  	text: "\\ding{59}"
  },
  	"✜": {
  	text: "\\ding{60}"
  },
  	"✝": {
  	text: "\\ding{61}"
  },
  	"✞": {
  	text: "\\ding{62}"
  },
  	"✟": {
  	text: "\\ding{63}"
  },
  	"✠": {
  	math: "\\maltese",
  	text: "\\ding{64}"
  },
  	"✡": {
  	text: "\\ding{65}"
  },
  	"✢": {
  	text: "\\ding{66}"
  },
  	"✣": {
  	text: "\\ding{67}"
  },
  	"✤": {
  	text: "\\ding{68}"
  },
  	"✥": {
  	text: "\\ding{69}"
  },
  	"✦": {
  	text: "\\ding{70}"
  },
  	"✧": {
  	text: "\\ding{71}"
  },
  	"✩": {
  	text: "\\ding{73}"
  },
  	"✪": {
  	math: "\\circledstar",
  	text: "\\ding{74}"
  },
  	"✫": {
  	text: "\\ding{75}"
  },
  	"✬": {
  	text: "\\ding{76}"
  },
  	"✭": {
  	text: "\\ding{77}"
  },
  	"✮": {
  	text: "\\ding{78}"
  },
  	"✯": {
  	text: "\\ding{79}"
  },
  	"✰": {
  	text: "\\ding{80}"
  },
  	"✱": {
  	text: "\\ding{81}"
  },
  	"✲": {
  	text: "\\ding{82}"
  },
  	"✳": {
  	text: "\\ding{83}"
  },
  	"✴": {
  	text: "\\ding{84}"
  },
  	"✵": {
  	text: "\\ding{85}"
  },
  	"✶": {
  	math: "\\varstar",
  	text: "\\ding{86}"
  },
  	"✷": {
  	text: "\\ding{87}"
  },
  	"✸": {
  	text: "\\ding{88}"
  },
  	"✹": {
  	text: "\\ding{89}"
  },
  	"✺": {
  	text: "\\ding{90}"
  },
  	"✻": {
  	text: "\\ding{91}"
  },
  	"✼": {
  	text: "\\ding{92}"
  },
  	"✽": {
  	math: "\\dingasterisk",
  	text: "\\ding{93}"
  },
  	"✾": {
  	text: "\\ding{94}"
  },
  	"✿": {
  	text: "\\ding{95}"
  },
  	"❀": {
  	text: "\\ding{96}"
  },
  	"❁": {
  	text: "\\ding{97}"
  },
  	"❂": {
  	text: "\\ding{98}"
  },
  	"❃": {
  	text: "\\ding{99}"
  },
  	"❄": {
  	text: "\\ding{100}"
  },
  	"❅": {
  	text: "\\ding{101}"
  },
  	"❆": {
  	text: "\\ding{102}"
  },
  	"❇": {
  	text: "\\ding{103}"
  },
  	"❈": {
  	text: "\\ding{104}"
  },
  	"❉": {
  	text: "\\ding{105}"
  },
  	"❊": {
  	text: "\\ding{106}"
  },
  	"❋": {
  	text: "\\ding{107}"
  },
  	"❍": {
  	text: "\\ding{109}"
  },
  	"❏": {
  	text: "\\ding{111}"
  },
  	"❐": {
  	text: "\\ding{112}"
  },
  	"❑": {
  	text: "\\ding{113}"
  },
  	"❒": {
  	text: "\\ding{114}"
  },
  	"❖": {
  	text: "\\ding{118}"
  },
  	"❘": {
  	text: "\\ding{120}"
  },
  	"❙": {
  	text: "\\ding{121}"
  },
  	"❚": {
  	text: "\\ding{122}"
  },
  	"❛": {
  	text: "\\ding{123}"
  },
  	"❜": {
  	text: "\\ding{124}"
  },
  	"❝": {
  	text: "\\ding{125}"
  },
  	"❞": {
  	text: "\\ding{126}"
  },
  	"❡": {
  	text: "\\ding{161}"
  },
  	"❢": {
  	text: "\\ding{162}"
  },
  	"❣": {
  	text: "\\ding{163}"
  },
  	"❤": {
  	text: "\\ding{164}"
  },
  	"❥": {
  	text: "\\ding{165}"
  },
  	"❦": {
  	text: "\\ding{166}"
  },
  	"❧": {
  	text: "\\ding{167}"
  },
  	"❲": {
  	math: "\\lbrbrak"
  },
  	"❳": {
  	math: "\\rbrbrak"
  },
  	"❶": {
  	text: "\\ding{182}"
  },
  	"❷": {
  	text: "\\ding{183}"
  },
  	"❸": {
  	text: "\\ding{184}"
  },
  	"❹": {
  	text: "\\ding{185}"
  },
  	"❺": {
  	text: "\\ding{186}"
  },
  	"❻": {
  	text: "\\ding{187}"
  },
  	"❼": {
  	text: "\\ding{188}"
  },
  	"❽": {
  	text: "\\ding{189}"
  },
  	"❾": {
  	text: "\\ding{190}"
  },
  	"❿": {
  	text: "\\ding{191}"
  },
  	"➀": {
  	text: "\\ding{192}"
  },
  	"➁": {
  	text: "\\ding{193}"
  },
  	"➂": {
  	text: "\\ding{194}"
  },
  	"➃": {
  	text: "\\ding{195}"
  },
  	"➄": {
  	text: "\\ding{196}"
  },
  	"➅": {
  	text: "\\ding{197}"
  },
  	"➆": {
  	text: "\\ding{198}"
  },
  	"➇": {
  	text: "\\ding{199}"
  },
  	"➈": {
  	text: "\\ding{200}"
  },
  	"➉": {
  	text: "\\ding{201}"
  },
  	"➊": {
  	text: "\\ding{202}"
  },
  	"➋": {
  	text: "\\ding{203}"
  },
  	"➌": {
  	text: "\\ding{204}"
  },
  	"➍": {
  	text: "\\ding{205}"
  },
  	"➎": {
  	text: "\\ding{206}"
  },
  	"➏": {
  	text: "\\ding{207}"
  },
  	"➐": {
  	text: "\\ding{208}"
  },
  	"➑": {
  	text: "\\ding{209}"
  },
  	"➒": {
  	text: "\\ding{210}"
  },
  	"➓": {
  	text: "\\ding{211}"
  },
  	"➔": {
  	text: "\\ding{212}"
  },
  	"➘": {
  	text: "\\ding{216}"
  },
  	"➙": {
  	text: "\\ding{217}"
  },
  	"➚": {
  	text: "\\ding{218}"
  },
  	"➛": {
  	math: "\\draftingarrow",
  	text: "\\ding{219}"
  },
  	"➜": {
  	text: "\\ding{220}"
  },
  	"➝": {
  	text: "\\ding{221}"
  },
  	"➞": {
  	text: "\\ding{222}"
  },
  	"➟": {
  	text: "\\ding{223}"
  },
  	"➠": {
  	text: "\\ding{224}"
  },
  	"➡": {
  	text: "\\ding{225}"
  },
  	"➢": {
  	math: "\\arrowbullet",
  	text: "\\ding{226}"
  },
  	"➣": {
  	text: "\\ding{227}"
  },
  	"➤": {
  	text: "\\ding{228}"
  },
  	"➥": {
  	text: "\\ding{229}"
  },
  	"➦": {
  	text: "\\ding{230}"
  },
  	"➧": {
  	text: "\\ding{231}"
  },
  	"➨": {
  	text: "\\ding{232}"
  },
  	"➩": {
  	text: "\\ding{233}"
  },
  	"➪": {
  	text: "\\ding{234}"
  },
  	"➫": {
  	text: "\\ding{235}"
  },
  	"➬": {
  	text: "\\ding{236}"
  },
  	"➭": {
  	text: "\\ding{237}"
  },
  	"➮": {
  	text: "\\ding{238}"
  },
  	"➯": {
  	text: "\\ding{239}"
  },
  	"➱": {
  	text: "\\ding{241}"
  },
  	"➲": {
  	text: "\\ding{242}"
  },
  	"➳": {
  	text: "\\ding{243}"
  },
  	"➴": {
  	text: "\\ding{244}"
  },
  	"➵": {
  	text: "\\ding{245}"
  },
  	"➶": {
  	text: "\\ding{246}"
  },
  	"➷": {
  	text: "\\ding{247}"
  },
  	"➸": {
  	text: "\\ding{248}"
  },
  	"➹": {
  	text: "\\ding{249}"
  },
  	"➺": {
  	text: "\\ding{250}"
  },
  	"➻": {
  	text: "\\ding{251}"
  },
  	"➼": {
  	text: "\\ding{252}"
  },
  	"➽": {
  	text: "\\ding{253}"
  },
  	"➾": {
  	text: "\\ding{254}"
  },
  	"⟀": {
  	math: "\\threedangle"
  },
  	"⟁": {
  	math: "\\whiteinwhitetriangle"
  },
  	"⟂": {
  	math: "\\perp"
  },
  	"⟃": {
  	math: "\\subsetcirc"
  },
  	"⟄": {
  	math: "\\supsetcirc"
  },
  	"⟅": {
  	math: "\\Lbag"
  },
  	"⟆": {
  	math: "\\Rbag"
  },
  	"⟇": {
  	math: "\\veedot"
  },
  	"⟈": {
  	math: "\\bsolhsub"
  },
  	"⟉": {
  	math: "\\suphsol"
  },
  	"⟌": {
  	math: "\\longdivision"
  },
  	"⟐": {
  	math: "\\Diamonddot"
  },
  	"⟑": {
  	math: "\\wedgedot"
  },
  	"⟒": {
  	math: "\\upin"
  },
  	"⟓": {
  	math: "\\pullback"
  },
  	"⟔": {
  	math: "\\pushout"
  },
  	"⟕": {
  	math: "\\leftouterjoin"
  },
  	"⟖": {
  	math: "\\rightouterjoin"
  },
  	"⟗": {
  	math: "\\fullouterjoin"
  },
  	"⟘": {
  	math: "\\bigbot"
  },
  	"⟙": {
  	math: "\\bigtop"
  },
  	"⟚": {
  	math: "\\DashVDash"
  },
  	"⟛": {
  	math: "\\dashVdash"
  },
  	"⟜": {
  	math: "\\multimapinv"
  },
  	"⟝": {
  	math: "\\vlongdash"
  },
  	"⟞": {
  	math: "\\longdashv"
  },
  	"⟟": {
  	math: "\\cirbot"
  },
  	"⟠": {
  	math: "\\lozengeminus"
  },
  	"⟡": {
  	math: "\\concavediamond"
  },
  	"⟢": {
  	math: "\\concavediamondtickleft"
  },
  	"⟣": {
  	math: "\\concavediamondtickright"
  },
  	"⟤": {
  	math: "\\whitesquaretickleft"
  },
  	"⟥": {
  	math: "\\whitesquaretickright"
  },
  	"⟦": {
  	math: "\\llbracket"
  },
  	"⟧": {
  	math: "\\rrbracket"
  },
  	"⟨": {
  	math: "\\langle"
  },
  	"⟩": {
  	math: "\\rangle"
  },
  	"⟪": {
  	math: "\\lang"
  },
  	"⟫": {
  	math: "\\rang"
  },
  	"⟬": {
  	math: "\\Lbrbrak"
  },
  	"⟭": {
  	math: "\\Rbrbrak"
  },
  	"⟮": {
  	math: "\\lgroup"
  },
  	"⟯": {
  	math: "\\rgroup"
  },
  	"⟰": {
  	math: "\\UUparrow"
  },
  	"⟱": {
  	math: "\\DDownarrow"
  },
  	"⟲": {
  	math: "\\acwgapcirclearrow"
  },
  	"⟳": {
  	math: "\\cwgapcirclearrow"
  },
  	"⟴": {
  	math: "\\rightarrowonoplus"
  },
  	"⟵": {
  	math: "\\longleftarrow"
  },
  	"⟶": {
  	math: "\\longrightarrow"
  },
  	"⟷": {
  	math: "\\longleftrightarrow"
  },
  	"⟸": {
  	math: "\\Longleftarrow"
  },
  	"⟹": {
  	math: "\\Longrightarrow"
  },
  	"⟺": {
  	math: "\\Longleftrightarrow"
  },
  	"⟻": {
  	math: "\\longmapsfrom"
  },
  	"⟼": {
  	math: "\\longmapsto"
  },
  	"⟽": {
  	math: "\\Longmapsfrom"
  },
  	"⟾": {
  	math: "\\Longmapsto"
  },
  	"⟿": {
  	math: "\\sim\\joinrel\\leadsto"
  },
  	"⤀": {
  	math: "\\psur"
  },
  	"⤁": {
  	math: "\\nVtwoheadrightarrow"
  },
  	"⤂": {
  	math: "\\nvLeftarrow"
  },
  	"⤃": {
  	math: "\\nvRightarrow"
  },
  	"⤄": {
  	math: "\\nvLeftrightarrow"
  },
  	"⤆": {
  	math: "\\Mapsfrom"
  },
  	"⤇": {
  	math: "\\Mapsto"
  },
  	"⤈": {
  	math: "\\downarrowbarred"
  },
  	"⤉": {
  	math: "\\uparrowbarred"
  },
  	"⤊": {
  	math: "\\Uuparrow"
  },
  	"⤋": {
  	math: "\\Ddownarrow"
  },
  	"⤌": {
  	math: "\\leftbkarrow"
  },
  	"⤍": {
  	math: "\\rightbkarrow"
  },
  	"⤎": {
  	math: "\\leftdbkarrow"
  },
  	"⤏": {
  	math: "\\dbkarow"
  },
  	"⤐": {
  	math: "\\drbkarow"
  },
  	"⤑": {
  	math: "\\rightdotarrow"
  },
  	"⤒": {
  	math: "\\UpArrowBar"
  },
  	"⤓": {
  	math: "\\DownArrowBar"
  },
  	"⤔": {
  	math: "\\pinj"
  },
  	"⤕": {
  	math: "\\finj"
  },
  	"⤖": {
  	math: "\\bij"
  },
  	"⤗": {
  	math: "\\nvtwoheadrightarrowtail"
  },
  	"⤘": {
  	math: "\\nVtwoheadrightarrowtail"
  },
  	"⤙": {
  	math: "\\lefttail"
  },
  	"⤚": {
  	math: "\\righttail"
  },
  	"⤛": {
  	math: "\\leftdbltail"
  },
  	"⤜": {
  	math: "\\rightdbltail"
  },
  	"⤝": {
  	math: "\\diamondleftarrow"
  },
  	"⤞": {
  	math: "\\rightarrowdiamond"
  },
  	"⤟": {
  	math: "\\diamondleftarrowbar"
  },
  	"⤠": {
  	math: "\\barrightarrowdiamond"
  },
  	"⤡": {
  	math: "\\nwsearrow"
  },
  	"⤢": {
  	math: "\\neswarrow"
  },
  	"⤫": {
  	math: "\\rdiagovfdiag"
  },
  	"⤬": {
  	math: "\\fdiagovrdiag"
  },
  	"⤭": {
  	math: "\\seovnearrow"
  },
  	"⤮": {
  	math: "\\neovsearrow"
  },
  	"⤯": {
  	math: "\\fdiagovnearrow"
  },
  	"⤰": {
  	math: "\\rdiagovsearrow"
  },
  	"⤱": {
  	math: "\\neovnwarrow"
  },
  	"⤲": {
  	math: "\\nwovnearrow"
  },
  	"⤴": {
  	math: "\\uprightcurvearrow"
  },
  	"⤵": {
  	math: "\\downrightcurvedarrow"
  },
  	"⤸": {
  	math: "\\cwrightarcarrow"
  },
  	"⤹": {
  	math: "\\acwleftarcarrow"
  },
  	"⤺": {
  	math: "\\acwoverarcarrow"
  },
  	"⤻": {
  	math: "\\acwunderarcarrow"
  },
  	"⤼": {
  	math: "\\curvearrowrightminus"
  },
  	"⤽": {
  	math: "\\curvearrowleftplus"
  },
  	"⤾": {
  	math: "\\cwundercurvearrow"
  },
  	"⤿": {
  	math: "\\ccwundercurvearrow"
  },
  	"⥀": {
  	math: "\\Elolarr"
  },
  	"⥁": {
  	math: "\\Elorarr"
  },
  	"⥂": {
  	math: "\\ElzRlarr"
  },
  	"⥃": {
  	math: "\\leftarrowshortrightarrow"
  },
  	"⥄": {
  	math: "\\ElzrLarr"
  },
  	"⥅": {
  	math: "\\rightarrowplus"
  },
  	"⥆": {
  	math: "\\leftarrowplus"
  },
  	"⥇": {
  	math: "\\Elzrarrx"
  },
  	"⥈": {
  	math: "\\leftrightarrowcircle"
  },
  	"⥉": {
  	math: "\\twoheaduparrowcircle"
  },
  	"⥊": {
  	math: "\\leftrightharpoon"
  },
  	"⥋": {
  	math: "\\rightleftharpoon"
  },
  	"⥌": {
  	math: "\\updownharpoonrightleft"
  },
  	"⥍": {
  	math: "\\updownharpoonleftright"
  },
  	"⥎": {
  	math: "\\LeftRightVector"
  },
  	"⥏": {
  	math: "\\RightUpDownVector"
  },
  	"⥐": {
  	math: "\\DownLeftRightVector"
  },
  	"⥑": {
  	math: "\\LeftUpDownVector"
  },
  	"⥒": {
  	math: "\\LeftVectorBar"
  },
  	"⥓": {
  	math: "\\RightVectorBar"
  },
  	"⥔": {
  	math: "\\RightUpVectorBar"
  },
  	"⥕": {
  	math: "\\RightDownVectorBar"
  },
  	"⥖": {
  	math: "\\DownLeftVectorBar"
  },
  	"⥗": {
  	math: "\\DownRightVectorBar"
  },
  	"⥘": {
  	math: "\\LeftUpVectorBar"
  },
  	"⥙": {
  	math: "\\LeftDownVectorBar"
  },
  	"⥚": {
  	math: "\\LeftTeeVector"
  },
  	"⥛": {
  	math: "\\RightTeeVector"
  },
  	"⥜": {
  	math: "\\RightUpTeeVector"
  },
  	"⥝": {
  	math: "\\RightDownTeeVector"
  },
  	"⥞": {
  	math: "\\DownLeftTeeVector"
  },
  	"⥟": {
  	math: "\\DownRightTeeVector"
  },
  	"⥠": {
  	math: "\\LeftUpTeeVector"
  },
  	"⥡": {
  	math: "\\LeftDownTeeVector"
  },
  	"⥢": {
  	math: "\\leftleftharpoons"
  },
  	"⥣": {
  	math: "\\upupharpoons"
  },
  	"⥤": {
  	math: "\\rightrightharpoons"
  },
  	"⥥": {
  	math: "\\downdownharpoons"
  },
  	"⥦": {
  	math: "\\leftrightharpoonsup"
  },
  	"⥧": {
  	math: "\\leftrightharpoonsdown"
  },
  	"⥨": {
  	math: "\\rightleftharpoonsup"
  },
  	"⥩": {
  	math: "\\rightleftharpoonsdown"
  },
  	"⥪": {
  	math: "\\leftbarharpoon"
  },
  	"⥫": {
  	math: "\\barleftharpoon"
  },
  	"⥬": {
  	math: "\\rightbarharpoon"
  },
  	"⥭": {
  	math: "\\barrightharpoon"
  },
  	"⥮": {
  	math: "\\UpEquilibrium"
  },
  	"⥯": {
  	math: "\\ReverseUpEquilibrium"
  },
  	"⥰": {
  	math: "\\RoundImplies"
  },
  	"⥱": {
  	math: "\\equalrightarrow"
  },
  	"⥲": {
  	math: "\\similarrightarrow"
  },
  	"⥳": {
  	math: "\\leftarrowsimilar"
  },
  	"⥴": {
  	math: "\\rightarrowsimilar"
  },
  	"⥵": {
  	math: "\\rightarrowapprox"
  },
  	"⥶": {
  	math: "\\ltlarr"
  },
  	"⥷": {
  	math: "\\leftarrowless"
  },
  	"⥸": {
  	math: "\\gtrarr"
  },
  	"⥹": {
  	math: "\\subrarr"
  },
  	"⥺": {
  	math: "\\leftarrowsubset"
  },
  	"⥻": {
  	math: "\\suplarr"
  },
  	"⥾": {
  	math: "\\upfishtail"
  },
  	"⥿": {
  	math: "\\downfishtail"
  },
  	"⦀": {
  	math: "\\Elztfnc"
  },
  	"⦁": {
  	math: "\\spot"
  },
  	"⦂": {
  	math: "\\typecolon"
  },
  	"⦃": {
  	math: "\\lBrace"
  },
  	"⦄": {
  	math: "\\rBrace"
  },
  	"⦆": {
  	math: "\\Elroang"
  },
  	"⦇": {
  	math: "\\limg"
  },
  	"⦈": {
  	math: "\\rimg"
  },
  	"⦉": {
  	math: "\\lblot"
  },
  	"⦊": {
  	math: "\\rblot"
  },
  	"⦋": {
  	math: "\\lbrackubar"
  },
  	"⦌": {
  	math: "\\rbrackubar"
  },
  	"⦍": {
  	math: "\\lbrackultick"
  },
  	"⦎": {
  	math: "\\rbracklrtick"
  },
  	"⦏": {
  	math: "\\lbracklltick"
  },
  	"⦐": {
  	math: "\\rbrackurtick"
  },
  	"⦑": {
  	math: "\\langledot"
  },
  	"⦒": {
  	math: "\\rangledot"
  },
  	"⦓": {
  	math: "<\\kern-0.58em("
  },
  	"⦕": {
  	math: "\\Lparengtr"
  },
  	"⦖": {
  	math: "\\Rparenless"
  },
  	"⦗": {
  	math: "\\lblkbrbrak"
  },
  	"⦘": {
  	math: "\\rblkbrbrak"
  },
  	"⦙": {
  	math: "\\Elzddfnc"
  },
  	"⦚": {
  	math: "\\vzigzag"
  },
  	"⦛": {
  	math: "\\measuredangleleft"
  },
  	"⦜": {
  	math: "\\Angle"
  },
  	"⦝": {
  	math: "\\rightanglemdot"
  },
  	"⦞": {
  	math: "\\angles"
  },
  	"⦟": {
  	math: "\\angdnr"
  },
  	"⦠": {
  	math: "\\Elzlpargt"
  },
  	"⦡": {
  	math: "\\sphericalangleup"
  },
  	"⦢": {
  	math: "\\turnangle"
  },
  	"⦣": {
  	math: "\\revangle"
  },
  	"⦤": {
  	math: "\\angleubar"
  },
  	"⦥": {
  	math: "\\revangleubar"
  },
  	"⦦": {
  	math: "\\wideangledown"
  },
  	"⦧": {
  	math: "\\wideangleup"
  },
  	"⦨": {
  	math: "\\measanglerutone"
  },
  	"⦩": {
  	math: "\\measanglelutonw"
  },
  	"⦪": {
  	math: "\\measanglerdtose"
  },
  	"⦫": {
  	math: "\\measangleldtosw"
  },
  	"⦬": {
  	math: "\\measangleurtone"
  },
  	"⦭": {
  	math: "\\measangleultonw"
  },
  	"⦮": {
  	math: "\\measangledrtose"
  },
  	"⦯": {
  	math: "\\measangledltosw"
  },
  	"⦰": {
  	math: "\\revemptyset"
  },
  	"⦱": {
  	math: "\\emptysetobar"
  },
  	"⦲": {
  	math: "\\emptysetocirc"
  },
  	"⦳": {
  	math: "\\emptysetoarr"
  },
  	"⦴": {
  	math: "\\emptysetoarrl"
  },
  	"⦷": {
  	math: "\\circledparallel"
  },
  	"⦸": {
  	math: "\\circledbslash"
  },
  	"⦹": {
  	math: "\\operp"
  },
  	"⦺": {
  	math: "\\obot"
  },
  	"⦻": {
  	math: "\\olcross"
  },
  	"⦼": {
  	math: "\\odotslashdot"
  },
  	"⦽": {
  	math: "\\uparrowoncircle"
  },
  	"⦾": {
  	math: "\\circledwhitebullet"
  },
  	"⦿": {
  	math: "\\circledbullet"
  },
  	"⧀": {
  	math: "\\circledless"
  },
  	"⧁": {
  	math: "\\circledgtr"
  },
  	"⧂": {
  	math: "\\cirscir"
  },
  	"⧃": {
  	math: "\\cirE"
  },
  	"⧄": {
  	math: "\\boxslash"
  },
  	"⧅": {
  	math: "\\boxbslash"
  },
  	"⧆": {
  	math: "\\boxast"
  },
  	"⧇": {
  	math: "\\boxcircle"
  },
  	"⧈": {
  	math: "\\boxbox"
  },
  	"⧉": {
  	math: "\\boxonbox"
  },
  	"⧊": {
  	math: "\\ElzLap"
  },
  	"⧋": {
  	math: "\\Elzdefas"
  },
  	"⧌": {
  	math: "\\triangles"
  },
  	"⧍": {
  	math: "\\triangleserifs"
  },
  	"⧎": {
  	math: "\\rtriltri"
  },
  	"⧏": {
  	math: "\\LeftTriangleBar"
  },
  	"⧏̸": {
  	math: "\\NotLeftTriangleBar"
  },
  	"⧐": {
  	math: "\\RightTriangleBar"
  },
  	"⧐̸": {
  	math: "\\NotRightTriangleBar"
  },
  	"⧑": {
  	math: "\\lfbowtie"
  },
  	"⧒": {
  	math: "\\rfbowtie"
  },
  	"⧓": {
  	math: "\\fbowtie"
  },
  	"⧔": {
  	math: "\\lftimes"
  },
  	"⧕": {
  	math: "\\rftimes"
  },
  	"⧖": {
  	math: "\\hourglass"
  },
  	"⧗": {
  	math: "\\blackhourglass"
  },
  	"⧘": {
  	math: "\\lvzigzag"
  },
  	"⧙": {
  	math: "\\rvzigzag"
  },
  	"⧚": {
  	math: "\\Lvzigzag"
  },
  	"⧛": {
  	math: "\\Rvzigzag"
  },
  	"⧝": {
  	math: "\\tieinfty"
  },
  	"⧞": {
  	math: "\\nvinfty"
  },
  	"⧟": {
  	math: "\\multimapboth"
  },
  	"⧠": {
  	math: "\\laplac"
  },
  	"⧡": {
  	math: "\\lrtriangleeq"
  },
  	"⧢": {
  	math: "\\shuffle"
  },
  	"⧣": {
  	math: "\\eparsl"
  },
  	"⧤": {
  	math: "\\smeparsl"
  },
  	"⧥": {
  	math: "\\eqvparsl"
  },
  	"⧦": {
  	math: "\\gleichstark"
  },
  	"⧧": {
  	math: "\\thermod"
  },
  	"⧨": {
  	math: "\\downtriangleleftblack"
  },
  	"⧩": {
  	math: "\\downtrianglerightblack"
  },
  	"⧪": {
  	math: "\\blackdiamonddownarrow"
  },
  	"⧫": {
  	math: "\\blacklozenge"
  },
  	"⧬": {
  	math: "\\circledownarrow"
  },
  	"⧭": {
  	math: "\\blackcircledownarrow"
  },
  	"⧮": {
  	math: "\\errbarsquare"
  },
  	"⧯": {
  	math: "\\errbarblacksquare"
  },
  	"⧰": {
  	math: "\\errbardiamond"
  },
  	"⧱": {
  	math: "\\errbarblackdiamond"
  },
  	"⧲": {
  	math: "\\errbarcircle"
  },
  	"⧳": {
  	math: "\\errbarblackcircle"
  },
  	"⧴": {
  	math: "\\RuleDelayed"
  },
  	"⧵": {
  	math: "\\setminus"
  },
  	"⧶": {
  	math: "\\dsol"
  },
  	"⧷": {
  	math: "\\rsolbar"
  },
  	"⧸": {
  	math: "\\xsol"
  },
  	"⧹": {
  	math: "\\zhide"
  },
  	"⧺": {
  	math: "\\doubleplus"
  },
  	"⧻": {
  	math: "\\tripleplus"
  },
  	"⧼": {
  	math: "\\lcurvyangle"
  },
  	"⧽": {
  	math: "\\rcurvyangle"
  },
  	"⧾": {
  	math: "\\tplus"
  },
  	"⧿": {
  	math: "\\tminus"
  },
  	"⨀": {
  	math: "\\bigodot"
  },
  	"⨁": {
  	math: "\\bigoplus"
  },
  	"⨂": {
  	math: "\\bigotimes"
  },
  	"⨃": {
  	math: "\\bigcupdot"
  },
  	"⨄": {
  	math: "\\Elxuplus"
  },
  	"⨅": {
  	math: "\\ElzThr"
  },
  	"⨆": {
  	math: "\\Elxsqcup"
  },
  	"⨇": {
  	math: "\\ElzInf"
  },
  	"⨈": {
  	math: "\\ElzSup"
  },
  	"⨉": {
  	math: "\\varprod"
  },
  	"⨊": {
  	math: "\\modtwosum"
  },
  	"⨋": {
  	math: "\\sumint"
  },
  	"⨌": {
  	math: "\\iiiint"
  },
  	"⨍": {
  	math: "\\ElzCint"
  },
  	"⨎": {
  	math: "\\intBar"
  },
  	"⨏": {
  	math: "\\clockoint"
  },
  	"⨑": {
  	math: "\\awint"
  },
  	"⨒": {
  	math: "\\rppolint"
  },
  	"⨓": {
  	math: "\\scpolint"
  },
  	"⨔": {
  	math: "\\npolint"
  },
  	"⨕": {
  	math: "\\pointint"
  },
  	"⨖": {
  	math: "\\sqrint"
  },
  	"⨗": {
  	math: "\\intlarhk"
  },
  	"⨘": {
  	math: "\\intx"
  },
  	"⨙": {
  	math: "\\intcap"
  },
  	"⨚": {
  	math: "\\intcup"
  },
  	"⨛": {
  	math: "\\upint"
  },
  	"⨜": {
  	math: "\\lowint"
  },
  	"⨝": {
  	math: "\\Join"
  },
  	"⨞": {
  	math: "\\bigtriangleleft"
  },
  	"⨟": {
  	math: "\\zcmp"
  },
  	"⨠": {
  	math: "\\zpipe"
  },
  	"⨡": {
  	math: "\\zproject"
  },
  	"⨢": {
  	math: "\\ringplus"
  },
  	"⨣": {
  	math: "\\plushat"
  },
  	"⨤": {
  	math: "\\simplus"
  },
  	"⨦": {
  	math: "\\plussim"
  },
  	"⨧": {
  	math: "\\plussubtwo"
  },
  	"⨨": {
  	math: "\\plustrif"
  },
  	"⨩": {
  	math: "\\commaminus"
  },
  	"⨫": {
  	math: "\\minusfdots"
  },
  	"⨬": {
  	math: "\\minusrdots"
  },
  	"⨯": {
  	math: "\\ElzTimes"
  },
  	"⨰": {
  	math: "\\dottimes"
  },
  	"⨱": {
  	math: "\\timesbar"
  },
  	"⨲": {
  	math: "\\btimes"
  },
  	"⨳": {
  	math: "\\smashtimes"
  },
  	"⨶": {
  	math: "\\otimeshat"
  },
  	"⨷": {
  	math: "\\Otimes"
  },
  	"⨸": {
  	math: "\\odiv"
  },
  	"⨹": {
  	math: "\\triangleplus"
  },
  	"⨺": {
  	math: "\\triangleminus"
  },
  	"⨻": {
  	math: "\\triangletimes"
  },
  	"⨽": {
  	math: "\\intprodr"
  },
  	"⨾": {
  	math: "\\fcmp"
  },
  	"⨿": {
  	math: "\\amalg"
  },
  	"⩀": {
  	math: "\\capdot"
  },
  	"⩁": {
  	math: "\\uminus"
  },
  	"⩂": {
  	math: "\\barcup"
  },
  	"⩃": {
  	math: "\\barcap"
  },
  	"⩄": {
  	math: "\\capwedge"
  },
  	"⩅": {
  	math: "\\cupvee"
  },
  	"⩆": {
  	math: "\\cupovercap"
  },
  	"⩇": {
  	math: "\\capovercup"
  },
  	"⩈": {
  	math: "\\cupbarcap"
  },
  	"⩉": {
  	math: "\\capbarcup"
  },
  	"⩊": {
  	math: "\\twocups"
  },
  	"⩋": {
  	math: "\\twocaps"
  },
  	"⩌": {
  	math: "\\closedvarcup"
  },
  	"⩍": {
  	math: "\\closedvarcap"
  },
  	"⩎": {
  	math: "\\Sqcap"
  },
  	"⩏": {
  	math: "\\Sqcup"
  },
  	"⩐": {
  	math: "\\closedvarcupsmashprod"
  },
  	"⩑": {
  	math: "\\wedgeodot"
  },
  	"⩒": {
  	math: "\\veeodot"
  },
  	"⩓": {
  	math: "\\ElzAnd"
  },
  	"⩔": {
  	math: "\\ElzOr"
  },
  	"⩖": {
  	math: "\\ElOr"
  },
  	"⩗": {
  	math: "\\bigslopedvee"
  },
  	"⩘": {
  	math: "\\bigslopedwedge"
  },
  	"⩙": {
  	math: "\\veeonwedge"
  },
  	"⩚": {
  	math: "\\wedgemidvert"
  },
  	"⩛": {
  	math: "\\veemidvert"
  },
  	"⩜": {
  	math: "\\midbarwedge"
  },
  	"⩝": {
  	math: "\\midbarvee"
  },
  	"⩞": {
  	math: "\\perspcorrespond"
  },
  	"⩟": {
  	math: "\\Elzminhat"
  },
  	"⩠": {
  	math: "\\wedgedoublebar"
  },
  	"⩡": {
  	math: "\\varveebar"
  },
  	"⩢": {
  	math: "\\doublebarvee"
  },
  	"⩤": {
  	math: "\\dsub"
  },
  	"⩥": {
  	math: "\\rsub"
  },
  	"⩦": {
  	math: "\\eqdot"
  },
  	"⩧": {
  	math: "\\dotequiv"
  },
  	"⩨": {
  	math: "\\equivVert"
  },
  	"⩩": {
  	math: "\\equivVvert"
  },
  	"⩪": {
  	math: "\\dotsim"
  },
  	"⩫": {
  	math: "\\simrdots"
  },
  	"⩬": {
  	math: "\\simminussim"
  },
  	"⩭": {
  	math: "\\congdot"
  },
  	"⩮": {
  	math: "\\stackrel{*}{=}"
  },
  	"⩯": {
  	math: "\\hatapprox"
  },
  	"⩰": {
  	math: "\\approxeqq"
  },
  	"⩱": {
  	math: "\\eqqplus"
  },
  	"⩲": {
  	math: "\\pluseqq"
  },
  	"⩳": {
  	math: "\\eqqsim"
  },
  	"⩴": {
  	math: "\\Coloneqq"
  },
  	"⩵": {
  	math: "\\Equal"
  },
  	"⩶": {
  	math: "\\Same"
  },
  	"⩷": {
  	math: "\\ddotseq"
  },
  	"⩸": {
  	math: "\\equivDD"
  },
  	"⩹": {
  	math: "\\ltcir"
  },
  	"⩺": {
  	math: "\\gtcir"
  },
  	"⩻": {
  	math: "\\ltquest"
  },
  	"⩼": {
  	math: "\\gtquest"
  },
  	"⩽": {
  	math: "\\leqslant",
  	mathpackages: [
  		"amssymb"
  	]
  },
  	"⩽̸": {
  	math: "\\nleqslant",
  	mathpackages: [
  		"amssymb"
  	]
  },
  	"⩾": {
  	math: "\\geqslant",
  	mathpackages: [
  		"amssymb"
  	]
  },
  	"⩾̸": {
  	math: "\\ngeqslant",
  	mathpackages: [
  		"amssymb"
  	]
  },
  	"⩿": {
  	math: "\\lesdot"
  },
  	"⪀": {
  	math: "\\gesdot"
  },
  	"⪁": {
  	math: "\\lesdoto"
  },
  	"⪂": {
  	math: "\\gesdoto"
  },
  	"⪃": {
  	math: "\\lesdotor"
  },
  	"⪄": {
  	math: "\\gesdotol"
  },
  	"⪅": {
  	math: "\\lessapprox"
  },
  	"⪆": {
  	math: "\\gtrapprox"
  },
  	"⪇": {
  	math: "\\lneq"
  },
  	"⪈": {
  	math: "\\gneq"
  },
  	"⪉": {
  	math: "\\lnapprox"
  },
  	"⪊": {
  	math: "\\gnapprox"
  },
  	"⪋": {
  	math: "\\lesseqqgtr"
  },
  	"⪌": {
  	math: "\\gtreqqless"
  },
  	"⪍": {
  	math: "\\lsime"
  },
  	"⪎": {
  	math: "\\gsime"
  },
  	"⪏": {
  	math: "\\lsimg"
  },
  	"⪐": {
  	math: "\\gsiml"
  },
  	"⪑": {
  	math: "\\lgE"
  },
  	"⪒": {
  	math: "\\glE"
  },
  	"⪓": {
  	math: "\\lesges"
  },
  	"⪔": {
  	math: "\\gesles"
  },
  	"⪕": {
  	math: "\\eqslantless"
  },
  	"⪖": {
  	math: "\\eqslantgtr"
  },
  	"⪗": {
  	math: "\\elsdot"
  },
  	"⪘": {
  	math: "\\egsdot"
  },
  	"⪙": {
  	math: "\\eqqless"
  },
  	"⪚": {
  	math: "\\eqqgtr"
  },
  	"⪛": {
  	math: "\\eqqslantless"
  },
  	"⪜": {
  	math: "\\eqqslantgtr"
  },
  	"⪝": {
  	math: "\\Pisymbol{ppi020}{117}"
  },
  	"⪞": {
  	math: "\\Pisymbol{ppi020}{105}"
  },
  	"⪟": {
  	math: "\\simlE"
  },
  	"⪠": {
  	math: "\\simgE"
  },
  	"⪡": {
  	math: "\\NestedLessLess"
  },
  	"⪡̸": {
  	math: "\\NotNestedLessLess"
  },
  	"⪢": {
  	math: "\\NestedGreaterGreater"
  },
  	"⪢̸": {
  	math: "\\NotNestedGreaterGreater"
  },
  	"⪣": {
  	math: "\\partialmeetcontraction"
  },
  	"⪤": {
  	math: "\\glj"
  },
  	"⪥": {
  	math: "\\gla"
  },
  	"⪦": {
  	math: "\\leftslice"
  },
  	"⪧": {
  	math: "\\rightslice"
  },
  	"⪨": {
  	math: "\\lescc"
  },
  	"⪩": {
  	math: "\\gescc"
  },
  	"⪪": {
  	math: "\\smt"
  },
  	"⪫": {
  	math: "\\lat"
  },
  	"⪬": {
  	math: "\\smte"
  },
  	"⪭": {
  	math: "\\late"
  },
  	"⪮": {
  	math: "\\bumpeqq"
  },
  	"⪯": {
  	math: "\\preceq"
  },
  	"⪯̸": {
  	math: "\\not\\preceq"
  },
  	"⪰": {
  	math: "\\succeq"
  },
  	"⪰̸": {
  	math: "\\not\\succeq"
  },
  	"⪱": {
  	math: "\\precneq"
  },
  	"⪲": {
  	math: "\\succneq"
  },
  	"⪳": {
  	math: "\\preceqq"
  },
  	"⪴": {
  	math: "\\succeqq"
  },
  	"⪵": {
  	math: "\\precneqq"
  },
  	"⪶": {
  	math: "\\succneqq"
  },
  	"⪷": {
  	math: "\\precapprox"
  },
  	"⪸": {
  	math: "\\succapprox"
  },
  	"⪹": {
  	math: "\\precnapprox"
  },
  	"⪺": {
  	math: "\\succnapprox"
  },
  	"⪻": {
  	math: "\\llcurly"
  },
  	"⪼": {
  	math: "\\ggcurly"
  },
  	"⪽": {
  	math: "\\subsetdot"
  },
  	"⪾": {
  	math: "\\supsetdot"
  },
  	"⪿": {
  	math: "\\subsetplus"
  },
  	"⫀": {
  	math: "\\supsetplus"
  },
  	"⫁": {
  	math: "\\submult"
  },
  	"⫂": {
  	math: "\\supmult"
  },
  	"⫃": {
  	math: "\\subedot"
  },
  	"⫄": {
  	math: "\\supedot"
  },
  	"⫅": {
  	math: "\\subseteqq"
  },
  	"⫅̸": {
  	math: "\\nsubseteqq"
  },
  	"⫆": {
  	math: "\\supseteqq"
  },
  	"⫆̸": {
  	math: "\\nsupseteqq"
  },
  	"⫇": {
  	math: "\\subsim"
  },
  	"⫈": {
  	math: "\\supsim"
  },
  	"⫉": {
  	math: "\\subsetapprox"
  },
  	"⫊": {
  	math: "\\supsetapprox"
  },
  	"⫋": {
  	math: "\\subsetneqq"
  },
  	"⫌": {
  	math: "\\supsetneqq"
  },
  	"⫍": {
  	math: "\\lsqhook"
  },
  	"⫎": {
  	math: "\\rsqhook"
  },
  	"⫏": {
  	math: "\\csub"
  },
  	"⫐": {
  	math: "\\csup"
  },
  	"⫑": {
  	math: "\\csube"
  },
  	"⫒": {
  	math: "\\csupe"
  },
  	"⫓": {
  	math: "\\subsup"
  },
  	"⫔": {
  	math: "\\supsub"
  },
  	"⫕": {
  	math: "\\subsub"
  },
  	"⫖": {
  	math: "\\supsup"
  },
  	"⫗": {
  	math: "\\suphsub"
  },
  	"⫘": {
  	math: "\\supdsub"
  },
  	"⫙": {
  	math: "\\forkv"
  },
  	"⫚": {
  	math: "\\topfork"
  },
  	"⫛": {
  	math: "\\mlcp"
  },
  	"⫝̸": {
  	math: "\\forks"
  },
  	"⫝": {
  	math: "\\forksnot"
  },
  	"⫝̸": {
  	math: "\\forks"
  },
  	"⫞": {
  	math: "\\shortlefttack"
  },
  	"⫟": {
  	math: "\\shortdowntack"
  },
  	"⫠": {
  	math: "\\shortuptack"
  },
  	"⫡": {
  	math: "\\perps"
  },
  	"⫢": {
  	math: "\\vDdash"
  },
  	"⫣": {
  	math: "\\dashV"
  },
  	"⫤": {
  	math: "\\Dashv"
  },
  	"⫥": {
  	math: "\\DashV"
  },
  	"⫦": {
  	math: "\\varVdash"
  },
  	"⫧": {
  	math: "\\Barv"
  },
  	"⫨": {
  	math: "\\vBar"
  },
  	"⫩": {
  	math: "\\vBarv"
  },
  	"⫪": {
  	math: "\\Top"
  },
  	"⫬": {
  	math: "\\Not"
  },
  	"⫭": {
  	math: "\\bNot"
  },
  	"⫮": {
  	math: "\\revnmid"
  },
  	"⫯": {
  	math: "\\cirmid"
  },
  	"⫰": {
  	math: "\\midcir"
  },
  	"⫱": {
  	math: "\\topcir"
  },
  	"⫲": {
  	math: "\\nhpar"
  },
  	"⫳": {
  	math: "\\parsim"
  },
  	"⫴": {
  	math: "\\interleave"
  },
  	"⫵": {
  	math: "\\nhVvert"
  },
  	"⫶": {
  	math: "\\Elztdcol"
  },
  	"⫷": {
  	math: "\\lllnest"
  },
  	"⫸": {
  	math: "\\gggnest"
  },
  	"⫹": {
  	math: "\\leqqslant"
  },
  	"⫺": {
  	math: "\\geqqslant"
  },
  	"⫻": {
  	math: "\\trslash"
  },
  	"⫼": {
  	math: "\\biginterleave"
  },
  	"⫽": {
  	math: "{{/}\\!\\!{/}}"
  },
  	"⫽⃥": {
  	math: "{\\rlap{\\textbackslash}{{/}\\!\\!{/}}}"
  },
  	"⫾": {
  	math: "\\talloblong"
  },
  	"⫿": {
  	math: "\\bigtalloblong"
  },
  	"⬒": {
  	math: "\\squaretopblack"
  },
  	"⬓": {
  	math: "\\squarebotblack"
  },
  	"⬔": {
  	math: "\\squareurblack"
  },
  	"⬕": {
  	math: "\\squarellblack"
  },
  	"⬖": {
  	math: "\\diamondleftblack"
  },
  	"⬗": {
  	math: "\\diamondrightblack"
  },
  	"⬘": {
  	math: "\\diamondtopblack"
  },
  	"⬙": {
  	math: "\\diamondbotblack"
  },
  	"⬚": {
  	math: "\\dottedsquare"
  },
  	"⬛": {
  	math: "\\blacksquare"
  },
  	"⬜": {
  	math: "\\square"
  },
  	"⬝": {
  	math: "\\vysmblksquare"
  },
  	"⬞": {
  	math: "\\vysmwhtsquare"
  },
  	"⬟": {
  	math: "\\pentagonblack"
  },
  	"⬠": {
  	math: "\\pentagon"
  },
  	"⬡": {
  	math: "\\varhexagon"
  },
  	"⬢": {
  	math: "\\varhexagonblack"
  },
  	"⬣": {
  	math: "\\hexagonblack"
  },
  	"⬤": {
  	math: "\\lgblkcircle"
  },
  	"⬥": {
  	math: "\\mdblkdiamond"
  },
  	"⬦": {
  	math: "\\mdwhtdiamond"
  },
  	"⬧": {
  	math: "\\mdblklozenge"
  },
  	"⬨": {
  	math: "\\mdwhtlozenge"
  },
  	"⬩": {
  	math: "\\smblkdiamond"
  },
  	"⬪": {
  	math: "\\smblklozenge"
  },
  	"⬫": {
  	math: "\\smwhtlozenge"
  },
  	"⬬": {
  	math: "\\blkhorzoval"
  },
  	"⬭": {
  	math: "\\whthorzoval"
  },
  	"⬮": {
  	math: "\\blkvertoval"
  },
  	"⬯": {
  	math: "\\whtvertoval"
  },
  	"⬰": {
  	math: "\\circleonleftarrow"
  },
  	"⬱": {
  	math: "\\leftthreearrows"
  },
  	"⬲": {
  	math: "\\leftarrowonoplus"
  },
  	"⬳": {
  	math: "\\longleftsquigarrow"
  },
  	"⬴": {
  	math: "\\nvtwoheadleftarrow"
  },
  	"⬵": {
  	math: "\\nVtwoheadleftarrow"
  },
  	"⬶": {
  	math: "\\twoheadmapsfrom"
  },
  	"⬷": {
  	math: "\\twoheadleftdbkarrow"
  },
  	"⬸": {
  	math: "\\leftdotarrow"
  },
  	"⬹": {
  	math: "\\nvleftarrowtail"
  },
  	"⬺": {
  	math: "\\nVleftarrowtail"
  },
  	"⬻": {
  	math: "\\twoheadleftarrowtail"
  },
  	"⬼": {
  	math: "\\nvtwoheadleftarrowtail"
  },
  	"⬽": {
  	math: "\\nVtwoheadleftarrowtail"
  },
  	"⬾": {
  	math: "\\leftarrowx"
  },
  	"⬿": {
  	math: "\\leftcurvedarrow"
  },
  	"⭀": {
  	math: "\\equalleftarrow"
  },
  	"⭁": {
  	math: "\\bsimilarleftarrow"
  },
  	"⭂": {
  	math: "\\leftarrowbackapprox"
  },
  	"⭃": {
  	math: "\\rightarrowgtr"
  },
  	"⭄": {
  	math: "\\rightarrowsupset"
  },
  	"⭅": {
  	math: "\\LLeftarrow"
  },
  	"⭆": {
  	math: "\\RRightarrow"
  },
  	"⭇": {
  	math: "\\bsimilarrightarrow"
  },
  	"⭈": {
  	math: "\\rightarrowbackapprox"
  },
  	"⭉": {
  	math: "\\similarleftarrow"
  },
  	"⭊": {
  	math: "\\leftarrowapprox"
  },
  	"⭋": {
  	math: "\\leftarrowbsimilar"
  },
  	"⭌": {
  	math: "\\rightarrowbsimilar"
  },
  	"⭐": {
  	math: "\\medwhitestar"
  },
  	"⭑": {
  	math: "\\medblackstar"
  },
  	"⭒": {
  	math: "\\smwhitestar"
  },
  	"⭓": {
  	math: "\\rightpentagonblack"
  },
  	"⭔": {
  	math: "\\rightpentagon"
  },
  	"〈": {
  	math: "\\langle"
  },
  	"〉": {
  	math: "\\rangle"
  },
  	"〒": {
  	math: "\\postalmark"
  },
  	"〔": {
  	math: "\\lbrbrak"
  },
  	"〕": {
  	math: "\\rbrbrak"
  },
  	"〚": {
  	math: "\\openbracketleft"
  },
  	"〛": {
  	math: "\\openbracketright"
  },
  	"〰": {
  	math: "\\hzigzag"
  },
  	"ﬀ": {
  	text: "ff"
  },
  	"ﬁ": {
  	text: "fi"
  },
  	"ﬂ": {
  	text: "fl"
  },
  	"ﬃ": {
  	text: "ffi"
  },
  	"ﬄ": {
  	text: "ffl"
  },
  	"ﬅ": {
  	text: "st"
  },
  	"ﬆ": {
  	text: "st"
  },
  	"�": {
  	text: "\\dbend",
  	commandspacer: true
  },
  	"𝐀": {
  	math: "\\mathbf{A}"
  },
  	"𝐁": {
  	math: "\\mathbf{B}"
  },
  	"𝐂": {
  	math: "\\mathbf{C}"
  },
  	"𝐃": {
  	math: "\\mathbf{D}"
  },
  	"𝐄": {
  	math: "\\mathbf{E}"
  },
  	"𝐅": {
  	math: "\\mathbf{F}"
  },
  	"𝐆": {
  	math: "\\mathbf{G}"
  },
  	"𝐇": {
  	math: "\\mathbf{H}"
  },
  	"𝐈": {
  	math: "\\mathbf{I}"
  },
  	"𝐉": {
  	math: "\\mathbf{J}"
  },
  	"𝐊": {
  	math: "\\mathbf{K}"
  },
  	"𝐋": {
  	math: "\\mathbf{L}"
  },
  	"𝐌": {
  	math: "\\mathbf{M}"
  },
  	"𝐍": {
  	math: "\\mathbf{N}"
  },
  	"𝐎": {
  	math: "\\mathbf{O}"
  },
  	"𝐏": {
  	math: "\\mathbf{P}"
  },
  	"𝐐": {
  	math: "\\mathbf{Q}"
  },
  	"𝐑": {
  	math: "\\mathbf{R}"
  },
  	"𝐒": {
  	math: "\\mathbf{S}"
  },
  	"𝐓": {
  	math: "\\mathbf{T}"
  },
  	"𝐔": {
  	math: "\\mathbf{U}"
  },
  	"𝐕": {
  	math: "\\mathbf{V}"
  },
  	"𝐖": {
  	math: "\\mathbf{W}"
  },
  	"𝐗": {
  	math: "\\mathbf{X}"
  },
  	"𝐘": {
  	math: "\\mathbf{Y}"
  },
  	"𝐙": {
  	math: "\\mathbf{Z}"
  },
  	"𝐚": {
  	math: "\\mathbf{a}"
  },
  	"𝐛": {
  	math: "\\mathbf{b}"
  },
  	"𝐜": {
  	math: "\\mathbf{c}"
  },
  	"𝐝": {
  	math: "\\mathbf{d}"
  },
  	"𝐞": {
  	math: "\\mathbf{e}"
  },
  	"𝐟": {
  	math: "\\mathbf{f}"
  },
  	"𝐠": {
  	math: "\\mathbf{g}"
  },
  	"𝐡": {
  	math: "\\mathbf{h}"
  },
  	"𝐢": {
  	math: "\\mathbf{i}"
  },
  	"𝐣": {
  	math: "\\mathbf{j}"
  },
  	"𝐤": {
  	math: "\\mathbf{k}"
  },
  	"𝐥": {
  	math: "\\mathbf{l}"
  },
  	"𝐦": {
  	math: "\\mathbf{m}"
  },
  	"𝐧": {
  	math: "\\mathbf{n}"
  },
  	"𝐨": {
  	math: "\\mathbf{o}"
  },
  	"𝐩": {
  	math: "\\mathbf{p}"
  },
  	"𝐪": {
  	math: "\\mathbf{q}"
  },
  	"𝐫": {
  	math: "\\mathbf{r}"
  },
  	"𝐬": {
  	math: "\\mathbf{s}"
  },
  	"𝐭": {
  	math: "\\mathbf{t}"
  },
  	"𝐮": {
  	math: "\\mathbf{u}"
  },
  	"𝐯": {
  	math: "\\mathbf{v}"
  },
  	"𝐰": {
  	math: "\\mathbf{w}"
  },
  	"𝐱": {
  	math: "\\mathbf{x}"
  },
  	"𝐲": {
  	math: "\\mathbf{y}"
  },
  	"𝐳": {
  	math: "\\mathbf{z}"
  },
  	"𝐴": {
  	math: "\\mathsl{A}"
  },
  	"𝐵": {
  	math: "\\mathsl{B}"
  },
  	"𝐶": {
  	math: "\\mathsl{C}"
  },
  	"𝐷": {
  	math: "\\mathsl{D}"
  },
  	"𝐸": {
  	math: "\\mathsl{E}"
  },
  	"𝐹": {
  	math: "\\mathsl{F}"
  },
  	"𝐺": {
  	math: "\\mathsl{G}"
  },
  	"𝐻": {
  	math: "\\mathsl{H}"
  },
  	"𝐼": {
  	math: "\\mathsl{I}"
  },
  	"𝐽": {
  	math: "\\mathsl{J}"
  },
  	"𝐾": {
  	math: "\\mathsl{K}"
  },
  	"𝐿": {
  	math: "\\mathsl{L}"
  },
  	"𝑀": {
  	math: "\\mathsl{M}"
  },
  	"𝑁": {
  	math: "\\mathsl{N}"
  },
  	"𝑂": {
  	math: "\\mathsl{O}"
  },
  	"𝑃": {
  	math: "\\mathsl{P}"
  },
  	"𝑄": {
  	math: "\\mathsl{Q}"
  },
  	"𝑅": {
  	math: "\\mathsl{R}"
  },
  	"𝑆": {
  	math: "\\mathsl{S}"
  },
  	"𝑇": {
  	math: "\\mathsl{T}"
  },
  	"𝑈": {
  	math: "\\mathsl{U}"
  },
  	"𝑉": {
  	math: "\\mathsl{V}"
  },
  	"𝑊": {
  	math: "\\mathsl{W}"
  },
  	"𝑋": {
  	math: "\\mathsl{X}"
  },
  	"𝑌": {
  	math: "\\mathsl{Y}"
  },
  	"𝑍": {
  	math: "\\mathsl{Z}"
  },
  	"𝑎": {
  	math: "\\mathsl{a}"
  },
  	"𝑏": {
  	math: "\\mathsl{b}"
  },
  	"𝑐": {
  	math: "\\mathsl{c}"
  },
  	"𝑑": {
  	math: "\\mathsl{d}"
  },
  	"𝑒": {
  	math: "\\mathsl{e}"
  },
  	"𝑓": {
  	math: "\\mathsl{f}"
  },
  	"𝑔": {
  	math: "\\mathsl{g}"
  },
  	"𝑖": {
  	math: "\\mathsl{i}"
  },
  	"𝑗": {
  	math: "\\mathsl{j}"
  },
  	"𝑘": {
  	math: "\\mathsl{k}"
  },
  	"𝑙": {
  	math: "\\mathsl{l}"
  },
  	"𝑚": {
  	math: "\\mathsl{m}"
  },
  	"𝑛": {
  	math: "\\mathsl{n}"
  },
  	"𝑜": {
  	math: "\\mathsl{o}"
  },
  	"𝑝": {
  	math: "\\mathsl{p}"
  },
  	"𝑞": {
  	math: "\\mathsl{q}"
  },
  	"𝑟": {
  	math: "\\mathsl{r}"
  },
  	"𝑠": {
  	math: "\\mathsl{s}"
  },
  	"𝑡": {
  	math: "\\mathsl{t}"
  },
  	"𝑢": {
  	math: "\\mathsl{u}"
  },
  	"𝑣": {
  	math: "\\mathsl{v}"
  },
  	"𝑤": {
  	math: "\\mathsl{w}"
  },
  	"𝑥": {
  	math: "\\mathsl{x}"
  },
  	"𝑦": {
  	math: "\\mathsl{y}"
  },
  	"𝑧": {
  	math: "\\mathsl{z}"
  },
  	"𝑨": {
  	math: "\\mathbit{A}"
  },
  	"𝑩": {
  	math: "\\mathbit{B}"
  },
  	"𝑪": {
  	math: "\\mathbit{C}"
  },
  	"𝑫": {
  	math: "\\mathbit{D}"
  },
  	"𝑬": {
  	math: "\\mathbit{E}"
  },
  	"𝑭": {
  	math: "\\mathbit{F}"
  },
  	"𝑮": {
  	math: "\\mathbit{G}"
  },
  	"𝑯": {
  	math: "\\mathbit{H}"
  },
  	"𝑰": {
  	math: "\\mathbit{I}"
  },
  	"𝑱": {
  	math: "\\mathbit{J}"
  },
  	"𝑲": {
  	math: "\\mathbit{K}"
  },
  	"𝑳": {
  	math: "\\mathbit{L}"
  },
  	"𝑴": {
  	math: "\\mathbit{M}"
  },
  	"𝑵": {
  	math: "\\mathbit{N}"
  },
  	"𝑶": {
  	math: "\\mathbit{O}"
  },
  	"𝑷": {
  	math: "\\mathbit{P}"
  },
  	"𝑸": {
  	math: "\\mathbit{Q}"
  },
  	"𝑹": {
  	math: "\\mathbit{R}"
  },
  	"𝑺": {
  	math: "\\mathbit{S}"
  },
  	"𝑻": {
  	math: "\\mathbit{T}"
  },
  	"𝑼": {
  	math: "\\mathbit{U}"
  },
  	"𝑽": {
  	math: "\\mathbit{V}"
  },
  	"𝑾": {
  	math: "\\mathbit{W}"
  },
  	"𝑿": {
  	math: "\\mathbit{X}"
  },
  	"𝒀": {
  	math: "\\mathbit{Y}"
  },
  	"𝒁": {
  	math: "\\mathbit{Z}"
  },
  	"𝒂": {
  	math: "\\mathbit{a}"
  },
  	"𝒃": {
  	math: "\\mathbit{b}"
  },
  	"𝒄": {
  	math: "\\mathbit{c}"
  },
  	"𝒅": {
  	math: "\\mathbit{d}"
  },
  	"𝒆": {
  	math: "\\mathbit{e}"
  },
  	"𝒇": {
  	math: "\\mathbit{f}"
  },
  	"𝒈": {
  	math: "\\mathbit{g}"
  },
  	"𝒉": {
  	math: "\\mathbit{h}"
  },
  	"𝒊": {
  	math: "\\mathbit{i}"
  },
  	"𝒋": {
  	math: "\\mathbit{j}"
  },
  	"𝒌": {
  	math: "\\mathbit{k}"
  },
  	"𝒍": {
  	math: "\\mathbit{l}"
  },
  	"𝒎": {
  	math: "\\mathbit{m}"
  },
  	"𝒏": {
  	math: "\\mathbit{n}"
  },
  	"𝒐": {
  	math: "\\mathbit{o}"
  },
  	"𝒑": {
  	math: "\\mathbit{p}"
  },
  	"𝒒": {
  	math: "\\mathbit{q}"
  },
  	"𝒓": {
  	math: "\\mathbit{r}"
  },
  	"𝒔": {
  	math: "\\mathbit{s}"
  },
  	"𝒕": {
  	math: "\\mathbit{t}"
  },
  	"𝒖": {
  	math: "\\mathbit{u}"
  },
  	"𝒗": {
  	math: "\\mathbit{v}"
  },
  	"𝒘": {
  	math: "\\mathbit{w}"
  },
  	"𝒙": {
  	math: "\\mathbit{x}"
  },
  	"𝒚": {
  	math: "\\mathbit{y}"
  },
  	"𝒛": {
  	math: "\\mathbit{z}"
  },
  	"𝒜": {
  	math: "\\mathscr{A}"
  },
  	"𝒞": {
  	math: "\\mathscr{C}"
  },
  	"𝒟": {
  	math: "\\mathscr{D}"
  },
  	"𝒢": {
  	math: "\\mathscr{G}"
  },
  	"𝒥": {
  	math: "\\mathscr{J}"
  },
  	"𝒦": {
  	math: "\\mathscr{K}"
  },
  	"𝒩": {
  	math: "\\mathscr{N}"
  },
  	"𝒪": {
  	math: "\\mathscr{O}"
  },
  	"𝒫": {
  	math: "\\mathscr{P}"
  },
  	"𝒬": {
  	math: "\\mathscr{Q}"
  },
  	"𝒮": {
  	math: "\\mathscr{S}"
  },
  	"𝒯": {
  	math: "\\mathscr{T}"
  },
  	"𝒰": {
  	math: "\\mathscr{U}"
  },
  	"𝒱": {
  	math: "\\mathscr{V}"
  },
  	"𝒲": {
  	math: "\\mathscr{W}"
  },
  	"𝒳": {
  	math: "\\mathscr{X}"
  },
  	"𝒴": {
  	math: "\\mathscr{Y}"
  },
  	"𝒵": {
  	math: "\\mathscr{Z}"
  },
  	"𝒶": {
  	math: "\\mathscr{a}"
  },
  	"𝒷": {
  	math: "\\mathscr{b}"
  },
  	"𝒸": {
  	math: "\\mathscr{c}"
  },
  	"𝒹": {
  	math: "\\mathscr{d}"
  },
  	"𝒻": {
  	math: "\\mathscr{f}"
  },
  	"𝒽": {
  	math: "\\mathscr{h}"
  },
  	"𝒾": {
  	math: "\\mathscr{i}"
  },
  	"𝒿": {
  	math: "\\mathscr{j}"
  },
  	"𝓀": {
  	math: "\\mathscr{k}"
  },
  	"𝓁": {
  	math: "\\mathscr{l}"
  },
  	"𝓂": {
  	math: "\\mathscr{m}"
  },
  	"𝓃": {
  	math: "\\mathscr{n}"
  },
  	"𝓅": {
  	math: "\\mathscr{p}"
  },
  	"𝓆": {
  	math: "\\mathscr{q}"
  },
  	"𝓇": {
  	math: "\\mathscr{r}"
  },
  	"𝓈": {
  	math: "\\mathscr{s}"
  },
  	"𝓉": {
  	math: "\\mathscr{t}"
  },
  	"𝓊": {
  	math: "\\mathscr{u}"
  },
  	"𝓋": {
  	math: "\\mathscr{v}"
  },
  	"𝓌": {
  	math: "\\mathscr{w}"
  },
  	"𝓍": {
  	math: "\\mathscr{x}"
  },
  	"𝓎": {
  	math: "\\mathscr{y}"
  },
  	"𝓏": {
  	math: "\\mathscr{z}"
  },
  	"𝓐": {
  	math: "\\mathmit{A}"
  },
  	"𝓑": {
  	math: "\\mathmit{B}"
  },
  	"𝓒": {
  	math: "\\mathmit{C}"
  },
  	"𝓓": {
  	math: "\\mathmit{D}"
  },
  	"𝓔": {
  	math: "\\mathmit{E}"
  },
  	"𝓕": {
  	math: "\\mathmit{F}"
  },
  	"𝓖": {
  	math: "\\mathmit{G}"
  },
  	"𝓗": {
  	math: "\\mathmit{H}"
  },
  	"𝓘": {
  	math: "\\mathmit{I}"
  },
  	"𝓙": {
  	math: "\\mathmit{J}"
  },
  	"𝓚": {
  	math: "\\mathmit{K}"
  },
  	"𝓛": {
  	math: "\\mathmit{L}"
  },
  	"𝓜": {
  	math: "\\mathmit{M}"
  },
  	"𝓝": {
  	math: "\\mathmit{N}"
  },
  	"𝓞": {
  	math: "\\mathmit{O}"
  },
  	"𝓟": {
  	math: "\\mathmit{P}"
  },
  	"𝓠": {
  	math: "\\mathmit{Q}"
  },
  	"𝓡": {
  	math: "\\mathmit{R}"
  },
  	"𝓢": {
  	math: "\\mathmit{S}"
  },
  	"𝓣": {
  	math: "\\mathmit{T}"
  },
  	"𝓤": {
  	math: "\\mathmit{U}"
  },
  	"𝓥": {
  	math: "\\mathmit{V}"
  },
  	"𝓦": {
  	math: "\\mathmit{W}"
  },
  	"𝓧": {
  	math: "\\mathmit{X}"
  },
  	"𝓨": {
  	math: "\\mathmit{Y}"
  },
  	"𝓩": {
  	math: "\\mathmit{Z}"
  },
  	"𝓪": {
  	math: "\\mathmit{a}"
  },
  	"𝓫": {
  	math: "\\mathmit{b}"
  },
  	"𝓬": {
  	math: "\\mathmit{c}"
  },
  	"𝓭": {
  	math: "\\mathmit{d}"
  },
  	"𝓮": {
  	math: "\\mathmit{e}"
  },
  	"𝓯": {
  	math: "\\mathmit{f}"
  },
  	"𝓰": {
  	math: "\\mathmit{g}"
  },
  	"𝓱": {
  	math: "\\mathmit{h}"
  },
  	"𝓲": {
  	math: "\\mathmit{i}"
  },
  	"𝓳": {
  	math: "\\mathmit{j}"
  },
  	"𝓴": {
  	math: "\\mathmit{k}"
  },
  	"𝓵": {
  	math: "\\mathmit{l}"
  },
  	"𝓶": {
  	math: "\\mathmit{m}"
  },
  	"𝓷": {
  	math: "\\mathmit{n}"
  },
  	"𝓸": {
  	math: "\\mathmit{o}"
  },
  	"𝓹": {
  	math: "\\mathmit{p}"
  },
  	"𝓺": {
  	math: "\\mathmit{q}"
  },
  	"𝓻": {
  	math: "\\mathmit{r}"
  },
  	"𝓼": {
  	math: "\\mathmit{s}"
  },
  	"𝓽": {
  	math: "\\mathmit{t}"
  },
  	"𝓾": {
  	math: "\\mathmit{u}"
  },
  	"𝓿": {
  	math: "\\mathmit{v}"
  },
  	"𝔀": {
  	math: "\\mathmit{w}"
  },
  	"𝔁": {
  	math: "\\mathmit{x}"
  },
  	"𝔂": {
  	math: "\\mathmit{y}"
  },
  	"𝔃": {
  	math: "\\mathmit{z}"
  },
  	"𝔄": {
  	math: "\\mathfrak{A}"
  },
  	"𝔅": {
  	math: "\\mathfrak{B}"
  },
  	"𝔇": {
  	math: "\\mathfrak{D}"
  },
  	"𝔈": {
  	math: "\\mathfrak{E}"
  },
  	"𝔉": {
  	math: "\\mathfrak{F}"
  },
  	"𝔊": {
  	math: "\\mathfrak{G}"
  },
  	"𝔍": {
  	math: "\\mathfrak{J}"
  },
  	"𝔎": {
  	math: "\\mathfrak{K}"
  },
  	"𝔏": {
  	math: "\\mathfrak{L}"
  },
  	"𝔐": {
  	math: "\\mathfrak{M}"
  },
  	"𝔑": {
  	math: "\\mathfrak{N}"
  },
  	"𝔒": {
  	math: "\\mathfrak{O}"
  },
  	"𝔓": {
  	math: "\\mathfrak{P}"
  },
  	"𝔔": {
  	math: "\\mathfrak{Q}"
  },
  	"𝔖": {
  	math: "\\mathfrak{S}"
  },
  	"𝔗": {
  	math: "\\mathfrak{T}"
  },
  	"𝔘": {
  	math: "\\mathfrak{U}"
  },
  	"𝔙": {
  	math: "\\mathfrak{V}"
  },
  	"𝔚": {
  	math: "\\mathfrak{W}"
  },
  	"𝔛": {
  	math: "\\mathfrak{X}"
  },
  	"𝔜": {
  	math: "\\mathfrak{Y}"
  },
  	"𝔞": {
  	math: "\\mathfrak{a}"
  },
  	"𝔟": {
  	math: "\\mathfrak{b}"
  },
  	"𝔠": {
  	math: "\\mathfrak{c}"
  },
  	"𝔡": {
  	math: "\\mathfrak{d}"
  },
  	"𝔢": {
  	math: "\\mathfrak{e}"
  },
  	"𝔣": {
  	math: "\\mathfrak{f}"
  },
  	"𝔤": {
  	math: "\\mathfrak{g}"
  },
  	"𝔥": {
  	math: "\\mathfrak{h}"
  },
  	"𝔦": {
  	math: "\\mathfrak{i}"
  },
  	"𝔧": {
  	math: "\\mathfrak{j}"
  },
  	"𝔨": {
  	math: "\\mathfrak{k}"
  },
  	"𝔩": {
  	math: "\\mathfrak{l}"
  },
  	"𝔪": {
  	math: "\\mathfrak{m}"
  },
  	"𝔫": {
  	math: "\\mathfrak{n}"
  },
  	"𝔬": {
  	math: "\\mathfrak{o}"
  },
  	"𝔭": {
  	math: "\\mathfrak{p}"
  },
  	"𝔮": {
  	math: "\\mathfrak{q}"
  },
  	"𝔯": {
  	math: "\\mathfrak{r}"
  },
  	"𝔰": {
  	math: "\\mathfrak{s}"
  },
  	"𝔱": {
  	math: "\\mathfrak{t}"
  },
  	"𝔲": {
  	math: "\\mathfrak{u}"
  },
  	"𝔳": {
  	math: "\\mathfrak{v}"
  },
  	"𝔴": {
  	math: "\\mathfrak{w}"
  },
  	"𝔵": {
  	math: "\\mathfrak{x}"
  },
  	"𝔶": {
  	math: "\\mathfrak{y}"
  },
  	"𝔷": {
  	math: "\\mathfrak{z}"
  },
  	"𝔸": {
  	math: "\\mathbb{A}"
  },
  	"𝔹": {
  	math: "\\mathbb{B}"
  },
  	"𝔻": {
  	math: "\\mathbb{D}"
  },
  	"𝔼": {
  	math: "\\mathbb{E}"
  },
  	"𝔽": {
  	math: "\\mathbb{F}"
  },
  	"𝔾": {
  	math: "\\mathbb{G}"
  },
  	"𝕀": {
  	math: "\\mathbb{I}"
  },
  	"𝕁": {
  	math: "\\mathbb{J}"
  },
  	"𝕂": {
  	math: "\\mathbb{K}"
  },
  	"𝕃": {
  	math: "\\mathbb{L}"
  },
  	"𝕄": {
  	math: "\\mathbb{M}"
  },
  	"𝕆": {
  	math: "\\mathbb{O}"
  },
  	"𝕊": {
  	math: "\\mathbb{S}"
  },
  	"𝕋": {
  	math: "\\mathbb{T}"
  },
  	"𝕌": {
  	math: "\\mathbb{U}"
  },
  	"𝕍": {
  	math: "\\mathbb{V}"
  },
  	"𝕎": {
  	math: "\\mathbb{W}"
  },
  	"𝕏": {
  	math: "\\mathbb{X}"
  },
  	"𝕐": {
  	math: "\\mathbb{Y}"
  },
  	"𝕒": {
  	math: "\\mathbb{a}"
  },
  	"𝕓": {
  	math: "\\mathbb{b}"
  },
  	"𝕔": {
  	math: "\\mathbb{c}"
  },
  	"𝕕": {
  	math: "\\mathbb{d}"
  },
  	"𝕖": {
  	math: "\\mathbb{e}"
  },
  	"𝕗": {
  	math: "\\mathbb{f}"
  },
  	"𝕘": {
  	math: "\\mathbb{g}"
  },
  	"𝕙": {
  	math: "\\mathbb{h}"
  },
  	"𝕚": {
  	math: "\\mathbb{i}"
  },
  	"𝕛": {
  	math: "\\mathbb{j}"
  },
  	"𝕜": {
  	math: "\\mathbb{k}"
  },
  	"𝕝": {
  	math: "\\mathbb{l}"
  },
  	"𝕞": {
  	math: "\\mathbb{m}"
  },
  	"𝕟": {
  	math: "\\mathbb{n}"
  },
  	"𝕠": {
  	math: "\\mathbb{o}"
  },
  	"𝕡": {
  	math: "\\mathbb{p}"
  },
  	"𝕢": {
  	math: "\\mathbb{q}"
  },
  	"𝕣": {
  	math: "\\mathbb{r}"
  },
  	"𝕤": {
  	math: "\\mathbb{s}"
  },
  	"𝕥": {
  	math: "\\mathbb{t}"
  },
  	"𝕦": {
  	math: "\\mathbb{u}"
  },
  	"𝕧": {
  	math: "\\mathbb{v}"
  },
  	"𝕨": {
  	math: "\\mathbb{w}"
  },
  	"𝕩": {
  	math: "\\mathbb{x}"
  },
  	"𝕪": {
  	math: "\\mathbb{y}"
  },
  	"𝕫": {
  	math: "\\mathbb{z}"
  },
  	"𝕬": {
  	math: "\\mathslbb{A}"
  },
  	"𝕭": {
  	math: "\\mathslbb{B}"
  },
  	"𝕮": {
  	math: "\\mathslbb{C}"
  },
  	"𝕯": {
  	math: "\\mathslbb{D}"
  },
  	"𝕰": {
  	math: "\\mathslbb{E}"
  },
  	"𝕱": {
  	math: "\\mathslbb{F}"
  },
  	"𝕲": {
  	math: "\\mathslbb{G}"
  },
  	"𝕳": {
  	math: "\\mathslbb{H}"
  },
  	"𝕴": {
  	math: "\\mathslbb{I}"
  },
  	"𝕵": {
  	math: "\\mathslbb{J}"
  },
  	"𝕶": {
  	math: "\\mathslbb{K}"
  },
  	"𝕷": {
  	math: "\\mathslbb{L}"
  },
  	"𝕸": {
  	math: "\\mathslbb{M}"
  },
  	"𝕹": {
  	math: "\\mathslbb{N}"
  },
  	"𝕺": {
  	math: "\\mathslbb{O}"
  },
  	"𝕻": {
  	math: "\\mathslbb{P}"
  },
  	"𝕼": {
  	math: "\\mathslbb{Q}"
  },
  	"𝕽": {
  	math: "\\mathslbb{R}"
  },
  	"𝕾": {
  	math: "\\mathslbb{S}"
  },
  	"𝕿": {
  	math: "\\mathslbb{T}"
  },
  	"𝖀": {
  	math: "\\mathslbb{U}"
  },
  	"𝖁": {
  	math: "\\mathslbb{V}"
  },
  	"𝖂": {
  	math: "\\mathslbb{W}"
  },
  	"𝖃": {
  	math: "\\mathslbb{X}"
  },
  	"𝖄": {
  	math: "\\mathslbb{Y}"
  },
  	"𝖅": {
  	math: "\\mathslbb{Z}"
  },
  	"𝖆": {
  	math: "\\mathslbb{a}"
  },
  	"𝖇": {
  	math: "\\mathslbb{b}"
  },
  	"𝖈": {
  	math: "\\mathslbb{c}"
  },
  	"𝖉": {
  	math: "\\mathslbb{d}"
  },
  	"𝖊": {
  	math: "\\mathslbb{e}"
  },
  	"𝖋": {
  	math: "\\mathslbb{f}"
  },
  	"𝖌": {
  	math: "\\mathslbb{g}"
  },
  	"𝖍": {
  	math: "\\mathslbb{h}"
  },
  	"𝖎": {
  	math: "\\mathslbb{i}"
  },
  	"𝖏": {
  	math: "\\mathslbb{j}"
  },
  	"𝖐": {
  	math: "\\mathslbb{k}"
  },
  	"𝖑": {
  	math: "\\mathslbb{l}"
  },
  	"𝖒": {
  	math: "\\mathslbb{m}"
  },
  	"𝖓": {
  	math: "\\mathslbb{n}"
  },
  	"𝖔": {
  	math: "\\mathslbb{o}"
  },
  	"𝖕": {
  	math: "\\mathslbb{p}"
  },
  	"𝖖": {
  	math: "\\mathslbb{q}"
  },
  	"𝖗": {
  	math: "\\mathslbb{r}"
  },
  	"𝖘": {
  	math: "\\mathslbb{s}"
  },
  	"𝖙": {
  	math: "\\mathslbb{t}"
  },
  	"𝖚": {
  	math: "\\mathslbb{u}"
  },
  	"𝖛": {
  	math: "\\mathslbb{v}"
  },
  	"𝖜": {
  	math: "\\mathslbb{w}"
  },
  	"𝖝": {
  	math: "\\mathslbb{x}"
  },
  	"𝖞": {
  	math: "\\mathslbb{y}"
  },
  	"𝖟": {
  	math: "\\mathslbb{z}"
  },
  	"𝖠": {
  	math: "\\mathsf{A}"
  },
  	"𝖡": {
  	math: "\\mathsf{B}"
  },
  	"𝖢": {
  	math: "\\mathsf{C}"
  },
  	"𝖣": {
  	math: "\\mathsf{D}"
  },
  	"𝖤": {
  	math: "\\mathsf{E}"
  },
  	"𝖥": {
  	math: "\\mathsf{F}"
  },
  	"𝖦": {
  	math: "\\mathsf{G}"
  },
  	"𝖧": {
  	math: "\\mathsf{H}"
  },
  	"𝖨": {
  	math: "\\mathsf{I}"
  },
  	"𝖩": {
  	math: "\\mathsf{J}"
  },
  	"𝖪": {
  	math: "\\mathsf{K}"
  },
  	"𝖫": {
  	math: "\\mathsf{L}"
  },
  	"𝖬": {
  	math: "\\mathsf{M}"
  },
  	"𝖭": {
  	math: "\\mathsf{N}"
  },
  	"𝖮": {
  	math: "\\mathsf{O}"
  },
  	"𝖯": {
  	math: "\\mathsf{P}"
  },
  	"𝖰": {
  	math: "\\mathsf{Q}"
  },
  	"𝖱": {
  	math: "\\mathsf{R}"
  },
  	"𝖲": {
  	math: "\\mathsf{S}"
  },
  	"𝖳": {
  	math: "\\mathsf{T}"
  },
  	"𝖴": {
  	math: "\\mathsf{U}"
  },
  	"𝖵": {
  	math: "\\mathsf{V}"
  },
  	"𝖶": {
  	math: "\\mathsf{W}"
  },
  	"𝖷": {
  	math: "\\mathsf{X}"
  },
  	"𝖸": {
  	math: "\\mathsf{Y}"
  },
  	"𝖹": {
  	math: "\\mathsf{Z}"
  },
  	"𝖺": {
  	math: "\\mathsf{a}"
  },
  	"𝖻": {
  	math: "\\mathsf{b}"
  },
  	"𝖼": {
  	math: "\\mathsf{c}"
  },
  	"𝖽": {
  	math: "\\mathsf{d}"
  },
  	"𝖾": {
  	math: "\\mathsf{e}"
  },
  	"𝖿": {
  	math: "\\mathsf{f}"
  },
  	"𝗀": {
  	math: "\\mathsf{g}"
  },
  	"𝗁": {
  	math: "\\mathsf{h}"
  },
  	"𝗂": {
  	math: "\\mathsf{i}"
  },
  	"𝗃": {
  	math: "\\mathsf{j}"
  },
  	"𝗄": {
  	math: "\\mathsf{k}"
  },
  	"𝗅": {
  	math: "\\mathsf{l}"
  },
  	"𝗆": {
  	math: "\\mathsf{m}"
  },
  	"𝗇": {
  	math: "\\mathsf{n}"
  },
  	"𝗈": {
  	math: "\\mathsf{o}"
  },
  	"𝗉": {
  	math: "\\mathsf{p}"
  },
  	"𝗊": {
  	math: "\\mathsf{q}"
  },
  	"𝗋": {
  	math: "\\mathsf{r}"
  },
  	"𝗌": {
  	math: "\\mathsf{s}"
  },
  	"𝗍": {
  	math: "\\mathsf{t}"
  },
  	"𝗎": {
  	math: "\\mathsf{u}"
  },
  	"𝗏": {
  	math: "\\mathsf{v}"
  },
  	"𝗐": {
  	math: "\\mathsf{w}"
  },
  	"𝗑": {
  	math: "\\mathsf{x}"
  },
  	"𝗒": {
  	math: "\\mathsf{y}"
  },
  	"𝗓": {
  	math: "\\mathsf{z}"
  },
  	"𝗔": {
  	math: "\\mathsfbf{A}"
  },
  	"𝗕": {
  	math: "\\mathsfbf{B}"
  },
  	"𝗖": {
  	math: "\\mathsfbf{C}"
  },
  	"𝗗": {
  	math: "\\mathsfbf{D}"
  },
  	"𝗘": {
  	math: "\\mathsfbf{E}"
  },
  	"𝗙": {
  	math: "\\mathsfbf{F}"
  },
  	"𝗚": {
  	math: "\\mathsfbf{G}"
  },
  	"𝗛": {
  	math: "\\mathsfbf{H}"
  },
  	"𝗜": {
  	math: "\\mathsfbf{I}"
  },
  	"𝗝": {
  	math: "\\mathsfbf{J}"
  },
  	"𝗞": {
  	math: "\\mathsfbf{K}"
  },
  	"𝗟": {
  	math: "\\mathsfbf{L}"
  },
  	"𝗠": {
  	math: "\\mathsfbf{M}"
  },
  	"𝗡": {
  	math: "\\mathsfbf{N}"
  },
  	"𝗢": {
  	math: "\\mathsfbf{O}"
  },
  	"𝗣": {
  	math: "\\mathsfbf{P}"
  },
  	"𝗤": {
  	math: "\\mathsfbf{Q}"
  },
  	"𝗥": {
  	math: "\\mathsfbf{R}"
  },
  	"𝗦": {
  	math: "\\mathsfbf{S}"
  },
  	"𝗧": {
  	math: "\\mathsfbf{T}"
  },
  	"𝗨": {
  	math: "\\mathsfbf{U}"
  },
  	"𝗩": {
  	math: "\\mathsfbf{V}"
  },
  	"𝗪": {
  	math: "\\mathsfbf{W}"
  },
  	"𝗫": {
  	math: "\\mathsfbf{X}"
  },
  	"𝗬": {
  	math: "\\mathsfbf{Y}"
  },
  	"𝗭": {
  	math: "\\mathsfbf{Z}"
  },
  	"𝗮": {
  	math: "\\mathsfbf{a}"
  },
  	"𝗯": {
  	math: "\\mathsfbf{b}"
  },
  	"𝗰": {
  	math: "\\mathsfbf{c}"
  },
  	"𝗱": {
  	math: "\\mathsfbf{d}"
  },
  	"𝗲": {
  	math: "\\mathsfbf{e}"
  },
  	"𝗳": {
  	math: "\\mathsfbf{f}"
  },
  	"𝗴": {
  	math: "\\mathsfbf{g}"
  },
  	"𝗵": {
  	math: "\\mathsfbf{h}"
  },
  	"𝗶": {
  	math: "\\mathsfbf{i}"
  },
  	"𝗷": {
  	math: "\\mathsfbf{j}"
  },
  	"𝗸": {
  	math: "\\mathsfbf{k}"
  },
  	"𝗹": {
  	math: "\\mathsfbf{l}"
  },
  	"𝗺": {
  	math: "\\mathsfbf{m}"
  },
  	"𝗻": {
  	math: "\\mathsfbf{n}"
  },
  	"𝗼": {
  	math: "\\mathsfbf{o}"
  },
  	"𝗽": {
  	math: "\\mathsfbf{p}"
  },
  	"𝗾": {
  	math: "\\mathsfbf{q}"
  },
  	"𝗿": {
  	math: "\\mathsfbf{r}"
  },
  	"𝘀": {
  	math: "\\mathsfbf{s}"
  },
  	"𝘁": {
  	math: "\\mathsfbf{t}"
  },
  	"𝘂": {
  	math: "\\mathsfbf{u}"
  },
  	"𝘃": {
  	math: "\\mathsfbf{v}"
  },
  	"𝘄": {
  	math: "\\mathsfbf{w}"
  },
  	"𝘅": {
  	math: "\\mathsfbf{x}"
  },
  	"𝘆": {
  	math: "\\mathsfbf{y}"
  },
  	"𝘇": {
  	math: "\\mathsfbf{z}"
  },
  	"𝘈": {
  	math: "\\mathsfsl{A}"
  },
  	"𝘉": {
  	math: "\\mathsfsl{B}"
  },
  	"𝘊": {
  	math: "\\mathsfsl{C}"
  },
  	"𝘋": {
  	math: "\\mathsfsl{D}"
  },
  	"𝘌": {
  	math: "\\mathsfsl{E}"
  },
  	"𝘍": {
  	math: "\\mathsfsl{F}"
  },
  	"𝘎": {
  	math: "\\mathsfsl{G}"
  },
  	"𝘏": {
  	math: "\\mathsfsl{H}"
  },
  	"𝘐": {
  	math: "\\mathsfsl{I}"
  },
  	"𝘑": {
  	math: "\\mathsfsl{J}"
  },
  	"𝘒": {
  	math: "\\mathsfsl{K}"
  },
  	"𝘓": {
  	math: "\\mathsfsl{L}"
  },
  	"𝘔": {
  	math: "\\mathsfsl{M}"
  },
  	"𝘕": {
  	math: "\\mathsfsl{N}"
  },
  	"𝘖": {
  	math: "\\mathsfsl{O}"
  },
  	"𝘗": {
  	math: "\\mathsfsl{P}"
  },
  	"𝘘": {
  	math: "\\mathsfsl{Q}"
  },
  	"𝘙": {
  	math: "\\mathsfsl{R}"
  },
  	"𝘚": {
  	math: "\\mathsfsl{S}"
  },
  	"𝘛": {
  	math: "\\mathsfsl{T}"
  },
  	"𝘜": {
  	math: "\\mathsfsl{U}"
  },
  	"𝘝": {
  	math: "\\mathsfsl{V}"
  },
  	"𝘞": {
  	math: "\\mathsfsl{W}"
  },
  	"𝘟": {
  	math: "\\mathsfsl{X}"
  },
  	"𝘠": {
  	math: "\\mathsfsl{Y}"
  },
  	"𝘡": {
  	math: "\\mathsfsl{Z}"
  },
  	"𝘢": {
  	math: "\\mathsfsl{a}"
  },
  	"𝘣": {
  	math: "\\mathsfsl{b}"
  },
  	"𝘤": {
  	math: "\\mathsfsl{c}"
  },
  	"𝘥": {
  	math: "\\mathsfsl{d}"
  },
  	"𝘦": {
  	math: "\\mathsfsl{e}"
  },
  	"𝘧": {
  	math: "\\mathsfsl{f}"
  },
  	"𝘨": {
  	math: "\\mathsfsl{g}"
  },
  	"𝘩": {
  	math: "\\mathsfsl{h}"
  },
  	"𝘪": {
  	math: "\\mathsfsl{i}"
  },
  	"𝘫": {
  	math: "\\mathsfsl{j}"
  },
  	"𝘬": {
  	math: "\\mathsfsl{k}"
  },
  	"𝘭": {
  	math: "\\mathsfsl{l}"
  },
  	"𝘮": {
  	math: "\\mathsfsl{m}"
  },
  	"𝘯": {
  	math: "\\mathsfsl{n}"
  },
  	"𝘰": {
  	math: "\\mathsfsl{o}"
  },
  	"𝘱": {
  	math: "\\mathsfsl{p}"
  },
  	"𝘲": {
  	math: "\\mathsfsl{q}"
  },
  	"𝘳": {
  	math: "\\mathsfsl{r}"
  },
  	"𝘴": {
  	math: "\\mathsfsl{s}"
  },
  	"𝘵": {
  	math: "\\mathsfsl{t}"
  },
  	"𝘶": {
  	math: "\\mathsfsl{u}"
  },
  	"𝘷": {
  	math: "\\mathsfsl{v}"
  },
  	"𝘸": {
  	math: "\\mathsfsl{w}"
  },
  	"𝘹": {
  	math: "\\mathsfsl{x}"
  },
  	"𝘺": {
  	math: "\\mathsfsl{y}"
  },
  	"𝘻": {
  	math: "\\mathsfsl{z}"
  },
  	"𝘼": {
  	math: "\\mathsfbfsl{A}"
  },
  	"𝘽": {
  	math: "\\mathsfbfsl{B}"
  },
  	"𝘾": {
  	math: "\\mathsfbfsl{C}"
  },
  	"𝘿": {
  	math: "\\mathsfbfsl{D}"
  },
  	"𝙀": {
  	math: "\\mathsfbfsl{E}"
  },
  	"𝙁": {
  	math: "\\mathsfbfsl{F}"
  },
  	"𝙂": {
  	math: "\\mathsfbfsl{G}"
  },
  	"𝙃": {
  	math: "\\mathsfbfsl{H}"
  },
  	"𝙄": {
  	math: "\\mathsfbfsl{I}"
  },
  	"𝙅": {
  	math: "\\mathsfbfsl{J}"
  },
  	"𝙆": {
  	math: "\\mathsfbfsl{K}"
  },
  	"𝙇": {
  	math: "\\mathsfbfsl{L}"
  },
  	"𝙈": {
  	math: "\\mathsfbfsl{M}"
  },
  	"𝙉": {
  	math: "\\mathsfbfsl{N}"
  },
  	"𝙊": {
  	math: "\\mathsfbfsl{O}"
  },
  	"𝙋": {
  	math: "\\mathsfbfsl{P}"
  },
  	"𝙌": {
  	math: "\\mathsfbfsl{Q}"
  },
  	"𝙍": {
  	math: "\\mathsfbfsl{R}"
  },
  	"𝙎": {
  	math: "\\mathsfbfsl{S}"
  },
  	"𝙏": {
  	math: "\\mathsfbfsl{T}"
  },
  	"𝙐": {
  	math: "\\mathsfbfsl{U}"
  },
  	"𝙑": {
  	math: "\\mathsfbfsl{V}"
  },
  	"𝙒": {
  	math: "\\mathsfbfsl{W}"
  },
  	"𝙓": {
  	math: "\\mathsfbfsl{X}"
  },
  	"𝙔": {
  	math: "\\mathsfbfsl{Y}"
  },
  	"𝙕": {
  	math: "\\mathsfbfsl{Z}"
  },
  	"𝙖": {
  	math: "\\mathsfbfsl{a}"
  },
  	"𝙗": {
  	math: "\\mathsfbfsl{b}"
  },
  	"𝙘": {
  	math: "\\mathsfbfsl{c}"
  },
  	"𝙙": {
  	math: "\\mathsfbfsl{d}"
  },
  	"𝙚": {
  	math: "\\mathsfbfsl{e}"
  },
  	"𝙛": {
  	math: "\\mathsfbfsl{f}"
  },
  	"𝙜": {
  	math: "\\mathsfbfsl{g}"
  },
  	"𝙝": {
  	math: "\\mathsfbfsl{h}"
  },
  	"𝙞": {
  	math: "\\mathsfbfsl{i}"
  },
  	"𝙟": {
  	math: "\\mathsfbfsl{j}"
  },
  	"𝙠": {
  	math: "\\mathsfbfsl{k}"
  },
  	"𝙡": {
  	math: "\\mathsfbfsl{l}"
  },
  	"𝙢": {
  	math: "\\mathsfbfsl{m}"
  },
  	"𝙣": {
  	math: "\\mathsfbfsl{n}"
  },
  	"𝙤": {
  	math: "\\mathsfbfsl{o}"
  },
  	"𝙥": {
  	math: "\\mathsfbfsl{p}"
  },
  	"𝙦": {
  	math: "\\mathsfbfsl{q}"
  },
  	"𝙧": {
  	math: "\\mathsfbfsl{r}"
  },
  	"𝙨": {
  	math: "\\mathsfbfsl{s}"
  },
  	"𝙩": {
  	math: "\\mathsfbfsl{t}"
  },
  	"𝙪": {
  	math: "\\mathsfbfsl{u}"
  },
  	"𝙫": {
  	math: "\\mathsfbfsl{v}"
  },
  	"𝙬": {
  	math: "\\mathsfbfsl{w}"
  },
  	"𝙭": {
  	math: "\\mathsfbfsl{x}"
  },
  	"𝙮": {
  	math: "\\mathsfbfsl{y}"
  },
  	"𝙯": {
  	math: "\\mathsfbfsl{z}"
  },
  	"𝙰": {
  	math: "\\mathtt{A}"
  },
  	"𝙱": {
  	math: "\\mathtt{B}"
  },
  	"𝙲": {
  	math: "\\mathtt{C}"
  },
  	"𝙳": {
  	math: "\\mathtt{D}"
  },
  	"𝙴": {
  	math: "\\mathtt{E}"
  },
  	"𝙵": {
  	math: "\\mathtt{F}"
  },
  	"𝙶": {
  	math: "\\mathtt{G}"
  },
  	"𝙷": {
  	math: "\\mathtt{H}"
  },
  	"𝙸": {
  	math: "\\mathtt{I}"
  },
  	"𝙹": {
  	math: "\\mathtt{J}"
  },
  	"𝙺": {
  	math: "\\mathtt{K}"
  },
  	"𝙻": {
  	math: "\\mathtt{L}"
  },
  	"𝙼": {
  	math: "\\mathtt{M}"
  },
  	"𝙽": {
  	math: "\\mathtt{N}"
  },
  	"𝙾": {
  	math: "\\mathtt{O}"
  },
  	"𝙿": {
  	math: "\\mathtt{P}"
  },
  	"𝚀": {
  	math: "\\mathtt{Q}"
  },
  	"𝚁": {
  	math: "\\mathtt{R}"
  },
  	"𝚂": {
  	math: "\\mathtt{S}"
  },
  	"𝚃": {
  	math: "\\mathtt{T}"
  },
  	"𝚄": {
  	math: "\\mathtt{U}"
  },
  	"𝚅": {
  	math: "\\mathtt{V}"
  },
  	"𝚆": {
  	math: "\\mathtt{W}"
  },
  	"𝚇": {
  	math: "\\mathtt{X}"
  },
  	"𝚈": {
  	math: "\\mathtt{Y}"
  },
  	"𝚉": {
  	math: "\\mathtt{Z}"
  },
  	"𝚊": {
  	math: "\\mathtt{a}"
  },
  	"𝚋": {
  	math: "\\mathtt{b}"
  },
  	"𝚌": {
  	math: "\\mathtt{c}"
  },
  	"𝚍": {
  	math: "\\mathtt{d}"
  },
  	"𝚎": {
  	math: "\\mathtt{e}"
  },
  	"𝚏": {
  	math: "\\mathtt{f}"
  },
  	"𝚐": {
  	math: "\\mathtt{g}"
  },
  	"𝚑": {
  	math: "\\mathtt{h}"
  },
  	"𝚒": {
  	math: "\\mathtt{i}"
  },
  	"𝚓": {
  	math: "\\mathtt{j}"
  },
  	"𝚔": {
  	math: "\\mathtt{k}"
  },
  	"𝚕": {
  	math: "\\mathtt{l}"
  },
  	"𝚖": {
  	math: "\\mathtt{m}"
  },
  	"𝚗": {
  	math: "\\mathtt{n}"
  },
  	"𝚘": {
  	math: "\\mathtt{o}"
  },
  	"𝚙": {
  	math: "\\mathtt{p}"
  },
  	"𝚚": {
  	math: "\\mathtt{q}"
  },
  	"𝚛": {
  	math: "\\mathtt{r}"
  },
  	"𝚜": {
  	math: "\\mathtt{s}"
  },
  	"𝚝": {
  	math: "\\mathtt{t}"
  },
  	"𝚞": {
  	math: "\\mathtt{u}"
  },
  	"𝚟": {
  	math: "\\mathtt{v}"
  },
  	"𝚠": {
  	math: "\\mathtt{w}"
  },
  	"𝚡": {
  	math: "\\mathtt{x}"
  },
  	"𝚢": {
  	math: "\\mathtt{y}"
  },
  	"𝚣": {
  	math: "\\mathtt{z}"
  },
  	"𝚤": {
  	math: "\\imath"
  },
  	"𝚥": {
  	math: "\\jmath"
  },
  	"𝚨": {
  	math: "\\mathbf{A}"
  },
  	"𝚩": {
  	math: "\\mathbf{B}"
  },
  	"𝚪": {
  	math: "\\mathbf{\\Gamma}"
  },
  	"𝚫": {
  	math: "\\mathbf{\\Delta}"
  },
  	"𝚬": {
  	math: "\\mathbf{E}"
  },
  	"𝚭": {
  	math: "\\mathbf{Z}"
  },
  	"𝚮": {
  	math: "\\mathbf{H}"
  },
  	"𝚯": {
  	math: "\\mathbf{\\Theta}"
  },
  	"𝚰": {
  	math: "\\mathbf{I}"
  },
  	"𝚱": {
  	math: "\\mathbf{K}"
  },
  	"𝚲": {
  	math: "\\mathbf{\\Lambda}"
  },
  	"𝚳": {
  	math: "M"
  },
  	"𝚴": {
  	math: "N"
  },
  	"𝚵": {
  	math: "\\mathbf{\\Xi}"
  },
  	"𝚶": {
  	math: "O"
  },
  	"𝚷": {
  	math: "\\mathbf{\\Pi}"
  },
  	"𝚸": {
  	math: "\\mathbf{P}"
  },
  	"𝚹": {
  	math: "\\mathbf{\\vartheta}"
  },
  	"𝚺": {
  	math: "\\mathbf{\\Sigma}"
  },
  	"𝚻": {
  	math: "\\mathbf{T}"
  },
  	"𝚼": {
  	math: "\\mathbf{\\Upsilon}"
  },
  	"𝚽": {
  	math: "\\mathbf{\\Phi}"
  },
  	"𝚾": {
  	math: "\\mathbf{X}"
  },
  	"𝚿": {
  	math: "\\mathbf{\\Psi}"
  },
  	"𝛀": {
  	math: "\\mathbf{\\Omega}"
  },
  	"𝛁": {
  	math: "\\mathbf{\\nabla}"
  },
  	"𝛂": {
  	math: "\\mathbf{\\alpha}"
  },
  	"𝛃": {
  	math: "\\mathbf{\\beta}"
  },
  	"𝛄": {
  	math: "\\mathbf{\\gamma}"
  },
  	"𝛅": {
  	math: "\\mathbf{\\delta}"
  },
  	"𝛆": {
  	math: "\\mathbf{\\epsilon}"
  },
  	"𝛇": {
  	math: "\\mathbf{\\zeta}"
  },
  	"𝛈": {
  	math: "\\mathbf{\\eta}"
  },
  	"𝛉": {
  	math: "\\mathbf{\\theta}"
  },
  	"𝛊": {
  	math: "\\mathbf{I}"
  },
  	"𝛋": {
  	math: "\\mathbf{K}"
  },
  	"𝛌": {
  	math: "\\mathbf{\\lambda}"
  },
  	"𝛍": {
  	math: "M"
  },
  	"𝛎": {
  	math: "N"
  },
  	"𝛏": {
  	math: "\\mathbf{\\xi}"
  },
  	"𝛐": {
  	math: "O"
  },
  	"𝛑": {
  	math: "\\mathbf{\\pi}"
  },
  	"𝛒": {
  	math: "\\mathbf{P}"
  },
  	"𝛓": {
  	math: "\\mathbf{\\varsigma}"
  },
  	"𝛔": {
  	math: "\\mathbf{\\sigma}"
  },
  	"𝛕": {
  	math: "\\mathbf{T}"
  },
  	"𝛖": {
  	math: "\\mathbf{\\upsilon}"
  },
  	"𝛗": {
  	math: "\\mathbf{\\phi}"
  },
  	"𝛘": {
  	math: "\\mathbf{X}"
  },
  	"𝛙": {
  	math: "\\mathbf{\\psi}"
  },
  	"𝛚": {
  	math: "\\mathbf{\\omega}"
  },
  	"𝛛": {
  	math: "\\partial"
  },
  	"𝛜": {
  	math: "\\in"
  },
  	"𝛝": {
  	math: "\\mathbf{\\vartheta}"
  },
  	"𝛞": {
  	math: "\\mathbf{\\varkappa}"
  },
  	"𝛟": {
  	math: "\\mathbf{\\phi}"
  },
  	"𝛠": {
  	math: "\\mathbf{\\varrho}"
  },
  	"𝛡": {
  	math: "\\mathbf{\\varpi}"
  },
  	"𝛢": {
  	math: "\\mathsl{A}"
  },
  	"𝛣": {
  	math: "\\mathsl{B}"
  },
  	"𝛤": {
  	math: "\\mathsl{\\Gamma}"
  },
  	"𝛥": {
  	math: "\\mathsl{\\Delta}"
  },
  	"𝛦": {
  	math: "\\mathsl{E}"
  },
  	"𝛧": {
  	math: "\\mathsl{Z}"
  },
  	"𝛨": {
  	math: "\\mathsl{H}"
  },
  	"𝛩": {
  	math: "\\mathsl{\\Theta}"
  },
  	"𝛪": {
  	math: "\\mathsl{I}"
  },
  	"𝛫": {
  	math: "\\mathsl{K}"
  },
  	"𝛬": {
  	math: "\\mathsl{\\Lambda}"
  },
  	"𝛭": {
  	math: "M"
  },
  	"𝛮": {
  	math: "N"
  },
  	"𝛯": {
  	math: "\\mathsl{\\Xi}"
  },
  	"𝛰": {
  	math: "O"
  },
  	"𝛱": {
  	math: "\\mathsl{\\Pi}"
  },
  	"𝛲": {
  	math: "\\mathsl{P}"
  },
  	"𝛳": {
  	math: "\\mathsl{\\Theta}"
  },
  	"𝛴": {
  	math: "\\mathsl{\\Sigma}"
  },
  	"𝛵": {
  	math: "\\mathsl{T}"
  },
  	"𝛶": {
  	math: "\\mathsl{\\Upsilon}"
  },
  	"𝛷": {
  	math: "\\mathsl{\\Phi}"
  },
  	"𝛸": {
  	math: "\\mathsl{X}"
  },
  	"𝛹": {
  	math: "\\mathsl{\\Psi}"
  },
  	"𝛺": {
  	math: "\\mathsl{\\Omega}"
  },
  	"𝛻": {
  	math: "\\mathsl{\\nabla}"
  },
  	"𝛼": {
  	math: "\\mathsl{A}"
  },
  	"𝛽": {
  	math: "\\mathsl{B}"
  },
  	"𝛾": {
  	math: "\\mathsl{\\gamma}"
  },
  	"𝛿": {
  	math: "\\mathsl{\\delta}"
  },
  	"𝜀": {
  	math: "\\mathsl{E}"
  },
  	"𝜁": {
  	math: "\\mathsl{Z}"
  },
  	"𝜂": {
  	math: "\\mathsl{H}"
  },
  	"𝜃": {
  	math: "\\mathsl{\\theta}"
  },
  	"𝜄": {
  	math: "\\mathsl{I}"
  },
  	"𝜅": {
  	math: "\\mathsl{K}"
  },
  	"𝜆": {
  	math: "\\mathsl{\\lambda}"
  },
  	"𝜇": {
  	math: "\\mu"
  },
  	"𝜈": {
  	math: "\\nu"
  },
  	"𝜉": {
  	math: "\\mathsl{\\xi}"
  },
  	"𝜊": {
  	math: "o"
  },
  	"𝜋": {
  	math: "\\mathsl{\\pi}"
  },
  	"𝜌": {
  	math: "\\mathsl{P}"
  },
  	"𝜍": {
  	math: "\\mathsl{\\varsigma}"
  },
  	"𝜎": {
  	math: "\\mathsl{\\sigma}"
  },
  	"𝜏": {
  	math: "\\mathsl{T}"
  },
  	"𝜐": {
  	math: "\\mathsl{\\upsilon}"
  },
  	"𝜑": {
  	math: "\\mathsl{\\varphi}"
  },
  	"𝜒": {
  	math: "\\mathsl{X}"
  },
  	"𝜓": {
  	math: "\\mathsl{\\psi}"
  },
  	"𝜔": {
  	math: "\\mathsl{\\omega}"
  },
  	"𝜕": {
  	math: "\\partial"
  },
  	"𝜖": {
  	math: "\\in"
  },
  	"𝜗": {
  	math: "\\mathsl{\\vartheta}"
  },
  	"𝜘": {
  	math: "\\mathsl{\\varkappa}"
  },
  	"𝜙": {
  	math: "\\mathsl{\\phi}"
  },
  	"𝜚": {
  	math: "\\mathsl{\\varrho}"
  },
  	"𝜛": {
  	math: "\\mathsl{\\varpi}"
  },
  	"𝜜": {
  	math: "\\mathbit{A}"
  },
  	"𝜝": {
  	math: "\\mathbit{B}"
  },
  	"𝜞": {
  	math: "\\mathbit{\\Gamma}"
  },
  	"𝜟": {
  	math: "\\mathbit{\\Delta}"
  },
  	"𝜠": {
  	math: "\\mathbit{E}"
  },
  	"𝜡": {
  	math: "\\mathbit{Z}"
  },
  	"𝜢": {
  	math: "\\mathbit{H}"
  },
  	"𝜣": {
  	math: "\\mathbit{\\Theta}"
  },
  	"𝜤": {
  	math: "\\mathbit{I}"
  },
  	"𝜥": {
  	math: "\\mathbit{K}"
  },
  	"𝜦": {
  	math: "\\mathbit{\\Lambda}"
  },
  	"𝜧": {
  	math: "M"
  },
  	"𝜨": {
  	math: "N"
  },
  	"𝜩": {
  	math: "\\mathbit{\\Xi}"
  },
  	"𝜪": {
  	math: "O"
  },
  	"𝜫": {
  	math: "\\mathbit{\\Pi}"
  },
  	"𝜬": {
  	math: "\\mathbit{P}"
  },
  	"𝜭": {
  	math: "\\mathbit{O}"
  },
  	"𝜮": {
  	math: "\\mathbit{\\Sigma}"
  },
  	"𝜯": {
  	math: "\\mathbit{T}"
  },
  	"𝜰": {
  	math: "\\mathbit{\\Upsilon}"
  },
  	"𝜱": {
  	math: "\\mathbit{\\Phi}"
  },
  	"𝜲": {
  	math: "\\mathbit{X}"
  },
  	"𝜳": {
  	math: "\\mathbit{\\Psi}"
  },
  	"𝜴": {
  	math: "\\mathbit{\\Omega}"
  },
  	"𝜵": {
  	math: "\\mathbit{\\nabla}"
  },
  	"𝜶": {
  	math: "\\mathbit{\\alpha}"
  },
  	"𝜷": {
  	math: "\\mathbit{\\beta}"
  },
  	"𝜸": {
  	math: "\\mathbit{\\gamma}"
  },
  	"𝜹": {
  	math: "\\mathbit{\\delta}"
  },
  	"𝜺": {
  	math: "\\mathbit{\\epsilon}"
  },
  	"𝜻": {
  	math: "\\mathbit{\\zeta}"
  },
  	"𝜼": {
  	math: "\\mathbit{\\eta}"
  },
  	"𝜽": {
  	math: "\\mathbit{\\theta}"
  },
  	"𝜾": {
  	math: "\\mathbit{\\imath}"
  },
  	"𝜿": {
  	math: "\\mathbit{\\kappa}"
  },
  	"𝝀": {
  	math: "\\mathbit{\\lambda}"
  },
  	"𝝁": {
  	math: "\\mu"
  },
  	"𝝂": {
  	math: "N"
  },
  	"𝝃": {
  	math: "\\mathbit{\\xi}"
  },
  	"𝝄": {
  	math: "O"
  },
  	"𝝅": {
  	math: "\\mathbit{\\pi}"
  },
  	"𝝆": {
  	math: "\\mathbit{\\rho}"
  },
  	"𝝇": {
  	math: "\\mathbit{\\varsigma}"
  },
  	"𝝈": {
  	math: "\\mathbit{\\sigma}"
  },
  	"𝝉": {
  	math: "\\mathbit{\\tau}"
  },
  	"𝝊": {
  	math: "\\mathbit{\\upsilon}"
  },
  	"𝝋": {
  	math: "\\mathbit{\\varphi}"
  },
  	"𝝌": {
  	math: "\\mathbit{\\chi}"
  },
  	"𝝍": {
  	math: "\\mathbit{\\psi}"
  },
  	"𝝎": {
  	math: "\\mathbit{\\omega}"
  },
  	"𝝏": {
  	math: "\\partial"
  },
  	"𝝐": {
  	math: "\\in"
  },
  	"𝝑": {
  	math: "\\mathbit{\\vartheta}"
  },
  	"𝝒": {
  	math: "\\mathbit{\\varkappa}"
  },
  	"𝝓": {
  	math: "\\mathbit{\\phi}"
  },
  	"𝝔": {
  	math: "\\mathbit{\\varrho}"
  },
  	"𝝕": {
  	math: "\\mathbit{\\varpi}"
  },
  	"𝝖": {
  	math: "\\mathsfbf{A}"
  },
  	"𝝗": {
  	math: "\\mathsfbf{B}"
  },
  	"𝝘": {
  	math: "\\mathsfbf{\\Gamma}"
  },
  	"𝝙": {
  	math: "\\mathsfbf{\\Delta}"
  },
  	"𝝚": {
  	math: "\\mathsfbf{E}"
  },
  	"𝝛": {
  	math: "\\mathsfbf{Z}"
  },
  	"𝝜": {
  	math: "\\mathsfbf{H}"
  },
  	"𝝝": {
  	math: "\\mathsfbf{\\Theta}"
  },
  	"𝝞": {
  	math: "\\mathsfbf{I}"
  },
  	"𝝟": {
  	math: "\\mathsfbf{K}"
  },
  	"𝝠": {
  	math: "\\mathsfbf{\\Lambda}"
  },
  	"𝝡": {
  	math: "M"
  },
  	"𝝢": {
  	math: "N"
  },
  	"𝝣": {
  	math: "\\mathsfbf{\\Xi}"
  },
  	"𝝤": {
  	math: "O"
  },
  	"𝝥": {
  	math: "\\mathsfbf{\\Pi}"
  },
  	"𝝦": {
  	math: "\\mathsfbf{P}"
  },
  	"𝝧": {
  	math: "\\mathsfbf{\\Theta}"
  },
  	"𝝨": {
  	math: "\\mathsfbf{\\Sigma}"
  },
  	"𝝩": {
  	math: "\\mathsfbf{T}"
  },
  	"𝝪": {
  	math: "\\mathsfbf{\\Upsilon}"
  },
  	"𝝫": {
  	math: "\\mathsfbf{\\Phi}"
  },
  	"𝝬": {
  	math: "\\mathsfbf{X}"
  },
  	"𝝭": {
  	math: "\\mathsfbf{\\Psi}"
  },
  	"𝝮": {
  	math: "\\mathsfbf{\\Omega}"
  },
  	"𝝯": {
  	math: "\\mathsfbf{\\nabla}"
  },
  	"𝝰": {
  	math: "\\mathsfbf{\\alpha}"
  },
  	"𝝱": {
  	math: "\\mathsfbf{\\beta}"
  },
  	"𝝲": {
  	math: "\\mathsfbf{\\gamma}"
  },
  	"𝝳": {
  	math: "\\mathsfbf{\\delta}"
  },
  	"𝝴": {
  	math: "\\mathsfbf{\\varepsilon}"
  },
  	"𝝵": {
  	math: "\\mathsfbf{\\zeta}"
  },
  	"𝝶": {
  	math: "\\mathsfbf{\\eta}"
  },
  	"𝝷": {
  	math: "\\mathsfbf{\\theta}"
  },
  	"𝝸": {
  	math: "\\mathsfbf{\\imath}"
  },
  	"𝝹": {
  	math: "\\mathsfbf{\\kappa}"
  },
  	"𝝺": {
  	math: "\\mathsfbf{\\lambda}"
  },
  	"𝝻": {
  	math: "\\mu"
  },
  	"𝝼": {
  	math: "\\nu"
  },
  	"𝝽": {
  	math: "\\mathsfbf{\\xi}"
  },
  	"𝝾": {
  	math: "o"
  },
  	"𝝿": {
  	math: "\\mathsfbf{\\pi}"
  },
  	"𝞀": {
  	math: "\\mathsfbf{\\rho}"
  },
  	"𝞁": {
  	math: "\\mathsfbf{\\varsigma}"
  },
  	"𝞂": {
  	math: "\\mathsfbf{\\sigma}"
  },
  	"𝞃": {
  	math: "\\mathsfbf{\\tau}"
  },
  	"𝞄": {
  	math: "\\mathsfbf{\\upsilon}"
  },
  	"𝞅": {
  	math: "\\mathsfbf{\\varphi}"
  },
  	"𝞆": {
  	math: "\\mathsfbf{\\chi}"
  },
  	"𝞇": {
  	math: "\\mathsfbf{\\psi}"
  },
  	"𝞈": {
  	math: "\\mathsfbf{\\omega}"
  },
  	"𝞉": {
  	math: "\\partial"
  },
  	"𝞊": {
  	math: "\\in"
  },
  	"𝞋": {
  	math: "\\mathsfbf{\\vartheta}"
  },
  	"𝞌": {
  	math: "\\mathsfbf{\\varkappa}"
  },
  	"𝞍": {
  	math: "\\mathsfbf{\\phi}"
  },
  	"𝞎": {
  	math: "\\mathsfbf{\\varrho}"
  },
  	"𝞏": {
  	math: "\\mathsfbf{\\varpi}"
  },
  	"𝞐": {
  	math: "\\mathsfbfsl{A}"
  },
  	"𝞑": {
  	math: "\\mathsfbfsl{B}"
  },
  	"𝞒": {
  	math: "\\mathsfbfsl{\\Gamma}"
  },
  	"𝞓": {
  	math: "\\mathsfbfsl{\\Delta}"
  },
  	"𝞔": {
  	math: "\\mathsfbfsl{E}"
  },
  	"𝞕": {
  	math: "\\mathsfbfsl{Z}"
  },
  	"𝞖": {
  	math: "\\mathsfbfsl{H}"
  },
  	"𝞗": {
  	math: "\\mathsfbfsl{\\Theta}"
  },
  	"𝞘": {
  	math: "\\mathsfbfsl{I}"
  },
  	"𝞙": {
  	math: "\\mathsfbfsl{K}"
  },
  	"𝞚": {
  	math: "\\mathsfbfsl{\\Lambda}"
  },
  	"𝞛": {
  	math: "\\mathsfbfsl{M}"
  },
  	"𝞜": {
  	math: "\\mathsfbfsl{N}"
  },
  	"𝞝": {
  	math: "\\mathsfbfsl{\\Xi}"
  },
  	"𝞞": {
  	math: "\\mathsfbfsl{O}"
  },
  	"𝞟": {
  	math: "\\mathsfbfsl{\\Pi}"
  },
  	"𝞠": {
  	math: "\\mathsfbfsl{P}"
  },
  	"𝞡": {
  	math: "\\mathsfbfsl{\\Theta}"
  },
  	"𝞢": {
  	math: "\\mathsfbfsl{\\Sigma}"
  },
  	"𝞣": {
  	math: "\\mathsfbfsl{T}"
  },
  	"𝞤": {
  	math: "\\mathsfbfsl{\\Upsilon}"
  },
  	"𝞥": {
  	math: "\\mathsfbfsl{\\Phi}"
  },
  	"𝞦": {
  	math: "\\mathsfbfsl{X}"
  },
  	"𝞧": {
  	math: "\\mathsfbfsl{\\Psi}"
  },
  	"𝞨": {
  	math: "\\mathsfbfsl{\\Omega}"
  },
  	"𝞩": {
  	math: "\\mathsfbfsl{\\nabla}"
  },
  	"𝞪": {
  	math: "\\mathsfbfsl{\\alpha}"
  },
  	"𝞫": {
  	math: "\\mathsfbfsl{\\beta}"
  },
  	"𝞬": {
  	math: "\\mathsfbfsl{\\gamma}"
  },
  	"𝞭": {
  	math: "\\mathsfbfsl{\\delta}"
  },
  	"𝞮": {
  	math: "\\mathsfbfsl{\\varepsilon}"
  },
  	"𝞯": {
  	math: "\\mathsfbfsl{\\zeta}"
  },
  	"𝞰": {
  	math: "\\mathsfbfsl{\\eta}"
  },
  	"𝞱": {
  	math: "\\mathsfbfsl{\\theta}"
  },
  	"𝞲": {
  	math: "\\mathsfbfsl{\\imath}"
  },
  	"𝞳": {
  	math: "\\mathsfbfsl{\\kappa}"
  },
  	"𝞴": {
  	math: "\\mathsfbfsl{\\lambda}"
  },
  	"𝞵": {
  	math: "\\mu"
  },
  	"𝞶": {
  	math: "\\nu"
  },
  	"𝞷": {
  	math: "\\mathsfbfsl{\\xi}"
  },
  	"𝞸": {
  	math: "o"
  },
  	"𝞹": {
  	math: "\\mathsfbfsl{\\pi}"
  },
  	"𝞺": {
  	math: "\\mathsfbfsl{\\rho}"
  },
  	"𝞻": {
  	math: "\\mathsfbfsl{\\varsigma}"
  },
  	"𝞼": {
  	math: "\\mathsfbfsl{\\sigma}"
  },
  	"𝞽": {
  	math: "\\mathsfbfsl{\\tau}"
  },
  	"𝞾": {
  	math: "\\mathsfbfsl{\\upsilon}"
  },
  	"𝞿": {
  	math: "\\mathsfbfsl{\\varphi}"
  },
  	"𝟀": {
  	math: "\\mathsfbfsl{\\chi}"
  },
  	"𝟁": {
  	math: "\\mathsfbfsl{\\psi}"
  },
  	"𝟂": {
  	math: "\\mathsfbfsl{\\omega}"
  },
  	"𝟃": {
  	math: "\\partial"
  },
  	"𝟄": {
  	math: "\\in"
  },
  	"𝟅": {
  	math: "\\mathsfbfsl{\\vartheta}"
  },
  	"𝟆": {
  	math: "\\mathsfbfsl{\\varkappa}"
  },
  	"𝟇": {
  	math: "\\mathsfbfsl{\\phi}"
  },
  	"𝟈": {
  	math: "\\mathsfbfsl{\\varrho}"
  },
  	"𝟉": {
  	math: "\\mathsfbfsl{\\varpi}"
  },
  	"𝟊": {
  	math: "\\mbfDigamma"
  },
  	"𝟋": {
  	math: "\\mbfdigamma"
  },
  	"𝟎": {
  	math: "\\mathbf{0}"
  },
  	"𝟏": {
  	math: "\\mathbf{1}"
  },
  	"𝟐": {
  	math: "\\mathbf{2}"
  },
  	"𝟑": {
  	math: "\\mathbf{3}"
  },
  	"𝟒": {
  	math: "\\mathbf{4}"
  },
  	"𝟓": {
  	math: "\\mathbf{5}"
  },
  	"𝟔": {
  	math: "\\mathbf{6}"
  },
  	"𝟕": {
  	math: "\\mathbf{7}"
  },
  	"𝟖": {
  	math: "\\mathbf{8}"
  },
  	"𝟗": {
  	math: "\\mathbf{9}"
  },
  	"𝟘": {
  	math: "\\mathbb{0}"
  },
  	"𝟙": {
  	math: "\\mathbb{1}"
  },
  	"𝟚": {
  	math: "\\mathbb{2}"
  },
  	"𝟛": {
  	math: "\\mathbb{3}"
  },
  	"𝟜": {
  	math: "\\mathbb{4}"
  },
  	"𝟝": {
  	math: "\\mathbb{5}"
  },
  	"𝟞": {
  	math: "\\mathbb{6}"
  },
  	"𝟟": {
  	math: "\\mathbb{7}"
  },
  	"𝟠": {
  	math: "\\mathbb{8}"
  },
  	"𝟡": {
  	math: "\\mathbb{9}"
  },
  	"𝟢": {
  	math: "\\mathsf{0}"
  },
  	"𝟣": {
  	math: "\\mathsf{1}"
  },
  	"𝟤": {
  	math: "\\mathsf{2}"
  },
  	"𝟥": {
  	math: "\\mathsf{3}"
  },
  	"𝟦": {
  	math: "\\mathsf{4}"
  },
  	"𝟧": {
  	math: "\\mathsf{5}"
  },
  	"𝟨": {
  	math: "\\mathsf{6}"
  },
  	"𝟩": {
  	math: "\\mathsf{7}"
  },
  	"𝟪": {
  	math: "\\mathsf{8}"
  },
  	"𝟫": {
  	math: "\\mathsf{9}"
  },
  	"𝟬": {
  	math: "\\mathsfbf{0}"
  },
  	"𝟭": {
  	math: "\\mathsfbf{1}"
  },
  	"𝟮": {
  	math: "\\mathsfbf{2}"
  },
  	"𝟯": {
  	math: "\\mathsfbf{3}"
  },
  	"𝟰": {
  	math: "\\mathsfbf{4}"
  },
  	"𝟱": {
  	math: "\\mathsfbf{5}"
  },
  	"𝟲": {
  	math: "\\mathsfbf{6}"
  },
  	"𝟳": {
  	math: "\\mathsfbf{7}"
  },
  	"𝟴": {
  	math: "\\mathsfbf{8}"
  },
  	"𝟵": {
  	math: "\\mathsfbf{9}"
  },
  	"𝟶": {
  	math: "\\mathtt{0}"
  },
  	"𝟷": {
  	math: "\\mathtt{1}"
  },
  	"𝟸": {
  	math: "\\mathtt{2}"
  },
  	"𝟹": {
  	math: "\\mathtt{3}"
  },
  	"𝟺": {
  	math: "\\mathtt{4}"
  },
  	"𝟻": {
  	math: "\\mathtt{5}"
  },
  	"𝟼": {
  	math: "\\mathtt{6}"
  },
  	"𝟽": {
  	math: "\\mathtt{7}"
  },
  	"𝟾": {
  	math: "\\mathtt{8}"
  },
  	"𝟿": {
  	math: "\\mathtt{9}"
  }
  };

  var $$1 = {
  	math: "\\$",
  	text: "\\$"
  };
  var _$1 = {
  	math: "\\_",
  	text: "\\_"
  };
  var require$$1 = {
  	"#": {
  	math: "\\#",
  	text: "\\#"
  },
  	$: $$1,
  	"%": {
  	math: "\\%",
  	text: "\\%"
  },
  	"&": {
  	math: "\\&",
  	text: "\\&"
  },
  	"/​": {
  	text: "{\\slash}"
  },
  	"<": {
  	math: "<"
  },
  	">": {
  	math: ">"
  },
  	"\\": {
  	math: "\\backslash",
  	text: "{\\textbackslash}"
  },
  	"^": {
  	math: "\\sphat",
  	text: "\\^"
  },
  	_: _$1,
  	"i︠a︡": {
  	text: "\\t{ia}"
  },
  	"{": {
  	math: "\\lbrace",
  	text: "\\{"
  },
  	"}": {
  	math: "\\rbrace",
  	text: "\\}"
  },
  	"~": {
  	math: "\\sptilde",
  	text: "{\\textasciitilde}"
  },
  	" ": {
  	math: "~",
  	space: true,
  	text: "~"
  },
  	"¡": {
  	text: "{\\textexclamdown}"
  },
  	"¢": {
  	math: "\\cent",
  	text: "{\\textcent}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"£": {
  	math: "\\pounds",
  	text: "{\\textsterling}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"¤": {
  	text: "{\\textcurrency}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"¥": {
  	math: "\\yen",
  	text: "{\\textyen}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"¦": {
  	text: "{\\textbrokenbar}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"§": {
  	text: "{\\textsection}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"¨": {
  	math: "\\spddot",
  	text: "{\\textasciidieresis}"
  },
  	"©": {
  	text: "{\\textcopyright}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"ª": {
  	text: "{\\textordfeminine}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"«": {
  	text: "{\\guillemotleft}"
  },
  	"¬": {
  	math: "\\lnot"
  },
  	"­": {
  	math: "\\-",
  	text: "\\-"
  },
  	"®": {
  	math: "\\circledR",
  	text: "{\\textregistered}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"¯": {
  	text: "{\\textasciimacron}"
  },
  	"°": {
  	math: "^\\circ",
  	text: "{\\textdegree}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"±": {
  	math: "\\pm"
  },
  	"²": {
  	math: "^{2}"
  },
  	"³": {
  	math: "^{3}"
  },
  	"´": {
  	text: "{\\textasciiacute}"
  },
  	"µ": {
  	text: "{\\textmu}"
  },
  	"¶": {
  	text: "{\\textparagraph}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"·": {
  	math: "\\cdot"
  },
  	"¸": {
  	text: "{\\c}"
  },
  	"¹": {
  	math: "^{1}"
  },
  	"º": {
  	text: "{\\textordmasculine}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"»": {
  	text: "{\\guillemotright}"
  },
  	"¼": {
  	math: "\\frac{1}{4}"
  },
  	"½": {
  	math: "\\frac{1}{2}"
  },
  	"¾": {
  	math: "\\frac{3}{4}"
  },
  	"¿": {
  	text: "{\\textquestiondown}"
  },
  	"À": {
  	text: "{\\`A}"
  },
  	"Á": {
  	text: "{\\'A}"
  },
  	"Â": {
  	text: "{\\^A}"
  },
  	"Ã": {
  	text: "{\\~A}"
  },
  	"Ä": {
  	text: "{\\\"A}"
  },
  	"Å": {
  	text: "{\\AA}"
  },
  	"Æ": {
  	text: "{\\AE}"
  },
  	"Ç": {
  	text: "{\\c C}"
  },
  	"È": {
  	text: "{\\`E}"
  },
  	"É": {
  	text: "{\\'E}"
  },
  	"Ê": {
  	text: "{\\^E}"
  },
  	"Ë": {
  	text: "{\\\"E}"
  },
  	"Ì": {
  	text: "{\\`I}"
  },
  	"Í": {
  	text: "{\\'I}"
  },
  	"Î": {
  	text: "{\\^I}"
  },
  	"Ï": {
  	text: "{\\\"I}"
  },
  	"Ð": {
  	text: "{\\DH}"
  },
  	"Ñ": {
  	text: "{\\~N}"
  },
  	"Ò": {
  	text: "{\\`O}"
  },
  	"Ó": {
  	text: "{\\'O}"
  },
  	"Ô": {
  	text: "{\\^O}"
  },
  	"Õ": {
  	text: "{\\~O}"
  },
  	"Ö": {
  	text: "{\\\"O}"
  },
  	"×": {
  	math: "\\times",
  	text: "{\\texttimes}"
  },
  	"Ø": {
  	text: "{\\O}"
  },
  	"Ù": {
  	text: "{\\`U}"
  },
  	"Ú": {
  	text: "{\\'U}"
  },
  	"Û": {
  	text: "{\\^U}"
  },
  	"Ü": {
  	text: "{\\\"U}"
  },
  	"Ý": {
  	text: "{\\'Y}"
  },
  	"Þ": {
  	text: "{\\TH}"
  },
  	"ß": {
  	text: "{\\ss}"
  },
  	"à": {
  	text: "{\\`a}"
  },
  	"á": {
  	text: "{\\'a}"
  },
  	"â": {
  	text: "{\\^a}"
  },
  	"ã": {
  	text: "{\\~a}"
  },
  	"ä": {
  	text: "{\\\"a}"
  },
  	"å": {
  	text: "{\\aa}"
  },
  	"æ": {
  	text: "{\\ae}"
  },
  	"ç": {
  	text: "{\\c c}"
  },
  	"è": {
  	text: "{\\`e}"
  },
  	"é": {
  	text: "{\\'e}"
  },
  	"ê": {
  	text: "{\\^e}"
  },
  	"ë": {
  	text: "{\\\"e}"
  },
  	"ì": {
  	text: "{\\`i}"
  },
  	"í": {
  	text: "{\\'i}"
  },
  	"î": {
  	text: "{\\^i}"
  },
  	"ï": {
  	text: "{\\\"i}"
  },
  	"ð": {
  	math: "\\eth",
  	mathpackages: [
  		"amssymb",
  		"arevmath"
  	],
  	text: "{\\dh}"
  },
  	"ñ": {
  	text: "{\\~n}"
  },
  	"ò": {
  	text: "{\\`o}"
  },
  	"ó": {
  	text: "{\\'o}"
  },
  	"ô": {
  	text: "{\\^o}"
  },
  	"õ": {
  	text: "{\\~o}"
  },
  	"ö": {
  	text: "{\\\"o}"
  },
  	"÷": {
  	math: "\\div"
  },
  	"ø": {
  	text: "{\\o}"
  },
  	"ù": {
  	text: "{\\`u}"
  },
  	"ú": {
  	text: "{\\'u}"
  },
  	"û": {
  	text: "{\\^u}"
  },
  	"ü": {
  	text: "{\\\"u}"
  },
  	"ý": {
  	text: "{\\'y}"
  },
  	"þ": {
  	text: "{\\th}"
  },
  	"ÿ": {
  	text: "{\\\"y}"
  },
  	"Ā": {
  	text: "{\\=A}"
  },
  	"ā": {
  	text: "{\\=a}"
  },
  	"Ă": {
  	text: "{\\u A}"
  },
  	"ă": {
  	text: "{\\u a}"
  },
  	"Ą": {
  	text: "{\\k{A}}"
  },
  	"ą": {
  	text: "{\\k{a}}"
  },
  	"Ć": {
  	text: "{\\'C}"
  },
  	"ć": {
  	text: "{\\'c}"
  },
  	"Ĉ": {
  	text: "{\\^C}"
  },
  	"ĉ": {
  	text: "{\\^c}"
  },
  	"Ċ": {
  	text: "{\\.C}"
  },
  	"ċ": {
  	text: "{\\.c}"
  },
  	"Č": {
  	text: "{\\v C}"
  },
  	"č": {
  	text: "{\\v c}"
  },
  	"Ď": {
  	text: "{\\v D}"
  },
  	"ď": {
  	text: "{\\v d}"
  },
  	"Đ": {
  	text: "{\\DJ}"
  },
  	"đ": {
  	text: "{\\dj}"
  },
  	"Ē": {
  	text: "{\\=E}"
  },
  	"ē": {
  	text: "{\\=e}"
  },
  	"Ĕ": {
  	text: "{\\u E}"
  },
  	"ĕ": {
  	text: "{\\u e}"
  },
  	"Ė": {
  	text: "{\\.E}"
  },
  	"ė": {
  	text: "{\\.e}"
  },
  	"Ę": {
  	text: "{\\k{E}}"
  },
  	"ę": {
  	text: "{\\k{e}}"
  },
  	"Ě": {
  	text: "{\\v E}"
  },
  	"ě": {
  	text: "{\\v e}"
  },
  	"Ĝ": {
  	text: "{\\^G}"
  },
  	"ĝ": {
  	text: "{\\^g}"
  },
  	"Ğ": {
  	text: "{\\u G}"
  },
  	"ğ": {
  	text: "{\\u g}"
  },
  	"Ġ": {
  	text: "{\\.G}"
  },
  	"ġ": {
  	text: "{\\.g}"
  },
  	"Ģ": {
  	text: "{\\c G}"
  },
  	"ģ": {
  	text: "{\\c g}"
  },
  	"Ĥ": {
  	text: "{\\^H}"
  },
  	"ĥ": {
  	text: "{\\^h}"
  },
  	"Ħ": {
  	text: "{\\fontencoding{LELA}\\selectfont\\char40}"
  },
  	"ħ": {
  	math: "\\Elzxh"
  },
  	"Ĩ": {
  	text: "{\\~I}"
  },
  	"ĩ": {
  	text: "{\\~i}"
  },
  	"Ī": {
  	text: "{\\=I}"
  },
  	"ī": {
  	text: "{\\=i}"
  },
  	"Ĭ": {
  	text: "{\\u I}"
  },
  	"ĭ": {
  	text: "{\\u \\i}"
  },
  	"Į": {
  	text: "{\\k{I}}"
  },
  	"į": {
  	text: "{\\k{i}}"
  },
  	"İ": {
  	text: "{\\.I}"
  },
  	"ı": {
  	math: "\\imath",
  	text: "{\\i}"
  },
  	"Ĳ": {
  	text: "IJ"
  },
  	"ĳ": {
  	text: "ij"
  },
  	"Ĵ": {
  	text: "{\\^J}"
  },
  	"ĵ": {
  	text: "{\\^\\j}"
  },
  	"Ķ": {
  	text: "{\\c K}"
  },
  	"ķ": {
  	text: "{\\c k}"
  },
  	"ĸ": {
  	text: "{\\fontencoding{LELA}\\selectfont\\char91}"
  },
  	"Ĺ": {
  	text: "{\\'L}"
  },
  	"ĺ": {
  	text: "{\\'l}"
  },
  	"Ļ": {
  	text: "{\\c L}"
  },
  	"ļ": {
  	text: "{\\c l}"
  },
  	"Ľ": {
  	text: "{\\v L}"
  },
  	"ľ": {
  	text: "{\\v l}"
  },
  	"Ŀ": {
  	text: "{\\fontencoding{LELA}\\selectfont\\char201}"
  },
  	"ŀ": {
  	text: "{\\fontencoding{LELA}\\selectfont\\char202}"
  },
  	"Ł": {
  	text: "{\\L}"
  },
  	"ł": {
  	text: "{\\l}"
  },
  	"Ń": {
  	text: "{\\'N}"
  },
  	"ń": {
  	text: "{\\'n}"
  },
  	"Ņ": {
  	text: "{\\c N}"
  },
  	"ņ": {
  	text: "{\\c n}"
  },
  	"Ň": {
  	text: "{\\v N}"
  },
  	"ň": {
  	text: "{\\v n}"
  },
  	"ŉ": {
  	text: "'n"
  },
  	"Ŋ": {
  	text: "{\\NG}"
  },
  	"ŋ": {
  	text: "{\\ng}"
  },
  	"Ō": {
  	text: "{\\=O}"
  },
  	"ō": {
  	text: "{\\=o}"
  },
  	"Ŏ": {
  	text: "{\\u O}"
  },
  	"ŏ": {
  	text: "{\\u o}"
  },
  	"Ő": {
  	text: "{\\H O}"
  },
  	"ő": {
  	text: "{\\H o}"
  },
  	"Œ": {
  	text: "{\\OE}"
  },
  	"œ": {
  	text: "{\\oe}"
  },
  	"Ŕ": {
  	text: "{\\'R}"
  },
  	"ŕ": {
  	text: "{\\'r}"
  },
  	"Ŗ": {
  	text: "{\\c R}"
  },
  	"ŗ": {
  	text: "{\\c r}"
  },
  	"Ř": {
  	text: "{\\v R}"
  },
  	"ř": {
  	text: "{\\v r}"
  },
  	"Ś": {
  	text: "{\\'S}"
  },
  	"ś": {
  	text: "{\\'s}"
  },
  	"Ŝ": {
  	text: "{\\^S}"
  },
  	"ŝ": {
  	text: "{\\^s}"
  },
  	"Ş": {
  	text: "{\\c S}"
  },
  	"ş": {
  	text: "{\\c s}"
  },
  	"Š": {
  	text: "{\\v S}"
  },
  	"š": {
  	text: "{\\v s}"
  },
  	"Ţ": {
  	text: "{\\c T}"
  },
  	"ţ": {
  	text: "{\\c t}"
  },
  	"Ť": {
  	text: "{\\v T}"
  },
  	"ť": {
  	text: "{\\v t}"
  },
  	"Ŧ": {
  	text: "{\\fontencoding{LELA}\\selectfont\\char47}"
  },
  	"ŧ": {
  	text: "{\\fontencoding{LELA}\\selectfont\\char63}"
  },
  	"Ũ": {
  	text: "{\\~U}"
  },
  	"ũ": {
  	text: "{\\~u}"
  },
  	"Ū": {
  	text: "{\\=U}"
  },
  	"ū": {
  	text: "{\\=u}"
  },
  	"Ŭ": {
  	text: "{\\u U}"
  },
  	"ŭ": {
  	text: "{\\u u}"
  },
  	"Ů": {
  	text: "{\\r{U}}"
  },
  	"ů": {
  	text: "{\\r{u}}"
  },
  	"Ű": {
  	text: "{\\H U}"
  },
  	"ű": {
  	text: "{\\H u}"
  },
  	"Ų": {
  	text: "{\\k{U}}"
  },
  	"ų": {
  	text: "{\\k{u}}"
  },
  	"Ŵ": {
  	text: "{\\^W}"
  },
  	"ŵ": {
  	text: "{\\^w}"
  },
  	"Ŷ": {
  	text: "{\\^Y}"
  },
  	"ŷ": {
  	text: "{\\^y}"
  },
  	"Ÿ": {
  	text: "{\\\"Y}"
  },
  	"Ź": {
  	text: "{\\'Z}"
  },
  	"ź": {
  	text: "{\\'z}"
  },
  	"Ż": {
  	text: "{\\.Z}"
  },
  	"ż": {
  	text: "{\\.z}"
  },
  	"Ž": {
  	text: "{\\v Z}"
  },
  	"ž": {
  	text: "{\\v z}"
  },
  	"ſ": {
  	text: "s"
  },
  	"ƒ": {
  	math: "f"
  },
  	"ƕ": {
  	text: "{\\texthvlig}"
  },
  	"ƞ": {
  	text: "{\\textnrleg}"
  },
  	"ƪ": {
  	text: "{\\textesh}"
  },
  	"Ƶ": {
  	math: "\\Zbar"
  },
  	"ƺ": {
  	text: "{\\fontencoding{LELA}\\selectfont\\char195}"
  },
  	"ǂ": {
  	text: "{\\textdoublepipe}"
  },
  	"Ǎ": {
  	text: "{\\v A}"
  },
  	"ǎ": {
  	text: "{\\v a}"
  },
  	"Ǐ": {
  	text: "{\\v I}"
  },
  	"ǐ": {
  	text: "{\\v i}"
  },
  	"Ǒ": {
  	text: "{\\v O}"
  },
  	"ǒ": {
  	text: "{\\v o}"
  },
  	"Ǔ": {
  	text: "{\\v U}"
  },
  	"ǔ": {
  	text: "{\\v u}"
  },
  	"Ǧ": {
  	text: "{\\v G}"
  },
  	"ǧ": {
  	text: "{\\v g}"
  },
  	"Ǩ": {
  	text: "{\\v K}"
  },
  	"ǩ": {
  	text: "{\\v k}"
  },
  	"Ǫ": {
  	text: "{\\k{O}}"
  },
  	"ǫ": {
  	text: "{\\k{o}}"
  },
  	"ǰ": {
  	text: "{\\v j}"
  },
  	"Ǵ": {
  	text: "{\\'G}"
  },
  	"ǵ": {
  	text: "{\\'g}"
  },
  	"Ȩ": {
  	text: "{\\c E}"
  },
  	"ȩ": {
  	text: "{\\c e}"
  },
  	"ȷ": {
  	math: "\\jmath"
  },
  	"ɐ": {
  	math: "\\Elztrna"
  },
  	"ɒ": {
  	math: "\\Elztrnsa"
  },
  	"ɔ": {
  	math: "\\Elzopeno"
  },
  	"ɖ": {
  	math: "\\Elzrtld"
  },
  	"ɘ": {
  	text: "{\\fontencoding{LEIP}\\selectfont\\char61}"
  },
  	"ə": {
  	math: "\\Elzschwa"
  },
  	"ɛ": {
  	math: "\\varepsilon"
  },
  	"ɡ": {
  	text: "g"
  },
  	"ɣ": {
  	math: "\\Elzpgamma"
  },
  	"ɤ": {
  	math: "\\Elzpbgam"
  },
  	"ɥ": {
  	math: "\\Elztrnh"
  },
  	"ɬ": {
  	math: "\\Elzbtdl"
  },
  	"ɭ": {
  	math: "\\Elzrtll"
  },
  	"ɯ": {
  	math: "\\Elztrnm"
  },
  	"ɰ": {
  	math: "\\Elztrnmlr"
  },
  	"ɱ": {
  	math: "\\Elzltlmr"
  },
  	"ɲ": {
  	text: "{\\Elzltln}"
  },
  	"ɳ": {
  	math: "\\Elzrtln"
  },
  	"ɷ": {
  	math: "\\Elzclomeg"
  },
  	"ɸ": {
  	text: "{\\textphi}"
  },
  	"ɹ": {
  	math: "\\Elztrnr"
  },
  	"ɺ": {
  	math: "\\Elztrnrl"
  },
  	"ɻ": {
  	math: "\\Elzrttrnr"
  },
  	"ɼ": {
  	math: "\\Elzrl"
  },
  	"ɽ": {
  	math: "\\Elzrtlr"
  },
  	"ɾ": {
  	math: "\\Elzfhr"
  },
  	"ɿ": {
  	text: "{\\fontencoding{LEIP}\\selectfont\\char202}"
  },
  	"ʂ": {
  	math: "\\Elzrtls"
  },
  	"ʃ": {
  	math: "\\Elzesh"
  },
  	"ʇ": {
  	math: "\\Elztrnt"
  },
  	"ʈ": {
  	math: "\\Elzrtlt"
  },
  	"ʊ": {
  	math: "\\Elzpupsil"
  },
  	"ʋ": {
  	math: "\\Elzpscrv"
  },
  	"ʌ": {
  	math: "\\Elzinvv"
  },
  	"ʍ": {
  	math: "\\Elzinvw"
  },
  	"ʎ": {
  	math: "\\Elztrny"
  },
  	"ʐ": {
  	math: "\\Elzrtlz"
  },
  	"ʒ": {
  	math: "\\Elzyogh"
  },
  	"ʔ": {
  	math: "\\Elzglst"
  },
  	"ʕ": {
  	math: "\\Elzreglst"
  },
  	"ʖ": {
  	math: "\\Elzinglst"
  },
  	"ʞ": {
  	text: "{\\textturnk}"
  },
  	"ʤ": {
  	math: "\\Elzdyogh"
  },
  	"ʧ": {
  	math: "\\Elztesh"
  },
  	"ʰ": {
  	math: "^{h}",
  	text: "\\textsuperscript{h}"
  },
  	"ʲ": {
  	math: "^{j}",
  	text: "\\textsuperscript{j}"
  },
  	"ʳ": {
  	math: "^{r}",
  	text: "\\textsuperscript{r}"
  },
  	"ʷ": {
  	math: "^{w}",
  	text: "\\textsuperscript{w}"
  },
  	"ʸ": {
  	math: "^{y}",
  	text: "\\textsuperscript{y}"
  },
  	"ʹ": {
  	text: "'"
  },
  	"ʻ": {
  	text: "'"
  },
  	"ʼ": {
  	text: "'"
  },
  	"ʽ": {
  	text: "'"
  },
  	"ʿ": {
  	text: "{\\lasp}",
  	textpackages: [
  		"mathscinet"
  	]
  },
  	"ˆ": {
  	text: "{\\textasciicircum}"
  },
  	"ˇ": {
  	text: "{\\textasciicaron}"
  },
  	"ˈ": {
  	math: "\\Elzverts"
  },
  	"ˉ": {
  	text: "-"
  },
  	"ˌ": {
  	math: "\\Elzverti"
  },
  	"ː": {
  	math: "\\Elzlmrk"
  },
  	"ˑ": {
  	math: "\\Elzhlmrk"
  },
  	"˒": {
  	math: "\\Elzsbrhr"
  },
  	"˓": {
  	math: "\\Elzsblhr"
  },
  	"˔": {
  	math: "\\Elzrais"
  },
  	"˕": {
  	math: "\\Elzlow"
  },
  	"˘": {
  	text: "{\\textasciibreve}"
  },
  	"˙": {
  	text: "{\\textperiodcentered}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"˚": {
  	text: "{\\r{}}"
  },
  	"˛": {
  	text: "{\\k{}}"
  },
  	"˜": {
  	text: "{\\texttildelow}"
  },
  	"˝": {
  	text: "{\\H{}}"
  },
  	"ˡ": {
  	math: "^{l}",
  	text: "\\textsuperscript{l}"
  },
  	"ˢ": {
  	math: "^{s}",
  	text: "\\textsuperscript{s}"
  },
  	"ˣ": {
  	math: "^{x}",
  	text: "\\textsuperscript{x}"
  },
  	"˥": {
  	text: "\\tone{55}"
  },
  	"˦": {
  	text: "\\tone{44}"
  },
  	"˧": {
  	text: "\\tone{33}"
  },
  	"˨": {
  	text: "\\tone{22}"
  },
  	"˩": {
  	text: "\\tone{11}"
  },
  	"̀": {
  	math: "\\grave",
  	combiningdiacritic: true,
  	text: "\\`"
  },
  	"̀̄": {
  	text: "{\\textgravemacron}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̄̀": {
  	text: "{\\textgravemacron}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̀̇": {
  	text: "{\\textgravedot}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̇̀": {
  	text: "{\\textgravedot}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"́": {
  	math: "\\acute",
  	combiningdiacritic: true,
  	text: "\\'"
  },
  	"́̄": {
  	text: "{\\textacutemacron}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̄́": {
  	text: "{\\textacutemacron}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"́̌": {
  	text: "{\\textacutewedge}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̌́": {
  	text: "{\\textacutewedge}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̂": {
  	math: "\\hat",
  	combiningdiacritic: true,
  	text: "\\^"
  },
  	"̂̇": {
  	text: "{\\textcircumdot}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̇̂": {
  	text: "{\\textcircumdot}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̃": {
  	math: "\\tilde",
  	combiningdiacritic: true,
  	text: "\\~"
  },
  	"̃̇": {
  	text: "{\\texttildedot}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̇̃": {
  	text: "{\\texttildedot}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̄": {
  	math: "\\bar",
  	combiningdiacritic: true,
  	text: "\\="
  },
  	"̅": {
  	math: "\\overline",
  	combiningdiacritic: true
  },
  	"̆": {
  	math: "\\breve",
  	combiningdiacritic: true,
  	text: "{\\u}"
  },
  	"̆̄": {
  	text: "{\\textbrevemacron}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̄̆": {
  	text: "{\\textbrevemacron}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̇": {
  	math: "\\dot",
  	combiningdiacritic: true,
  	text: "\\."
  },
  	"̇́": {
  	text: "{\\textdotacute}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"́̇": {
  	text: "{\\textdotacute}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̇̆": {
  	text: "{\\textdotbreve}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̆̇": {
  	text: "{\\textdotbreve}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̈": {
  	math: "\\ddot",
  	combiningdiacritic: true,
  	text: "\\\""
  },
  	"̉": {
  	math: "\\ovhook"
  },
  	"̊": {
  	math: "\\mathring",
  	combiningdiacritic: true,
  	text: "{\\r}"
  },
  	"̊̄": {
  	text: "{\\textringmacron}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̄̊": {
  	text: "{\\textringmacron}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̋": {
  	text: "{\\H}",
  	combiningdiacritic: true
  },
  	"̌": {
  	math: "\\check",
  	text: "{\\v}",
  	combiningdiacritic: true
  },
  	"̍": {
  	text: "{\\textvbaraccent}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̎": {
  	text: "{\\textdoublevbaraccent}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̏": {
  	text: "{\\textdoublegrave}",
  	combiningdiacritic: true
  },
  	"̐": {
  	text: "{\\textdotbreve}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̑": {
  	text: "{\\fontencoding{LECO}\\selectfont\\char177}"
  },
  	"̒": {
  	math: "\\oturnedcomma"
  },
  	"̕": {
  	math: "\\ocommatopright"
  },
  	"̖": {
  	text: "{\\textsubgrave}",
  	combiningdiacritic: true
  },
  	"̘": {
  	text: "{\\textadvancing}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̙": {
  	text: "{\\textretracting}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̚": {
  	math: "\\droang",
  	text: "{\\textcorner}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̜": {
  	text: "{\\textsublhalfring}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̝": {
  	text: "{\\textraising}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̞": {
  	text: "{\\textlowering}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̟": {
  	text: "{\\textsubplus}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̡": {
  	math: "\\Elzpalh"
  },
  	"̢": {
  	text: "{\\Elzrh}"
  },
  	"̣": {
  	text: "{\\d}",
  	combiningdiacritic: true
  },
  	"̤": {
  	text: "{\\textsubumlaut}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̥": {
  	text: "{\\textsubring}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̧": {
  	text: "{\\c}",
  	combiningdiacritic: true
  },
  	"̨": {
  	text: "{\\k}",
  	combiningdiacritic: true
  },
  	"̩": {
  	text: "{\\textsyllabic}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̪": {
  	math: "\\Elzsbbrg",
  	text: "{\\textsubbridge}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̫": {
  	text: "{\\fontencoding{LECO}\\selectfont\\char203}"
  },
  	"̬": {
  	text: "{\\textsubwedge}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̯": {
  	text: "{\\textsubarch}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̰": {
  	math: "\\utilde",
  	text: "{\\textsubtilde}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̱": {
  	math: "\\underbar",
  	combiningdiacritic: true,
  	text: "{\\textsubbar}",
  	textpackages: [
  		"tipa"
  	]
  },
  	"̲": {
  	math: "\\underline"
  },
  	"̴": {
  	text: "{\\textsuperimposetilde}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̵": {
  	text: "{\\Elzxl}"
  },
  	"̶": {
  	text: "{\\Elzbar}"
  },
  	"̷": {
  	text: "{\\fontencoding{LECO}\\selectfont\\char215}"
  },
  	"̸": {
  	math: "\\not"
  },
  	"̹": {
  	text: "{\\textsubrhalfring}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̺": {
  	text: "{\\textinvsubbridge}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̻": {
  	text: "{\\textsubsquare}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̼": {
  	text: "{\\textseagull}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"̽": {
  	text: "{\\textovercross}",
  	combiningdiacritic: true,
  	textpackages: [
  		"tipa"
  	]
  },
  	"͡": {
  	text: "{\\fontencoding{LECO}\\selectfont\\char225}"
  },
  	"ʹ": {
  	text: "'"
  },
  	"͵": {
  	text: ","
  },
  	";": {
  	text: ";"
  },
  	"Ά": {
  	text: "{\\'A}"
  },
  	"Έ": {
  	text: "{\\'E}"
  },
  	"Ή": {
  	text: "{\\'H}"
  },
  	"Ί": {
  	text: "{\\'{}I}"
  },
  	"Ό": {
  	text: "{\\'{}O}"
  },
  	"Ύ": {
  	math: "\\mathrm{'Y}"
  },
  	"Ώ": {
  	math: "\\mathrm{'\\Omega}"
  },
  	"ΐ": {
  	math: "\\acute{\\ddot{\\iota}}"
  },
  	"Α": {
  	math: "A"
  },
  	"Β": {
  	math: "B"
  },
  	"Γ": {
  	math: "\\Gamma"
  },
  	"Δ": {
  	math: "\\Delta"
  },
  	"Ε": {
  	math: "E"
  },
  	"Ζ": {
  	math: "Z"
  },
  	"Η": {
  	math: "H"
  },
  	"Θ": {
  	math: "\\Theta"
  },
  	"Ι": {
  	math: "I"
  },
  	"Κ": {
  	math: "K"
  },
  	"Λ": {
  	math: "\\Lambda"
  },
  	"Μ": {
  	math: "M"
  },
  	"Ν": {
  	math: "N"
  },
  	"Ξ": {
  	math: "\\Xi"
  },
  	"Ο": {
  	math: "O"
  },
  	"Π": {
  	math: "\\Pi"
  },
  	"Ρ": {
  	math: "P"
  },
  	"Σ": {
  	math: "\\Sigma"
  },
  	"Τ": {
  	math: "T"
  },
  	"Υ": {
  	math: "\\Upsilon"
  },
  	"Φ": {
  	math: "\\Phi"
  },
  	"Χ": {
  	math: "X"
  },
  	"Ψ": {
  	math: "\\Psi"
  },
  	"Ω": {
  	math: "\\Omega"
  },
  	"Ϊ": {
  	math: "\\mathrm{\\ddot{I}}"
  },
  	"Ϋ": {
  	math: "\\mathrm{\\ddot{Y}}"
  },
  	"ά": {
  	text: "{\\'$\\alpha$}"
  },
  	"έ": {
  	math: "\\acute{\\epsilon}"
  },
  	"ή": {
  	math: "\\acute{\\eta}"
  },
  	"ί": {
  	math: "\\acute{\\iota}"
  },
  	"ΰ": {
  	math: "\\acute{\\ddot{\\upsilon}}"
  },
  	"α": {
  	math: "\\alpha"
  },
  	"β": {
  	math: "\\beta"
  },
  	"γ": {
  	math: "\\gamma"
  },
  	"δ": {
  	math: "\\delta"
  },
  	"ε": {
  	math: "\\epsilon"
  },
  	"ζ": {
  	math: "\\zeta"
  },
  	"η": {
  	math: "\\eta"
  },
  	"θ": {
  	math: "\\theta",
  	text: "{\\texttheta}"
  },
  	"ι": {
  	math: "\\iota"
  },
  	"κ": {
  	math: "\\kappa"
  },
  	"λ": {
  	math: "\\lambda"
  },
  	"μ": {
  	math: "\\mu"
  },
  	"ν": {
  	math: "\\nu"
  },
  	"ξ": {
  	math: "\\xi"
  },
  	"ο": {
  	math: "o"
  },
  	"π": {
  	math: "\\pi"
  },
  	"ρ": {
  	math: "\\rho"
  },
  	"ς": {
  	math: "\\varsigma"
  },
  	"σ": {
  	math: "\\sigma"
  },
  	"τ": {
  	math: "\\tau"
  },
  	"υ": {
  	math: "\\upsilon"
  },
  	"φ": {
  	math: "\\varphi"
  },
  	"χ": {
  	math: "\\chi"
  },
  	"ψ": {
  	math: "\\psi"
  },
  	"ω": {
  	math: "\\omega"
  },
  	"ϊ": {
  	math: "\\ddot{\\iota}"
  },
  	"ϋ": {
  	math: "\\ddot{\\upsilon}"
  },
  	"ό": {
  	text: "{\\'o}"
  },
  	"ύ": {
  	math: "\\acute{\\upsilon}"
  },
  	"ώ": {
  	math: "\\acute{\\omega}"
  },
  	"ϐ": {
  	math: "\\varbeta",
  	text: "\\Pisymbol{ppi022}{87}"
  },
  	"ϑ": {
  	math: "\\vartheta",
  	text: "{\\textvartheta}"
  },
  	"ϒ": {
  	math: "\\Upsilon"
  },
  	"ϕ": {
  	math: "\\phi"
  },
  	"ϖ": {
  	math: "\\varpi"
  },
  	"Ϙ": {
  	math: "\\Qoppa"
  },
  	"ϙ": {
  	math: "\\qoppa"
  },
  	"Ϛ": {
  	math: "\\Stigma"
  },
  	"ϛ": {
  	math: "\\stigma"
  },
  	"Ϝ": {
  	math: "\\Digamma"
  },
  	"ϝ": {
  	math: "\\digamma"
  },
  	"Ϟ": {
  	math: "\\Koppa"
  },
  	"ϟ": {
  	math: "\\koppa"
  },
  	"Ϡ": {
  	math: "\\Sampi"
  },
  	"ϡ": {
  	math: "\\sampi"
  },
  	"ϰ": {
  	math: "\\varkappa"
  },
  	"ϱ": {
  	math: "\\varrho"
  },
  	"ϴ": {
  	math: "\\upvarTheta",
  	text: "{\\textTheta}"
  },
  	"ϵ": {
  	math: "\\epsilon"
  },
  	"϶": {
  	math: "\\backepsilon"
  },
  	"Ё": {
  	text: "{\\cyrchar\\CYRYO}"
  },
  	"Ђ": {
  	text: "{\\cyrchar\\CYRDJE}"
  },
  	"Ѓ": {
  	text: "{\\cyrchar{\\'\\CYRG}}"
  },
  	"Є": {
  	text: "{\\cyrchar\\CYRIE}"
  },
  	"Ѕ": {
  	text: "{\\cyrchar\\CYRDZE}"
  },
  	"І": {
  	text: "{\\cyrchar\\CYRII}"
  },
  	"Ї": {
  	text: "{\\cyrchar\\CYRYI}"
  },
  	"Ј": {
  	text: "{\\cyrchar\\CYRJE}"
  },
  	"Љ": {
  	text: "{\\cyrchar\\CYRLJE}"
  },
  	"Њ": {
  	text: "{\\cyrchar\\CYRNJE}"
  },
  	"Ћ": {
  	text: "{\\cyrchar\\CYRTSHE}"
  },
  	"Ќ": {
  	text: "{\\cyrchar{\\'\\CYRK}}"
  },
  	"Ў": {
  	text: "{\\cyrchar\\CYRUSHRT}"
  },
  	"Џ": {
  	text: "{\\cyrchar\\CYRDZHE}"
  },
  	"А": {
  	text: "{\\cyrchar\\CYRA}"
  },
  	"Б": {
  	text: "{\\cyrchar\\CYRB}"
  },
  	"В": {
  	text: "{\\cyrchar\\CYRV}"
  },
  	"Г": {
  	text: "{\\cyrchar\\CYRG}"
  },
  	"Д": {
  	text: "{\\cyrchar\\CYRD}"
  },
  	"Е": {
  	text: "{\\cyrchar\\CYRE}"
  },
  	"Ж": {
  	text: "{\\cyrchar\\CYRZH}"
  },
  	"З": {
  	text: "{\\cyrchar\\CYRZ}"
  },
  	"И": {
  	text: "{\\cyrchar\\CYRI}"
  },
  	"Й": {
  	text: "{\\cyrchar\\CYRISHRT}"
  },
  	"К": {
  	text: "{\\cyrchar\\CYRK}"
  },
  	"Л": {
  	text: "{\\cyrchar\\CYRL}"
  },
  	"М": {
  	text: "{\\cyrchar\\CYRM}"
  },
  	"Н": {
  	text: "{\\cyrchar\\CYRN}"
  },
  	"О": {
  	text: "{\\cyrchar\\CYRO}"
  },
  	"П": {
  	text: "{\\cyrchar\\CYRP}"
  },
  	"Р": {
  	text: "{\\cyrchar\\CYRR}"
  },
  	"С": {
  	text: "{\\cyrchar\\CYRS}"
  },
  	"Т": {
  	text: "{\\cyrchar\\CYRT}"
  },
  	"У": {
  	text: "{\\cyrchar\\CYRU}"
  },
  	"Ф": {
  	text: "{\\cyrchar\\CYRF}"
  },
  	"Х": {
  	text: "{\\cyrchar\\CYRH}"
  },
  	"Ц": {
  	text: "{\\cyrchar\\CYRC}"
  },
  	"Ч": {
  	text: "{\\cyrchar\\CYRCH}"
  },
  	"Ш": {
  	text: "{\\cyrchar\\CYRSH}"
  },
  	"Щ": {
  	text: "{\\cyrchar\\CYRSHCH}"
  },
  	"Ъ": {
  	text: "{\\cyrchar\\CYRHRDSN}"
  },
  	"Ы": {
  	text: "{\\cyrchar\\CYRERY}"
  },
  	"Ь": {
  	text: "{\\cyrchar\\CYRSFTSN}"
  },
  	"Э": {
  	text: "{\\cyrchar\\CYREREV}"
  },
  	"Ю": {
  	text: "{\\cyrchar\\CYRYU}"
  },
  	"Я": {
  	text: "{\\cyrchar\\CYRYA}"
  },
  	"а": {
  	text: "{\\cyrchar\\cyra}"
  },
  	"б": {
  	text: "{\\cyrchar\\cyrb}"
  },
  	"в": {
  	text: "{\\cyrchar\\cyrv}"
  },
  	"г": {
  	text: "{\\cyrchar\\cyrg}"
  },
  	"д": {
  	text: "{\\cyrchar\\cyrd}"
  },
  	"е": {
  	text: "{\\cyrchar\\cyre}"
  },
  	"ж": {
  	text: "{\\cyrchar\\cyrzh}"
  },
  	"з": {
  	text: "{\\cyrchar\\cyrz}"
  },
  	"и": {
  	text: "{\\cyrchar\\cyri}"
  },
  	"й": {
  	text: "{\\cyrchar\\cyrishrt}"
  },
  	"к": {
  	text: "{\\cyrchar\\cyrk}"
  },
  	"л": {
  	text: "{\\cyrchar\\cyrl}"
  },
  	"м": {
  	text: "{\\cyrchar\\cyrm}"
  },
  	"н": {
  	text: "{\\cyrchar\\cyrn}"
  },
  	"о": {
  	text: "{\\cyrchar\\cyro}"
  },
  	"п": {
  	text: "{\\cyrchar\\cyrp}"
  },
  	"р": {
  	text: "{\\cyrchar\\cyrr}"
  },
  	"с": {
  	text: "{\\cyrchar\\cyrs}"
  },
  	"т": {
  	text: "{\\cyrchar\\cyrt}"
  },
  	"у": {
  	text: "{\\cyrchar\\cyru}"
  },
  	"ф": {
  	text: "{\\cyrchar\\cyrf}"
  },
  	"х": {
  	text: "{\\cyrchar\\cyrh}"
  },
  	"ц": {
  	text: "{\\cyrchar\\cyrc}"
  },
  	"ч": {
  	text: "{\\cyrchar\\cyrch}"
  },
  	"ш": {
  	text: "{\\cyrchar\\cyrsh}"
  },
  	"щ": {
  	text: "{\\cyrchar\\cyrshch}"
  },
  	"ъ": {
  	text: "{\\cyrchar\\cyrhrdsn}"
  },
  	"ы": {
  	text: "{\\cyrchar\\cyrery}"
  },
  	"ь": {
  	text: "{\\cyrchar\\cyrsftsn}"
  },
  	"э": {
  	text: "{\\cyrchar\\cyrerev}"
  },
  	"ю": {
  	text: "{\\cyrchar\\cyryu}"
  },
  	"я": {
  	text: "{\\cyrchar\\cyrya}"
  },
  	"ё": {
  	text: "{\\cyrchar\\cyryo}"
  },
  	"ђ": {
  	text: "{\\cyrchar\\cyrdje}"
  },
  	"ѓ": {
  	text: "{\\cyrchar{\\'\\cyrg}}"
  },
  	"є": {
  	text: "{\\cyrchar\\cyrie}"
  },
  	"ѕ": {
  	text: "{\\cyrchar\\cyrdze}"
  },
  	"і": {
  	text: "{\\cyrchar\\cyrii}"
  },
  	"ї": {
  	text: "{\\cyrchar\\cyryi}"
  },
  	"ј": {
  	text: "{\\cyrchar\\cyrje}"
  },
  	"љ": {
  	text: "{\\cyrchar\\cyrlje}"
  },
  	"њ": {
  	text: "{\\cyrchar\\cyrnje}"
  },
  	"ћ": {
  	text: "{\\cyrchar\\cyrtshe}"
  },
  	"ќ": {
  	text: "{\\cyrchar{\\'\\cyrk}}"
  },
  	"ў": {
  	text: "{\\cyrchar\\cyrushrt}"
  },
  	"џ": {
  	text: "{\\cyrchar\\cyrdzhe}"
  },
  	"Ѡ": {
  	text: "{\\cyrchar\\CYROMEGA}"
  },
  	"ѡ": {
  	text: "{\\cyrchar\\cyromega}"
  },
  	"Ѣ": {
  	text: "{\\cyrchar\\CYRYAT}"
  },
  	"Ѥ": {
  	text: "{\\cyrchar\\CYRIOTE}"
  },
  	"ѥ": {
  	text: "{\\cyrchar\\cyriote}"
  },
  	"Ѧ": {
  	text: "{\\cyrchar\\CYRLYUS}"
  },
  	"ѧ": {
  	text: "{\\cyrchar\\cyrlyus}"
  },
  	"Ѩ": {
  	text: "{\\cyrchar\\CYRIOTLYUS}"
  },
  	"ѩ": {
  	text: "{\\cyrchar\\cyriotlyus}"
  },
  	"Ѫ": {
  	text: "{\\cyrchar\\CYRBYUS}"
  },
  	"Ѭ": {
  	text: "{\\cyrchar\\CYRIOTBYUS}"
  },
  	"ѭ": {
  	text: "{\\cyrchar\\cyriotbyus}"
  },
  	"Ѯ": {
  	text: "{\\cyrchar\\CYRKSI}"
  },
  	"ѯ": {
  	text: "{\\cyrchar\\cyrksi}"
  },
  	"Ѱ": {
  	text: "{\\cyrchar\\CYRPSI}"
  },
  	"ѱ": {
  	text: "{\\cyrchar\\cyrpsi}"
  },
  	"Ѳ": {
  	text: "{\\cyrchar\\CYRFITA}"
  },
  	"Ѵ": {
  	text: "{\\cyrchar\\CYRIZH}"
  },
  	"Ѹ": {
  	text: "{\\cyrchar\\CYRUK}"
  },
  	"ѹ": {
  	text: "{\\cyrchar\\cyruk}"
  },
  	"Ѻ": {
  	text: "{\\cyrchar\\CYROMEGARND}"
  },
  	"ѻ": {
  	text: "{\\cyrchar\\cyromegarnd}"
  },
  	"Ѽ": {
  	text: "{\\cyrchar\\CYROMEGATITLO}"
  },
  	"ѽ": {
  	text: "{\\cyrchar\\cyromegatitlo}"
  },
  	"Ѿ": {
  	text: "{\\cyrchar\\CYROT}"
  },
  	"ѿ": {
  	text: "{\\cyrchar\\cyrot}"
  },
  	"Ҁ": {
  	text: "{\\cyrchar\\CYRKOPPA}"
  },
  	"ҁ": {
  	text: "{\\cyrchar\\cyrkoppa}"
  },
  	"҂": {
  	text: "{\\cyrchar\\cyrthousands}"
  },
  	"҈": {
  	text: "{\\cyrchar\\cyrhundredthousands}"
  },
  	"҉": {
  	text: "{\\cyrchar\\cyrmillions}"
  },
  	"Ҍ": {
  	text: "{\\cyrchar\\CYRSEMISFTSN}"
  },
  	"ҍ": {
  	text: "{\\cyrchar\\cyrsemisftsn}"
  },
  	"Ҏ": {
  	text: "{\\cyrchar\\CYRRTICK}"
  },
  	"ҏ": {
  	text: "{\\cyrchar\\cyrrtick}"
  },
  	"Ґ": {
  	text: "{\\cyrchar\\CYRGUP}"
  },
  	"ґ": {
  	text: "{\\cyrchar\\cyrgup}"
  },
  	"Ғ": {
  	text: "{\\cyrchar\\CYRGHCRS}"
  },
  	"ғ": {
  	text: "{\\cyrchar\\cyrghcrs}"
  },
  	"Ҕ": {
  	text: "{\\cyrchar\\CYRGHK}"
  },
  	"ҕ": {
  	text: "{\\cyrchar\\cyrghk}"
  },
  	"Җ": {
  	text: "{\\cyrchar\\CYRZHDSC}"
  },
  	"җ": {
  	text: "{\\cyrchar\\cyrzhdsc}"
  },
  	"Ҙ": {
  	text: "{\\cyrchar\\CYRZDSC}"
  },
  	"ҙ": {
  	text: "{\\cyrchar\\cyrzdsc}"
  },
  	"Қ": {
  	text: "{\\cyrchar\\CYRKDSC}"
  },
  	"қ": {
  	text: "{\\cyrchar\\cyrkdsc}"
  },
  	"Ҝ": {
  	text: "{\\cyrchar\\CYRKVCRS}"
  },
  	"ҝ": {
  	text: "{\\cyrchar\\cyrkvcrs}"
  },
  	"Ҟ": {
  	text: "{\\cyrchar\\CYRKHCRS}"
  },
  	"ҟ": {
  	text: "{\\cyrchar\\cyrkhcrs}"
  },
  	"Ҡ": {
  	text: "{\\cyrchar\\CYRKBEAK}"
  },
  	"ҡ": {
  	text: "{\\cyrchar\\cyrkbeak}"
  },
  	"Ң": {
  	text: "{\\cyrchar\\CYRNDSC}"
  },
  	"ң": {
  	text: "{\\cyrchar\\cyrndsc}"
  },
  	"Ҥ": {
  	text: "{\\cyrchar\\CYRNG}"
  },
  	"ҥ": {
  	text: "{\\cyrchar\\cyrng}"
  },
  	"Ҧ": {
  	text: "{\\cyrchar\\CYRPHK}"
  },
  	"ҧ": {
  	text: "{\\cyrchar\\cyrphk}"
  },
  	"Ҩ": {
  	text: "{\\cyrchar\\CYRABHHA}"
  },
  	"ҩ": {
  	text: "{\\cyrchar\\cyrabhha}"
  },
  	"Ҫ": {
  	text: "{\\cyrchar\\CYRSDSC}"
  },
  	"ҫ": {
  	text: "{\\cyrchar\\cyrsdsc}"
  },
  	"Ҭ": {
  	text: "{\\cyrchar\\CYRTDSC}"
  },
  	"ҭ": {
  	text: "{\\cyrchar\\cyrtdsc}"
  },
  	"Ү": {
  	text: "{\\cyrchar\\CYRY}"
  },
  	"ү": {
  	text: "{\\cyrchar\\cyry}"
  },
  	"Ұ": {
  	text: "{\\cyrchar\\CYRYHCRS}"
  },
  	"ұ": {
  	text: "{\\cyrchar\\cyryhcrs}"
  },
  	"Ҳ": {
  	text: "{\\cyrchar\\CYRHDSC}"
  },
  	"ҳ": {
  	text: "{\\cyrchar\\cyrhdsc}"
  },
  	"Ҵ": {
  	text: "{\\cyrchar\\CYRTETSE}"
  },
  	"ҵ": {
  	text: "{\\cyrchar\\cyrtetse}"
  },
  	"Ҷ": {
  	text: "{\\cyrchar\\CYRCHRDSC}"
  },
  	"ҷ": {
  	text: "{\\cyrchar\\cyrchrdsc}"
  },
  	"Ҹ": {
  	text: "{\\cyrchar\\CYRCHVCRS}"
  },
  	"ҹ": {
  	text: "{\\cyrchar\\cyrchvcrs}"
  },
  	"Һ": {
  	text: "{\\cyrchar\\CYRSHHA}"
  },
  	"һ": {
  	text: "{\\cyrchar\\cyrshha}"
  },
  	"Ҽ": {
  	text: "{\\cyrchar\\CYRABHCH}"
  },
  	"ҽ": {
  	text: "{\\cyrchar\\cyrabhch}"
  },
  	"Ҿ": {
  	text: "{\\cyrchar\\CYRABHCHDSC}"
  },
  	"ҿ": {
  	text: "{\\cyrchar\\cyrabhchdsc}"
  },
  	"Ӏ": {
  	text: "{\\cyrchar\\CYRpalochka}"
  },
  	"Ӄ": {
  	text: "{\\cyrchar\\CYRKHK}"
  },
  	"ӄ": {
  	text: "{\\cyrchar\\cyrkhk}"
  },
  	"Ӈ": {
  	text: "{\\cyrchar\\CYRNHK}"
  },
  	"ӈ": {
  	text: "{\\cyrchar\\cyrnhk}"
  },
  	"Ӌ": {
  	text: "{\\cyrchar\\CYRCHLDSC}"
  },
  	"ӌ": {
  	text: "{\\cyrchar\\cyrchldsc}"
  },
  	"Ӕ": {
  	text: "{\\cyrchar\\CYRAE}"
  },
  	"ӕ": {
  	text: "{\\cyrchar\\cyrae}"
  },
  	"Ә": {
  	text: "{\\cyrchar\\CYRSCHWA}"
  },
  	"ә": {
  	text: "{\\cyrchar\\cyrschwa}"
  },
  	"Ӡ": {
  	text: "{\\cyrchar\\CYRABHDZE}"
  },
  	"ӡ": {
  	text: "{\\cyrchar\\cyrabhdze}"
  },
  	"Ө": {
  	text: "{\\cyrchar\\CYROTLD}"
  },
  	"ө": {
  	text: "{\\cyrchar\\cyrotld}"
  },
  	"ࡱ": {
  	math: "\\\\backslash"
  },
  	"ᵃ": {
  	math: "^{a}",
  	text: "\\textsuperscript{a}"
  },
  	"ᵇ": {
  	math: "^{b}",
  	text: "\\textsuperscript{b}"
  },
  	"ᵈ": {
  	math: "^{d}",
  	text: "\\textsuperscript{d}"
  },
  	"ᵉ": {
  	math: "^{e}",
  	text: "\\textsuperscript{e}"
  },
  	"ᵍ": {
  	math: "^{g}",
  	text: "\\textsuperscript{g}"
  },
  	"ᵏ": {
  	math: "^{k}",
  	text: "\\textsuperscript{k}"
  },
  	"ᵐ": {
  	math: "^{m}",
  	text: "\\textsuperscript{m}"
  },
  	"ᵒ": {
  	math: "^{o}",
  	text: "\\textsuperscript{o}"
  },
  	"ᵖ": {
  	math: "^{p}",
  	text: "\\textsuperscript{p}"
  },
  	"ᵗ": {
  	math: "^{t}",
  	text: "\\textsuperscript{t}"
  },
  	"ᵘ": {
  	math: "^{u}",
  	text: "\\textsuperscript{u}"
  },
  	"ᵛ": {
  	math: "^{v}",
  	text: "\\textsuperscript{v}"
  },
  	"ᶜ": {
  	math: "^{c}",
  	text: "\\textsuperscript{c}"
  },
  	"ᶠ": {
  	math: "^{f}",
  	text: "\\textsuperscript{f}"
  },
  	"ᶻ": {
  	math: "^{z}",
  	text: "\\textsuperscript{z}"
  },
  	"Ḃ": {
  	text: "{\\.B}"
  },
  	"ḃ": {
  	text: "{\\.b}"
  },
  	"Ḅ": {
  	text: "{\\d B}"
  },
  	"ḅ": {
  	text: "{\\d b}"
  },
  	"Ḇ": {
  	text: "{\\b B}"
  },
  	"ḇ": {
  	text: "{\\b b}"
  },
  	"Ḋ": {
  	text: "{\\.D}"
  },
  	"ḋ": {
  	text: "{\\.d}"
  },
  	"Ḍ": {
  	text: "{\\d D}"
  },
  	"ḍ": {
  	text: "{\\d d}"
  },
  	"Ḏ": {
  	text: "{\\b D}"
  },
  	"ḏ": {
  	text: "{\\b d}"
  },
  	"Ḑ": {
  	text: "{\\c D}"
  },
  	"ḑ": {
  	text: "{\\c d}"
  },
  	"Ḝ": {
  	text: "{\\c{\\u{E}}}"
  },
  	"ḝ": {
  	text: "{\\c{\\u{e}}}"
  },
  	"Ḟ": {
  	text: "{\\.F}"
  },
  	"ḟ": {
  	text: "{\\.f}"
  },
  	"Ḡ": {
  	text: "{\\=G}"
  },
  	"ḡ": {
  	text: "{\\=g}"
  },
  	"Ḣ": {
  	text: "{\\.H}"
  },
  	"ḣ": {
  	text: "{\\.h}"
  },
  	"Ḥ": {
  	text: "{\\d H}"
  },
  	"ḥ": {
  	text: "{\\d h}"
  },
  	"Ḧ": {
  	text: "{\\\"H}"
  },
  	"ḧ": {
  	text: "{\\\"h}"
  },
  	"Ḩ": {
  	text: "{\\c H}"
  },
  	"ḩ": {
  	text: "{\\c h}"
  },
  	"Ḱ": {
  	text: "{\\'K}"
  },
  	"ḱ": {
  	text: "{\\'k}"
  },
  	"Ḳ": {
  	text: "{\\d K}"
  },
  	"ḳ": {
  	text: "{\\d k}"
  },
  	"Ḵ": {
  	text: "{\\b K}"
  },
  	"ḵ": {
  	text: "{\\b k}"
  },
  	"Ḷ": {
  	text: "{\\d L}"
  },
  	"ḷ": {
  	text: "{\\d l}"
  },
  	"Ḻ": {
  	text: "{\\b L}"
  },
  	"ḻ": {
  	text: "{\\b l}"
  },
  	"Ḿ": {
  	text: "{\\'M}"
  },
  	"ḿ": {
  	text: "{\\'m}"
  },
  	"Ṁ": {
  	text: "{\\.M}"
  },
  	"ṁ": {
  	text: "{\\.m}"
  },
  	"Ṃ": {
  	text: "{\\d M}"
  },
  	"ṃ": {
  	text: "{\\d m}"
  },
  	"Ṅ": {
  	text: "{\\.N}"
  },
  	"ṅ": {
  	text: "{\\.n}"
  },
  	"Ṇ": {
  	text: "{\\d N}"
  },
  	"ṇ": {
  	text: "{\\d n}"
  },
  	"Ṉ": {
  	text: "{\\b N}"
  },
  	"ṉ": {
  	text: "{\\b n}"
  },
  	"Ṕ": {
  	text: "{\\'P}"
  },
  	"ṕ": {
  	text: "{\\'p}"
  },
  	"Ṗ": {
  	text: "{\\.P}"
  },
  	"ṗ": {
  	text: "{\\.p}"
  },
  	"Ṙ": {
  	text: "{\\.R}"
  },
  	"ṙ": {
  	text: "{\\.r}"
  },
  	"Ṛ": {
  	text: "{\\d R}"
  },
  	"ṛ": {
  	text: "{\\d r}"
  },
  	"Ṟ": {
  	text: "{\\b R}"
  },
  	"ṟ": {
  	text: "{\\b r}"
  },
  	"Ṡ": {
  	text: "{\\.S}"
  },
  	"ṡ": {
  	text: "{\\.s}"
  },
  	"Ṣ": {
  	text: "{\\d S}"
  },
  	"ṣ": {
  	text: "{\\d s}"
  },
  	"Ṫ": {
  	text: "{\\.T}"
  },
  	"ṫ": {
  	text: "{\\.t}"
  },
  	"Ṭ": {
  	text: "{\\d T}"
  },
  	"ṭ": {
  	text: "{\\d t}"
  },
  	"Ṯ": {
  	text: "{\\b T}"
  },
  	"ṯ": {
  	text: "{\\b t}"
  },
  	"Ṽ": {
  	text: "{\\~V}"
  },
  	"ṽ": {
  	text: "{\\~v}"
  },
  	"Ṿ": {
  	text: "{\\d V}"
  },
  	"ṿ": {
  	text: "{\\d v}"
  },
  	"Ẁ": {
  	text: "{\\`W}"
  },
  	"ẁ": {
  	text: "{\\`w}"
  },
  	"Ẃ": {
  	text: "{\\'W}"
  },
  	"ẃ": {
  	text: "{\\'w}"
  },
  	"Ẅ": {
  	text: "{\\\"W}"
  },
  	"ẅ": {
  	text: "{\\\"w}"
  },
  	"Ẇ": {
  	text: "{\\.W}"
  },
  	"ẇ": {
  	text: "{\\.w}"
  },
  	"Ẉ": {
  	text: "{\\d W}"
  },
  	"ẉ": {
  	text: "{\\d w}"
  },
  	"Ẋ": {
  	text: "{\\.X}"
  },
  	"ẋ": {
  	text: "{\\.x}"
  },
  	"Ẍ": {
  	text: "{\\\"X}"
  },
  	"ẍ": {
  	text: "{\\\"x}"
  },
  	"Ẏ": {
  	text: "{\\.Y}"
  },
  	"ẏ": {
  	text: "{\\.y}"
  },
  	"Ẑ": {
  	text: "{\\^Z}"
  },
  	"ẑ": {
  	text: "{\\^z}"
  },
  	"Ẓ": {
  	text: "{\\d Z}"
  },
  	"ẓ": {
  	text: "{\\d z}"
  },
  	"Ẕ": {
  	text: "{\\b Z}"
  },
  	"ẕ": {
  	text: "{\\b z}"
  },
  	"ẖ": {
  	text: "{\\b h}"
  },
  	"ẗ": {
  	text: "{\\\"t}"
  },
  	"ẘ": {
  	text: "{\\r{w}}"
  },
  	"ẙ": {
  	text: "{\\r{y}}"
  },
  	"Ạ": {
  	text: "{\\d A}"
  },
  	"ạ": {
  	text: "{\\d a}"
  },
  	"Ẹ": {
  	text: "{\\d E}"
  },
  	"ẹ": {
  	text: "{\\d e}"
  },
  	"Ẽ": {
  	text: "{\\~E}"
  },
  	"ẽ": {
  	text: "{\\~e}"
  },
  	"Ị": {
  	text: "{\\d I}"
  },
  	"ị": {
  	text: "{\\d i}"
  },
  	"Ọ": {
  	text: "{\\d O}"
  },
  	"ọ": {
  	text: "{\\d o}"
  },
  	"Ụ": {
  	text: "{\\d U}"
  },
  	"ụ": {
  	text: "{\\d u}"
  },
  	"Ỳ": {
  	text: "{\\`Y}"
  },
  	"ỳ": {
  	text: "{\\`y}"
  },
  	"Ỵ": {
  	text: "{\\d Y}"
  },
  	"ỵ": {
  	text: "{\\d y}"
  },
  	"Ỹ": {
  	text: "{\\~Y}"
  },
  	"ỹ": {
  	text: "{\\~y}"
  },
  	" ": {
  	text: " ",
  	space: true
  },
  	" ": {
  	math: "\\quad",
  	space: true
  },
  	" ": {
  	text: "\\hspace{0.6em}",
  	space: true
  },
  	" ": {
  	math: "\\quad",
  	space: true,
  	text: "\\hspace{1em}"
  },
  	" ": {
  	text: "\\;",
  	space: true
  },
  	" ": {
  	text: "\\hspace{0.25em}",
  	space: true
  },
  	" ": {
  	text: "\\hspace{0.166em}",
  	space: true
  },
  	" ": {
  	text: "\\hphantom{0}",
  	space: true
  },
  	" ": {
  	text: "\\hphantom{,}",
  	space: true
  },
  	" ": {
  	text: "\\,",
  	space: true
  },
  	" ": {
  	math: "\\mkern1mu",
  	space: true
  },
  	"​": {
  	text: "{\\mbox}",
  	space: true
  },
  	"‌": {
  	text: "{\\aftergroup\\ignorespaces}"
  },
  	"‐": {
  	text: "-"
  },
  	"‑": {
  	text: "-"
  },
  	"‒": {
  	text: "-"
  },
  	"–": {
  	text: "{\\textendash}"
  },
  	"—": {
  	text: "{\\textemdash}"
  },
  	"―": {
  	math: "\\horizbar",
  	text: "\\rule{1em}{1pt}"
  },
  	"‖": {
  	math: "\\Vert"
  },
  	"‗": {
  	math: "\\twolowline"
  },
  	"‘": {
  	text: "`"
  },
  	"’": {
  	text: "'"
  },
  	"‚": {
  	text: ","
  },
  	"‛": {
  	math: "\\Elzreapos"
  },
  	"“": {
  	text: "``"
  },
  	"”": {
  	text: "''"
  },
  	"„": {
  	text: ",,"
  },
  	"‟": {
  	text: "{\\quotedblbase}"
  },
  	"†": {
  	math: "\\dagger",
  	text: "{\\textdagger}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"‡": {
  	math: "\\ddagger",
  	text: "{\\textdaggerdbl}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"•": {
  	math: "\\bullet",
  	text: "{\\textbullet}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"‣": {
  	text: ">"
  },
  	"․": {
  	text: "."
  },
  	"‥": {
  	math: "\\enleadertwodots",
  	text: ".."
  },
  	"…": {
  	math: "\\ldots",
  	text: "{\\ldots}"
  },
  	"‧": {
  	text: "-"
  },
  	" ": {
  	text: " ",
  	space: true
  },
  	"‰": {
  	text: "{\\textperthousand}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"‱": {
  	text: "{\\textpertenthousand}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"′": {
  	math: "{'}"
  },
  	"″": {
  	math: "{''}"
  },
  	"‴": {
  	math: "{'''}"
  },
  	"‵": {
  	math: "\\backprime"
  },
  	"‶": {
  	math: "\\backdprime"
  },
  	"‷": {
  	math: "\\backtrprime"
  },
  	"‸": {
  	math: "\\caretinsert"
  },
  	"‹": {
  	text: "{\\guilsinglleft}"
  },
  	"›": {
  	text: "{\\guilsinglright}"
  },
  	"‼": {
  	math: "\\Exclam"
  },
  	"‾": {
  	text: "-"
  },
  	"⁃": {
  	math: "\\hyphenbullet"
  },
  	"⁄": {
  	math: "\\fracslash"
  },
  	"⁇": {
  	math: "\\Question"
  },
  	"⁈": {
  	text: "?!"
  },
  	"⁉": {
  	text: "!?"
  },
  	"⁊": {
  	text: "7"
  },
  	"⁐": {
  	math: "\\closure"
  },
  	"⁗": {
  	math: "''''"
  },
  	" ": {
  	math: "\\:",
  	space: true,
  	text: "\\:"
  },
  	"⁠": {
  	text: "{\\nolinebreak}"
  },
  	"⁰": {
  	math: "^{0}"
  },
  	"ⁱ": {
  	math: "^{i}",
  	text: "\\textsuperscript{i}"
  },
  	"⁴": {
  	math: "^{4}"
  },
  	"⁵": {
  	math: "^{5}"
  },
  	"⁶": {
  	math: "^{6}"
  },
  	"⁷": {
  	math: "^{7}"
  },
  	"⁸": {
  	math: "^{8}"
  },
  	"⁹": {
  	math: "^{9}"
  },
  	"⁺": {
  	math: "^{+}"
  },
  	"⁻": {
  	math: "^{-}"
  },
  	"⁼": {
  	math: "^{=}"
  },
  	"⁽": {
  	math: "^{(}"
  },
  	"⁾": {
  	math: "^{)}"
  },
  	"ⁿ": {
  	math: "^{n}",
  	text: "\\textsuperscript{n}"
  },
  	"₀": {
  	math: "_{0}"
  },
  	"₁": {
  	math: "_{1}"
  },
  	"₂": {
  	math: "_{2}"
  },
  	"₃": {
  	math: "_{3}"
  },
  	"₄": {
  	math: "_{4}"
  },
  	"₅": {
  	math: "_{5}"
  },
  	"₆": {
  	math: "_{6}"
  },
  	"₇": {
  	math: "_{7}"
  },
  	"₈": {
  	math: "_{8}"
  },
  	"₉": {
  	math: "_{9}"
  },
  	"₊": {
  	math: "_{+}"
  },
  	"₋": {
  	math: "_{-}"
  },
  	"₌": {
  	math: "_{=}"
  },
  	"₍": {
  	math: "_{(}"
  },
  	"₎": {
  	math: "_{)}"
  },
  	"ₐ": {
  	math: "_{a}",
  	text: "\\textsubscript{a}"
  },
  	"ₑ": {
  	math: "_{e}",
  	text: "\\textsubscript{e}"
  },
  	"ₒ": {
  	math: "_{o}",
  	text: "\\textsubscript{o}"
  },
  	"ₓ": {
  	math: "_{x}",
  	text: "\\textsubscript{x}"
  },
  	"ₔ": {
  	text: "\\textsubscript{\\textschwa}",
  	textpackages: [
  		"tipa"
  	]
  },
  	"ₕ": {
  	math: "_{h}",
  	text: "\\textsubscript{h}"
  },
  	"ₖ": {
  	math: "_{k}",
  	text: "\\textsubscript{k}"
  },
  	"ₗ": {
  	math: "_{l}",
  	text: "\\textsubscript{l}"
  },
  	"ₘ": {
  	math: "_{m}",
  	text: "\\textsubscript{m}"
  },
  	"ₙ": {
  	math: "_{n}",
  	text: "\\textsubscript{n}"
  },
  	"ₚ": {
  	math: "_{p}",
  	text: "\\textsubscript{p}"
  },
  	"ₛ": {
  	math: "_{s}",
  	text: "\\textsubscript{s}"
  },
  	"ₜ": {
  	math: "_{t}",
  	text: "\\textsubscript{t}"
  },
  	"₧": {
  	text: "\\ensuremath{\\Elzpes}"
  },
  	"€": {
  	math: "\\euro",
  	text: "{\\texteuro}"
  },
  	"⃐": {
  	math: "\\lvec"
  },
  	"⃑": {
  	math: "\\rightharpoonup",
  	mathpackages: [
  		"amsmath",
  		"amssymb"
  	]
  },
  	"⃒": {
  	math: "\\vertoverlay"
  },
  	"⃖": {
  	math: "\\LVec"
  },
  	"⃗": {
  	math: "\\vec"
  },
  	"⃛": {
  	math: "\\dddot"
  },
  	"⃜": {
  	math: "\\ddddot"
  },
  	"⃝": {
  	math: "\\enclosecircle"
  },
  	"⃞": {
  	math: "\\enclosesquare"
  },
  	"⃟": {
  	math: "\\enclosediamond"
  },
  	"⃡": {
  	math: "\\overleftrightarrow"
  },
  	"⃤": {
  	math: "\\enclosetriangle"
  },
  	"⃧": {
  	math: "\\annuity"
  },
  	"⃨": {
  	math: "\\threeunderdot"
  },
  	"⃩": {
  	math: "\\widebridgeabove"
  },
  	"⃬": {
  	math: "\\underrightharpoondown"
  },
  	"⃭": {
  	math: "\\underleftharpoondown"
  },
  	"⃮": {
  	math: "\\underleftarrow"
  },
  	"⃯": {
  	math: "\\underrightarrow"
  },
  	"⃰": {
  	math: "\\asteraccent"
  },
  	"℀": {
  	text: "a/c"
  },
  	"℁": {
  	text: "a/s"
  },
  	"ℂ": {
  	math: "\\mathbb{C}"
  },
  	"℃": {
  	text: "{\\textcelsius}"
  },
  	"℅": {
  	text: "c/o"
  },
  	"℆": {
  	text: "c/u"
  },
  	"ℇ": {
  	math: "\\Euler"
  },
  	"℉": {
  	text: "F"
  },
  	"ℊ": {
  	math: "\\mathscr{g}"
  },
  	"ℋ": {
  	math: "\\mathscr{H}"
  },
  	"ℌ": {
  	math: "\\mathfrak{H}"
  },
  	"ℍ": {
  	math: "\\mathbb{H}"
  },
  	"ℎ": {
  	math: "\\Planckconst"
  },
  	"ℏ": {
  	math: "\\hslash"
  },
  	"ℐ": {
  	math: "\\mathscr{I}"
  },
  	"ℑ": {
  	math: "\\mathfrak{I}"
  },
  	"ℒ": {
  	math: "\\mathscr{L}"
  },
  	"ℓ": {
  	math: "\\mathscr{l}"
  },
  	"ℕ": {
  	math: "\\mathbb{N}"
  },
  	"№": {
  	text: "{\\cyrchar\\textnumero}"
  },
  	"℗": {
  	text: "{\\textcircledP}"
  },
  	"℘": {
  	math: "\\wp"
  },
  	"ℙ": {
  	math: "\\mathbb{P}"
  },
  	"ℚ": {
  	math: "\\mathbb{Q}"
  },
  	"ℛ": {
  	math: "\\mathscr{R}"
  },
  	"ℜ": {
  	math: "\\mathfrak{R}"
  },
  	"ℝ": {
  	math: "\\mathbb{R}"
  },
  	"℞": {
  	math: "\\Elzxrat"
  },
  	"℠": {
  	text: "{\\textservicemark}"
  },
  	"℡": {
  	text: "TEL"
  },
  	"™": {
  	text: "{\\texttrademark}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"ℤ": {
  	math: "\\mathbb{Z}"
  },
  	"Ω": {
  	math: "\\Omega"
  },
  	"℧": {
  	math: "\\mho"
  },
  	"ℨ": {
  	math: "\\mathfrak{Z}"
  },
  	"℩": {
  	text: "{\\textriota}"
  },
  	"K": {
  	text: "K"
  },
  	"Å": {
  	math: "\\Angstroem",
  	text: "{\\AA}"
  },
  	"ℬ": {
  	math: "\\mathscr{B}"
  },
  	"ℭ": {
  	math: "\\mathfrak{C}"
  },
  	"℮": {
  	text: "{\\textestimated}"
  },
  	"ℯ": {
  	math: "\\mathscr{e}"
  },
  	"ℰ": {
  	math: "\\mathscr{E}"
  },
  	"ℱ": {
  	math: "\\mathscr{F}"
  },
  	"Ⅎ": {
  	math: "\\Finv"
  },
  	"ℳ": {
  	math: "\\mathscr{M}"
  },
  	"ℴ": {
  	math: "\\mathscr{o}"
  },
  	"ℵ": {
  	math: "\\aleph"
  },
  	"ℶ": {
  	math: "\\beth"
  },
  	"ℷ": {
  	math: "\\gimel"
  },
  	"ℸ": {
  	math: "\\daleth"
  },
  	"ℼ": {
  	math: "\\mathbb{\\pi}"
  },
  	"ℽ": {
  	math: "\\mathbb{\\gamma}"
  },
  	"ℾ": {
  	math: "\\mathbb{\\Gamma}"
  },
  	"ℿ": {
  	math: "\\mathbb{\\Pi}"
  },
  	"⅀": {
  	math: "\\mathbb{\\Sigma}"
  },
  	"⅁": {
  	math: "\\Game"
  },
  	"⅂": {
  	math: "\\sansLturned"
  },
  	"⅃": {
  	math: "\\sansLmirrored"
  },
  	"⅄": {
  	math: "\\Yup"
  },
  	"ⅅ": {
  	math: "\\CapitalDifferentialD"
  },
  	"ⅆ": {
  	math: "\\DifferentialD"
  },
  	"ⅇ": {
  	math: "\\ExponetialE"
  },
  	"ⅈ": {
  	math: "\\ComplexI"
  },
  	"ⅉ": {
  	math: "\\ComplexJ"
  },
  	"⅊": {
  	math: "\\PropertyLine"
  },
  	"⅋": {
  	math: "\\invamp"
  },
  	"⅐": {
  	math: "\\frac{1}{7}"
  },
  	"⅑": {
  	math: "\\frac{1}{9}"
  },
  	"⅒": {
  	math: "\\frac{1}{10}"
  },
  	"⅓": {
  	math: "\\frac{1}{3}"
  },
  	"⅔": {
  	math: "\\frac{2}{3}"
  },
  	"⅕": {
  	math: "\\frac{1}{5}"
  },
  	"⅖": {
  	math: "\\frac{2}{5}"
  },
  	"⅗": {
  	math: "\\frac{3}{5}"
  },
  	"⅘": {
  	math: "\\frac{4}{5}"
  },
  	"⅙": {
  	math: "\\frac{1}{6}"
  },
  	"⅚": {
  	math: "\\frac{5}{6}"
  },
  	"⅛": {
  	math: "\\frac{1}{8}"
  },
  	"⅜": {
  	math: "\\frac{3}{8}"
  },
  	"⅝": {
  	math: "\\frac{5}{8}"
  },
  	"⅞": {
  	math: "\\frac{7}{8}"
  },
  	"⅟": {
  	math: "\\frac{1}"
  },
  	"Ⅰ": {
  	text: "I"
  },
  	"Ⅱ": {
  	text: "II"
  },
  	"Ⅲ": {
  	text: "III"
  },
  	"Ⅳ": {
  	text: "IV"
  },
  	"Ⅴ": {
  	text: "V"
  },
  	"Ⅵ": {
  	text: "VI"
  },
  	"Ⅶ": {
  	text: "VII"
  },
  	"Ⅷ": {
  	text: "VIII"
  },
  	"Ⅸ": {
  	text: "IX"
  },
  	"Ⅹ": {
  	text: "X"
  },
  	"Ⅺ": {
  	text: "XI"
  },
  	"Ⅻ": {
  	text: "XII"
  },
  	"Ⅼ": {
  	text: "L"
  },
  	"Ⅽ": {
  	text: "C"
  },
  	"Ⅾ": {
  	text: "D"
  },
  	"Ⅿ": {
  	text: "M"
  },
  	"ⅰ": {
  	text: "i"
  },
  	"ⅱ": {
  	text: "ii"
  },
  	"ⅲ": {
  	text: "iii"
  },
  	"ⅳ": {
  	text: "iv"
  },
  	"ⅴ": {
  	text: "v"
  },
  	"ⅵ": {
  	text: "vi"
  },
  	"ⅶ": {
  	text: "vii"
  },
  	"ⅷ": {
  	text: "viii"
  },
  	"ⅸ": {
  	text: "ix"
  },
  	"ⅹ": {
  	text: "x"
  },
  	"ⅺ": {
  	text: "xi"
  },
  	"ⅻ": {
  	text: "xii"
  },
  	"ⅼ": {
  	text: "l"
  },
  	"ⅽ": {
  	text: "c"
  },
  	"ⅾ": {
  	text: "d"
  },
  	"ⅿ": {
  	text: "m"
  },
  	"↉": {
  	math: "\\frac{0}{3}"
  },
  	"←": {
  	math: "\\leftarrow"
  },
  	"↑": {
  	math: "\\uparrow"
  },
  	"→": {
  	math: "\\rightarrow",
  	text: "{\\textrightarrow}",
  	textpackages: [
  		"textcomp"
  	]
  },
  	"↓": {
  	math: "\\downarrow"
  },
  	"↔": {
  	math: "\\leftrightarrow"
  },
  	"↕": {
  	math: "\\updownarrow"
  },
  	"↖": {
  	math: "\\nwarrow"
  },
  	"↗": {
  	math: "\\nearrow"
  },
  	"↘": {
  	math: "\\searrow"
  },
  	"↙": {
  	math: "\\swarrow"
  },
  	"↚": {
  	math: "\\nleftarrow"
  },
  	"↛": {
  	math: "\\nrightarrow"
  },
  	"↜": {
  	math: "\\arrowwaveleft"
  },
  	"↝": {
  	math: "\\arrowwaveright"
  },
  	"↞": {
  	math: "\\twoheadleftarrow"
  },
  	"↟": {
  	math: "\\twoheaduparrow"
  },
  	"↠": {
  	math: "\\twoheadrightarrow"
  },
  	"↡": {
  	math: "\\twoheaddownarrow"
  },
  	"↢": {
  	math: "\\leftarrowtail"
  },
  	"↣": {
  	math: "\\rightarrowtail"
  },
  	"↤": {
  	math: "\\mapsfrom"
  },
  	"↥": {
  	math: "\\MapsUp"
  },
  	"↦": {
  	math: "\\mapsto"
  },
  	"↧": {
  	math: "\\MapsDown"
  },
  	"↨": {
  	math: "\\updownarrowbar"
  },
  	"↩": {
  	math: "\\hookleftarrow"
  },
  	"↪": {
  	math: "\\hookrightarrow"
  },
  	"↫": {
  	math: "\\looparrowleft"
  },
  	"↬": {
  	math: "\\looparrowright"
  },
  	"↭": {
  	math: "\\leftrightsquigarrow"
  },
  	"↮": {
  	math: "\\nleftrightarrow"
  },
  	"↯": {
  	math: "\\lightning"
  },
  	"↰": {
  	math: "\\Lsh"
  },
  	"↱": {
  	math: "\\Rsh"
  },
  	"↲": {
  	math: "\\dlsh"
  },
  	"↳": {
  	text: "\\reflectbox{\\carriagereturn}",
  	textpackages: [
  		"graphics",
  		"unicode-math"
  	]
  },
  	"↴": {
  	math: "\\linefeed"
  },
  	"↵": {
  	math: "\\carriagereturn"
  },
  	"↶": {
  	math: "\\curvearrowleft"
  },
  	"↷": {
  	math: "\\curvearrowright"
  },
  	"↸": {
  	math: "\\barovernorthwestarrow"
  },
  	"↹": {
  	math: "\\barleftarrowrightarrowba"
  },
  	"↺": {
  	math: "\\circlearrowleft"
  },
  	"↻": {
  	math: "\\circlearrowright"
  },
  	"↼": {
  	math: "\\leftharpoonup"
  },
  	"↽": {
  	math: "\\leftharpoondown"
  },
  	"↾": {
  	math: "\\upharpoonright"
  },
  	"↿": {
  	math: "\\upharpoonleft"
  },
  	"⇀": {
  	math: "\\rightharpoonup",
  	mathpackages: [
  		"amsmath",
  		"amssymb"
  	]
  },
  	"⇁": {
  	math: "\\rightharpoondown"
  },
  	"⇂": {
  	math: "\\downharpoonright"
  },
  	"⇃": {
  	math: "\\downharpoonleft"
  },
  	"⇄": {
  	math: "\\rightleftarrows"
  },
  	"⇅": {
  	math: "\\dblarrowupdown"
  },
  	"⇆": {
  	math: "\\leftrightarrows"
  },
  	"⇇": {
  	math: "\\leftleftarrows"
  },
  	"⇈": {
  	math: "\\upuparrows"
  },
  	"⇉": {
  	math: "\\rightrightarrows"
  },
  	"⇊": {
  	math: "\\downdownarrows"
  },
  	"⇋": {
  	math: "\\leftrightharpoons"
  },
  	"⇌": {
  	math: "\\rightleftharpoons"
  },
  	"⇍": {
  	math: "\\nLeftarrow"
  },
  	"⇎": {
  	math: "\\nLeftrightarrow"
  },
  	"⇏": {
  	math: "\\nRightarrow"
  },
  	"⇐": {
  	math: "\\Leftarrow"
  },
  	"⇑": {
  	math: "\\Uparrow"
  },
  	"⇒": {
  	math: "\\Rightarrow"
  },
  	"⇓": {
  	math: "\\Downarrow"
  },
  	"⇔": {
  	math: "\\Leftrightarrow"
  },
  	"⇕": {
  	math: "\\Updownarrow"
  },
  	"⇖": {
  	math: "\\Nwarrow"
  },
  	"⇗": {
  	math: "\\Nearrow"
  },
  	"⇘": {
  	math: "\\Searrow"
  },
  	"⇙": {
  	math: "\\Swarrow"
  },
  	"⇚": {
  	math: "\\Lleftarrow"
  },
  	"⇛": {
  	math: "\\Rrightarrow"
  },
  	"⇜": {
  	math: "\\leftsquigarrow"
  },
  	"⇝": {
  	math: "\\rightsquigarrow"
  },
  	"⇞": {
  	math: "\\nHuparrow"
  },
  	"⇟": {
  	math: "\\nHdownarrow"
  },
  	"⇠": {
  	math: "\\dashleftarrow"
  },
  	"⇡": {
  	math: "\\updasharrow"
  },
  	"⇢": {
  	math: "\\dashrightarrow"
  },
  	"⇣": {
  	math: "\\downdasharrow"
  },
  	"⇤": {
  	math: "\\LeftArrowBar"
  },
  	"⇥": {
  	math: "\\RightArrowBar"
  },
  	"⇦": {
  	math: "\\leftwhitearrow"
  },
  	"⇧": {
  	math: "\\upwhitearrow"
  },
  	"⇨": {
  	math: "\\rightwhitearrow"
  },
  	"⇩": {
  	math: "\\downwhitearrow"
  },
  	"⇪": {
  	math: "\\whitearrowupfrombar"
  },
  	"⇴": {
  	math: "\\circleonrightarrow"
  },
  	"⇵": {
  	math: "\\DownArrowUpArrow"
  },
  	"⇶": {
  	math: "\\rightthreearrows"
  },
  	"⇷": {
  	math: "\\nvleftarrow"
  },
  	"⇸": {
  	math: "\\pfun"
  },
  	"⇹": {
  	math: "\\nvleftrightarrow"
  },
  	"⇺": {
  	math: "\\nVleftarrow"
  },
  	"⇻": {
  	math: "\\ffun"
  },
  	"⇼": {
  	math: "\\nVleftrightarrow"
  },
  	"⇽": {
  	math: "\\leftarrowtriangle"
  },
  	"⇾": {
  	math: "\\rightarrowtriangle"
  },
  	"⇿": {
  	math: "\\leftrightarrowtriangle"
  },
  	"∀": {
  	math: "\\forall"
  },
  	"∁": {
  	math: "\\complement"
  },
  	"∂": {
  	math: "\\partial"
  },
  	"∃": {
  	math: "\\exists"
  },
  	"∄": {
  	math: "\\nexists"
  },
  	"∅": {
  	math: "\\varnothing"
  },
  	"∆": {
  	math: "\\increment"
  },
  	"∇": {
  	math: "\\nabla"
  },
  	"∈": {
  	math: "\\in"
  },
  	"∉": {
  	math: "\\not\\in"
  },
  	"∊": {
  	math: "\\smallin"
  },
  	"∋": {
  	math: "\\ni"
  },
  	"∌": {
  	math: "\\not\\ni"
  },
  	"∍": {
  	math: "\\smallni"
  },
  	"∎": {
  	math: "\\QED"
  },
  	"∏": {
  	math: "\\prod"
  },
  	"∐": {
  	math: "\\coprod"
  },
  	"∑": {
  	math: "\\sum"
  },
  	"−": {
  	math: "-",
  	text: "-"
  },
  	"∓": {
  	math: "\\mp"
  },
  	"∔": {
  	math: "\\dotplus"
  },
  	"∕": {
  	text: "/"
  },
  	"∖": {
  	math: "\\setminus"
  },
  	"∗": {
  	math: "{_\\ast}"
  },
  	"∘": {
  	math: "\\circ"
  },
  	"∙": {
  	math: "\\bullet"
  },
  	"√": {
  	math: "\\surd"
  },
  	"∛": {
  	math: "\\sqrt[3]"
  },
  	"∜": {
  	math: "\\sqrt[4]"
  },
  	"∝": {
  	math: "\\propto"
  },
  	"∞": {
  	math: "\\infty"
  },
  	"∟": {
  	math: "\\rightangle"
  },
  	"∠": {
  	math: "\\angle"
  },
  	"∡": {
  	math: "\\measuredangle"
  },
  	"∢": {
  	math: "\\sphericalangle"
  },
  	"∣": {
  	math: "\\mid"
  },
  	"∤": {
  	math: "\\nmid"
  },
  	"∥": {
  	math: "\\parallel"
  },
  	"∦": {
  	math: "\\nparallel"
  },
  	"∧": {
  	math: "\\wedge"
  },
  	"∨": {
  	math: "\\vee"
  },
  	"∩": {
  	math: "\\cap"
  },
  	"∪": {
  	math: "\\cup"
  },
  	"∫": {
  	math: "\\int"
  },
  	"∬": {
  	math: "{\\int\\!\\int}"
  },
  	"∭": {
  	math: "{\\int\\!\\int\\!\\int}"
  },
  	"∮": {
  	math: "\\oint"
  },
  	"∯": {
  	math: "\\surfintegral"
  },
  	"∰": {
  	math: "\\volintegral"
  },
  	"∱": {
  	math: "\\clwintegral"
  },
  	"∲": {
  	math: "\\lcirclerightint",
  	mathpackages: [
  		"MnSymbol"
  	]
  },
  	"∳": {
  	math: "\\rcirclerightint",
  	mathpackages: [
  		"MnSymbol"
  	]
  },
  	"∴": {
  	math: "\\therefore"
  },
  	"∵": {
  	math: "\\because"
  },
  	"∶": {
  	math: ":"
  },
  	"∷": {
  	math: "\\Colon"
  },
  	"∸": {
  	math: "\\dotdiv",
  	mathpackages: [
  		"mathabx"
  	]
  },
  	"∹": {
  	math: "\\eqcolon"
  },
  	"∺": {
  	math: "\\mathbin{{:}\\!\\!{-}\\!\\!{:}}"
  },
  	"∻": {
  	math: "\\homothetic"
  },
  	"∼": {
  	math: "\\sim"
  },
  	"∽": {
  	math: "\\backsim"
  },
  	"∾": {
  	math: "\\lazysinv"
  },
  	"∿": {
  	math: "\\AC"
  },
  	"≀": {
  	math: "\\wr"
  },
  	"≁": {
  	math: "\\not\\sim"
  },
  	"≂": {
  	math: "\\texteqsim",
  	mathpackages: [
  		"xecjk"
  	]
  },
  	"≂̸": {
  	math: "\\NotEqualTilde"
  },
  	"≃": {
  	math: "\\simeq"
  },
  	"≄": {
  	math: "\\not\\simeq"
  },
  	"≅": {
  	math: "\\cong"
  },
  	"≆": {
  	math: "\\approxnotequal"
  },
  	"≇": {
  	math: "\\not\\cong"
  },
  	"≈": {
  	math: "\\approx"
  },
  	"≉": {
  	math: "\\not\\approx"
  },
  	"≊": {
  	math: "\\approxeq"
  },
  	"≋": {
  	math: "\\tildetrpl"
  },
  	"≋̸": {
  	math: "\\not\\apid"
  },
  	"≌": {
  	math: "\\allequal"
  },
  	"≍": {
  	math: "\\asymp"
  },
  	"≎": {
  	math: "\\Bumpeq"
  },
  	"≎̸": {
  	math: "\\NotHumpDownHump"
  },
  	"≏": {
  	math: "\\bumpeq"
  },
  	"≏̸": {
  	math: "\\NotHumpEqual"
  },
  	"≐": {
  	math: "\\doteq"
  },
  	"≐̸": {
  	math: "\\not\\doteq"
  },
  	"≑": {
  	math: "\\doteqdot"
  },
  	"≒": {
  	math: "\\fallingdotseq"
  },
  	"≓": {
  	math: "\\risingdotseq"
  },
  	"≔": {
  	math: "\\coloneq",
  	text: ":="
  },
  	"≕": {
  	math: "=:"
  },
  	"≖": {
  	math: "\\eqcirc"
  },
  	"≗": {
  	math: "\\circeq"
  },
  	"≘": {
  	math: "\\arceq"
  },
  	"≙": {
  	math: "\\estimates"
  },
  	"≛": {
  	math: "\\starequal"
  },
  	"≜": {
  	math: "\\triangleq"
  },
  	"≝": {
  	math: "\\eqdef"
  },
  	"≞": {
  	math: "\\measeq"
  },
  	"≠": {
  	math: "\\neq"
  },
  	"≡": {
  	math: "\\equiv"
  },
  	"≢": {
  	math: "\\not\\equiv"
  },
  	"≣": {
  	math: "\\Equiv"
  },
  	"≤": {
  	math: "\\leq"
  },
  	"≥": {
  	math: "\\geq"
  },
  	"≦": {
  	math: "\\leqq"
  },
  	"≧": {
  	math: "\\geqq"
  },
  	"≨": {
  	math: "\\lneqq"
  },
  	"≨︀": {
  	math: "\\lvertneqq"
  },
  	"≩": {
  	math: "\\gneqq"
  },
  	"≩︀": {
  	math: "\\gvertneqq"
  },
  	"≪": {
  	math: "\\ll"
  },
  	"≪̸": {
  	math: "\\NotLessLess"
  },
  	"≫": {
  	math: "\\gg"
  },
  	"≫̸": {
  	math: "\\NotGreaterGreater"
  },
  	"≬": {
  	math: "\\between"
  },
  	"≭": {
  	math: "{\\not\\kern-0.3em\\times}"
  },
  	"≮": {
  	math: "\\not<"
  },
  	"≯": {
  	math: "\\not>"
  },
  	"≰": {
  	math: "\\not\\leq"
  },
  	"≱": {
  	math: "\\not\\geq"
  },
  	"≲": {
  	math: "\\lessequivlnt"
  },
  	"≳": {
  	math: "\\greaterequivlnt"
  },
  	"≶": {
  	math: "\\lessgtr"
  },
  	"≷": {
  	math: "\\gtrless"
  },
  	"≸": {
  	math: "\\notlessgreater"
  },
  	"≹": {
  	math: "\\notgreaterless"
  },
  	"≺": {
  	math: "\\prec"
  },
  	"≻": {
  	math: "\\succ"
  },
  	"≼": {
  	math: "\\preccurlyeq"
  },
  	"≽": {
  	math: "\\succcurlyeq"
  },
  	"≾": {
  	math: "\\precapprox"
  },
  	"≾̸": {
  	math: "\\NotPrecedesTilde"
  },
  	"≿": {
  	math: "\\succapprox"
  },
  	"≿̸": {
  	math: "\\NotSucceedsTilde"
  },
  	"⊀": {
  	math: "\\not\\prec"
  },
  	"⊁": {
  	math: "\\not\\succ"
  },
  	"⊂": {
  	math: "\\subset"
  },
  	"⊃": {
  	math: "\\supset"
  },
  	"⊄": {
  	math: "\\not\\subset"
  },
  	"⊅": {
  	math: "\\not\\supset"
  },
  	"⊆": {
  	math: "\\subseteq"
  },
  	"⊇": {
  	math: "\\supseteq"
  },
  	"⊈": {
  	math: "\\not\\subseteq"
  },
  	"⊉": {
  	math: "\\not\\supseteq"
  },
  	"⊊": {
  	math: "\\subsetneq"
  },
  	"⊊︀": {
  	math: "\\varsubsetneqq"
  },
  	"⊋": {
  	math: "\\supsetneq"
  },
  	"⊋︀": {
  	math: "\\varsupsetneq"
  },
  	"⊌": {
  	math: "\\cupleftarrow"
  },
  	"⊍": {
  	math: "\\cupdot"
  },
  	"⊎": {
  	math: "\\uplus"
  },
  	"⊏": {
  	math: "\\sqsubset"
  },
  	"⊏̸": {
  	math: "\\NotSquareSubset"
  },
  	"⊐": {
  	math: "\\sqsupset"
  },
  	"⊐̸": {
  	math: "\\NotSquareSuperset"
  },
  	"⊑": {
  	math: "\\sqsubseteq"
  },
  	"⊒": {
  	math: "\\sqsupseteq"
  },
  	"⊓": {
  	math: "\\sqcap"
  },
  	"⊔": {
  	math: "\\sqcup"
  },
  	"⊕": {
  	math: "\\oplus"
  },
  	"⊖": {
  	math: "\\ominus"
  },
  	"⊗": {
  	math: "\\otimes"
  },
  	"⊘": {
  	math: "\\oslash"
  },
  	"⊙": {
  	math: "\\odot"
  },
  	"⊚": {
  	math: "\\circledcirc"
  },
  	"⊛": {
  	math: "\\circledast"
  },
  	"⊜": {
  	math: "\\circledequal"
  },
  	"⊝": {
  	math: "\\circleddash"
  },
  	"⊞": {
  	math: "\\boxplus"
  },
  	"⊟": {
  	math: "\\boxminus"
  },
  	"⊠": {
  	math: "\\boxtimes"
  },
  	"⊡": {
  	math: "\\boxdot"
  },
  	"⊢": {
  	math: "\\vdash"
  },
  	"⊣": {
  	math: "\\dashv"
  },
  	"⊤": {
  	math: "\\top"
  },
  	"⊥": {
  	math: "\\perp"
  },
  	"⊦": {
  	math: "\\assert"
  },
  	"⊧": {
  	math: "\\truestate"
  },
  	"⊨": {
  	math: "\\forcesextra"
  },
  	"⊩": {
  	math: "\\Vdash"
  },
  	"⊪": {
  	math: "\\Vvdash"
  },
  	"⊫": {
  	math: "\\VDash"
  },
  	"⊬": {
  	math: "\\nvdash"
  },
  	"⊭": {
  	math: "\\nvDash"
  },
  	"⊮": {
  	math: "\\nVdash"
  },
  	"⊯": {
  	math: "\\nVDash"
  },
  	"⊰": {
  	math: "\\prurel"
  },
  	"⊱": {
  	math: "\\scurel"
  },
  	"⊲": {
  	math: "\\vartriangleleft"
  },
  	"⊳": {
  	math: "\\vartriangleright"
  },
  	"⊴": {
  	math: "\\trianglelefteq"
  },
  	"⊵": {
  	math: "\\trianglerighteq"
  },
  	"⊶": {
  	math: "\\original"
  },
  	"⊷": {
  	math: "\\image"
  },
  	"⊸": {
  	math: "\\multimap"
  },
  	"⊹": {
  	math: "\\hermitconjmatrix"
  },
  	"⊺": {
  	math: "\\intercal"
  },
  	"⊻": {
  	math: "\\veebar"
  },
  	"⊼": {
  	math: "\\barwedge"
  },
  	"⊽": {
  	math: "\\barvee"
  },
  	"⊾": {
  	math: "\\rightanglearc"
  },
  	"⊿": {
  	math: "\\varlrtriangle"
  },
  	"⋂": {
  	math: "\\bigcap"
  },
  	"⋃": {
  	math: "\\bigcup"
  },
  	"⋄": {
  	math: "\\diamond"
  },
  	"⋅": {
  	math: "\\cdot"
  },
  	"⋆": {
  	math: "\\star"
  },
  	"⋇": {
  	math: "\\divideontimes"
  },
  	"⋈": {
  	math: "\\bowtie"
  },
  	"⋉": {
  	math: "\\ltimes"
  },
  	"⋊": {
  	math: "\\rtimes"
  },
  	"⋋": {
  	math: "\\leftthreetimes"
  },
  	"⋌": {
  	math: "\\rightthreetimes"
  },
  	"⋍": {
  	math: "\\backsimeq"
  },
  	"⋎": {
  	math: "\\curlyvee"
  },
  	"⋏": {
  	math: "\\curlywedge"
  },
  	"⋐": {
  	math: "\\Subset"
  },
  	"⋑": {
  	math: "\\Supset"
  },
  	"⋒": {
  	math: "\\Cap"
  },
  	"⋓": {
  	math: "\\Cup"
  },
  	"⋔": {
  	math: "\\pitchfork"
  },
  	"⋕": {
  	math: "\\hash"
  },
  	"⋖": {
  	math: "\\lessdot"
  },
  	"⋗": {
  	math: "\\gtrdot"
  },
  	"⋘": {
  	math: "\\verymuchless"
  },
  	"⋙": {
  	math: "\\verymuchgreater"
  },
  	"⋚": {
  	math: "\\lesseqgtr"
  },
  	"⋛": {
  	math: "\\gtreqless"
  },
  	"⋜": {
  	math: "\\eqless"
  },
  	"⋝": {
  	math: "\\eqgtr"
  },
  	"⋞": {
  	math: "\\curlyeqprec"
  },
  	"⋟": {
  	math: "\\curlyeqsucc"
  },
  	"⋠": {
  	math: "\\npreceq"
  },
  	"⋡": {
  	math: "\\nsucceq"
  },
  	"⋢": {
  	math: "\\not\\sqsubseteq"
  },
  	"⋣": {
  	math: "\\not\\sqsupseteq"
  },
  	"⋤": {
  	math: "\\sqsubsetneq"
  },
  	"⋥": {
  	math: "\\Elzsqspne"
  },
  	"⋦": {
  	math: "\\lnsim"
  },
  	"⋧": {
  	math: "\\gnsim"
  },
  	"⋨": {
  	math: "\\precedesnotsimilar"
  },
  	"⋩": {
  	math: "\\succnsim"
  },
  	"⋪": {
  	math: "\\ntriangleleft"
  },
  	"⋫": {
  	math: "\\ntriangleright"
  },
  	"⋬": {
  	math: "\\ntrianglelefteq"
  },
  	"⋭": {
  	math: "\\ntrianglerighteq"
  },
  	"⋮": {
  	math: "\\vdots"
  },
  	"⋯": {
  	math: "\\cdots"
  },
  	"⋰": {
  	math: "\\upslopeellipsis"
  },
  	"⋱": {
  	math: "\\downslopeellipsis"
  },
  	"⋲": {
  	math: "\\disin"
  },
  	"⋳": {
  	math: "\\varisins"
  },
  	"⋴": {
  	math: "\\isins"
  },
  	"⋵": {
  	math: "\\isindot"
  },
  	"⋶": {
  	math: "\\barin"
  },
  	"⋷": {
  	math: "\\isinobar"
  },
  	"⋸": {
  	math: "\\isinvb"
  },
  	"⋹": {
  	math: "\\isinE"
  },
  	"⋺": {
  	math: "\\nisd"
  },
  	"⋻": {
  	math: "\\varnis"
  },
  	"⋼": {
  	math: "\\nis"
  },
  	"⋽": {
  	math: "\\varniobar"
  },
  	"⋾": {
  	math: "\\niobar"
  },
  	"⋿": {
  	math: "\\bagmember"
  },
  	"⌀": {
  	math: "\\diameter"
  },
  	"⌂": {
  	math: "\\house"
  },
  	"⌅": {
  	math: "\\varbarwedge",
  	text: "{\\barwedge}"
  },
  	"⌆": {
  	math: "\\perspcorrespond"
  },
  	"⌈": {
  	math: "\\lceil"
  },
  	"⌉": {
  	math: "\\rceil"
  },
  	"⌊": {
  	math: "\\lfloor"
  },
  	"⌋": {
  	math: "\\rfloor"
  },
  	"⌐": {
  	math: "\\invneg"
  },
  	"⌑": {
  	math: "\\wasylozenge"
  },
  	"⌒": {
  	math: "\\profline"
  },
  	"⌓": {
  	math: "\\profsurf"
  },
  	"⌕": {
  	math: "\\recorder"
  },
  	"⌖": {
  	math: "{\\mathchar\"2208}"
  },
  	"⌗": {
  	math: "\\viewdata"
  },
  	"⌙": {
  	math: "\\turnednot"
  },
  	"⌜": {
  	math: "\\ulcorner"
  },
  	"⌝": {
  	math: "\\urcorner"
  },
  	"⌞": {
  	math: "\\llcorner"
  },
  	"⌟": {
  	math: "\\lrcorner"
  },
  	"⌠": {
  	math: "\\inttop"
  },
  	"⌡": {
  	math: "\\intbottom"
  },
  	"⌢": {
  	math: "\\frown"
  },
  	"⌣": {
  	math: "\\smile"
  },
  	"〈": {
  	math: "\\langle"
  },
  	"〉": {
  	math: "\\rangle"
  },
  	"⌬": {
  	math: "\\varhexagonlrbonds"
  },
  	"⌲": {
  	math: "\\conictaper"
  },
  	"⌶": {
  	math: "\\topbot"
  },
  	"⌹": {
  	math: "\\APLinv"
  },
  	"⌿": {
  	math: "\\notslash"
  },
  	"⍀": {
  	math: "\\notbackslash"
  },
  	"⍇": {
  	math: "\\APLleftarrowbox"
  },
  	"⍈": {
  	math: "\\APLrightarrowbox"
  },
  	"⍉": {
  	math: "\\invdiameter"
  },
  	"⍐": {
  	math: "\\APLuparrowbox"
  },
  	"⍓": {
  	math: "\\APLboxupcaret"
  },
  	"⍗": {
  	math: "\\APLdownarrowbox"
  },
  	"⍝": {
  	math: "\\APLcomment"
  },
  	"⍞": {
  	math: "\\APLinput"
  },
  	"⍟": {
  	math: "\\APLlog"
  },
  	"⍰": {
  	math: "\\APLboxquestion"
  },
  	"⍼": {
  	math: "\\rangledownzigzagarrow"
  },
  	"⎔": {
  	math: "\\hexagon"
  },
  	"⎛": {
  	math: "\\lparenuend"
  },
  	"⎜": {
  	math: "\\lparenextender"
  },
  	"⎝": {
  	math: "\\lparenlend"
  },
  	"⎞": {
  	math: "\\rparenuend"
  },
  	"⎟": {
  	math: "\\rparenextender"
  },
  	"⎠": {
  	math: "\\rparenlend"
  },
  	"⎡": {
  	math: "\\lbrackuend"
  },
  	"⎢": {
  	math: "\\lbrackextender"
  },
  	"⎣": {
  	math: "\\Elzdlcorn"
  },
  	"⎤": {
  	math: "\\rbrackuend"
  },
  	"⎥": {
  	math: "\\rbrackextender"
  },
  	"⎦": {
  	math: "\\rbracklend"
  },
  	"⎧": {
  	math: "\\lbraceuend"
  },
  	"⎨": {
  	math: "\\lbracemid"
  },
  	"⎩": {
  	math: "\\lbracelend"
  },
  	"⎪": {
  	math: "\\vbraceextender"
  },
  	"⎫": {
  	math: "\\rbraceuend"
  },
  	"⎬": {
  	math: "\\rbracemid"
  },
  	"⎭": {
  	math: "\\rbracelend"
  },
  	"⎮": {
  	math: "\\intextender"
  },
  	"⎯": {
  	math: "\\harrowextender"
  },
  	"⎰": {
  	math: "\\lmoustache"
  },
  	"⎱": {
  	math: "\\rmoustache"
  },
  	"⎲": {
  	math: "\\sumtop"
  },
  	"⎳": {
  	math: "\\sumbottom"
  },
  	"⎴": {
  	math: "\\overbracket"
  },
  	"⎵": {
  	math: "\\underbracket"
  },
  	"⎶": {
  	math: "\\bbrktbrk"
  },
  	"⎷": {
  	math: "\\sqrtbottom"
  },
  	"⎸": {
  	math: "\\lvboxline"
  },
  	"⎹": {
  	math: "\\rvboxline"
  },
  	"⏎": {
  	math: "\\varcarriagereturn"
  },
  	"⏜": {
  	math: "\\overparen"
  },
  	"⏝": {
  	math: "\\underparen"
  },
  	"⏞": {
  	math: "\\overbrace"
  },
  	"⏟": {
  	math: "\\underbrace"
  },
  	"⏠": {
  	math: "\\obrbrak"
  },
  	"⏡": {
  	math: "\\ubrbrak"
  },
  	"⏢": {
  	math: "\\trapezium"
  },
  	"⏣": {
  	math: "\\benzenr"
  },
  	"⏤": {
  	math: "\\strns"
  },
  	"⏥": {
  	math: "\\fltns"
  },
  	"⏦": {
  	math: "\\accurrent"
  },
  	"⏧": {
  	math: "\\elinters"
  },
  	"␀": {
  	text: "NUL"
  },
  	"␁": {
  	text: "SOH"
  },
  	"␂": {
  	text: "STX"
  },
  	"␃": {
  	text: "ETX"
  },
  	"␄": {
  	text: "EOT"
  },
  	"␅": {
  	text: "ENQ"
  },
  	"␆": {
  	text: "ACK"
  },
  	"␇": {
  	text: "BEL"
  },
  	"␈": {
  	text: "BS"
  },
  	"␉": {
  	text: "HT"
  },
  	"␊": {
  	text: "LF"
  },
  	"␋": {
  	text: "VT"
  },
  	"␌": {
  	text: "FF"
  },
  	"␍": {
  	text: "CR"
  },
  	"␎": {
  	text: "SO"
  },
  	"␏": {
  	text: "SI"
  },
  	"␐": {
  	text: "DLE"
  },
  	"␑": {
  	text: "DC1"
  },
  	"␒": {
  	text: "DC2"
  },
  	"␓": {
  	text: "DC3"
  },
  	"␔": {
  	text: "DC4"
  },
  	"␕": {
  	text: "NAK"
  },
  	"␖": {
  	text: "SYN"
  },
  	"␗": {
  	text: "ETB"
  },
  	"␘": {
  	text: "CAN"
  },
  	"␙": {
  	text: "EM"
  },
  	"␚": {
  	text: "SUB"
  },
  	"␛": {
  	text: "ESC"
  },
  	"␜": {
  	text: "FS"
  },
  	"␝": {
  	text: "GS"
  },
  	"␞": {
  	text: "RS"
  },
  	"␟": {
  	text: "US"
  },
  	"␠": {
  	text: "SP"
  },
  	"␡": {
  	text: "DEL"
  },
  	"␣": {
  	text: "{\\textvisiblespace}"
  },
  	"␤": {
  	text: "NL"
  },
  	"␥": {
  	text: "///"
  },
  	"␦": {
  	text: "?"
  },
  	"①": {
  	text: "\\ding{172}"
  },
  	"②": {
  	text: "\\ding{173}"
  },
  	"③": {
  	text: "\\ding{174}"
  },
  	"④": {
  	text: "\\ding{175}"
  },
  	"⑤": {
  	text: "\\ding{176}"
  },
  	"⑥": {
  	text: "\\ding{177}"
  },
  	"⑦": {
  	text: "\\ding{178}"
  },
  	"⑧": {
  	text: "\\ding{179}"
  },
  	"⑨": {
  	text: "\\ding{180}"
  },
  	"⑩": {
  	text: "\\ding{181}"
  },
  	"⑪": {
  	text: "(11)"
  },
  	"⑫": {
  	text: "(12)"
  },
  	"⑬": {
  	text: "(13)"
  },
  	"⑭": {
  	text: "(14)"
  },
  	"⑮": {
  	text: "(15)"
  },
  	"⑯": {
  	text: "(16)"
  },
  	"⑰": {
  	text: "(17)"
  },
  	"⑱": {
  	text: "(18)"
  },
  	"⑲": {
  	text: "(19)"
  },
  	"⑳": {
  	text: "(20)"
  },
  	"⑴": {
  	text: "(1)"
  },
  	"⑵": {
  	text: "(2)"
  },
  	"⑶": {
  	text: "(3)"
  },
  	"⑷": {
  	text: "(4)"
  },
  	"⑸": {
  	text: "(5)"
  },
  	"⑹": {
  	text: "(6)"
  },
  	"⑺": {
  	text: "(7)"
  },
  	"⑻": {
  	text: "(8)"
  },
  	"⑼": {
  	text: "(9)"
  },
  	"⑽": {
  	text: "(10)"
  },
  	"⑾": {
  	text: "(11)"
  },
  	"⑿": {
  	text: "(12)"
  },
  	"⒀": {
  	text: "(13)"
  },
  	"⒁": {
  	text: "(14)"
  },
  	"⒂": {
  	text: "(15)"
  },
  	"⒃": {
  	text: "(16)"
  },
  	"⒄": {
  	text: "(17)"
  },
  	"⒅": {
  	text: "(18)"
  },
  	"⒆": {
  	text: "(19)"
  },
  	"⒇": {
  	text: "(20)"
  },
  	"⒈": {
  	text: "1."
  },
  	"⒉": {
  	text: "2."
  },
  	"⒊": {
  	text: "3."
  },
  	"⒋": {
  	text: "4."
  },
  	"⒌": {
  	text: "5."
  },
  	"⒍": {
  	text: "6."
  },
  	"⒎": {
  	text: "7."
  },
  	"⒏": {
  	text: "8."
  },
  	"⒐": {
  	text: "9."
  },
  	"⒑": {
  	text: "10."
  },
  	"⒒": {
  	text: "11."
  },
  	"⒓": {
  	text: "12."
  },
  	"⒔": {
  	text: "13."
  },
  	"⒕": {
  	text: "14."
  },
  	"⒖": {
  	text: "15."
  },
  	"⒗": {
  	text: "16."
  },
  	"⒘": {
  	text: "17."
  },
  	"⒙": {
  	text: "18."
  },
  	"⒚": {
  	text: "19."
  },
  	"⒛": {
  	text: "20."
  },
  	"⒜": {
  	text: "(a)"
  },
  	"⒝": {
  	text: "(b)"
  },
  	"⒞": {
  	text: "(c)"
  },
  	"⒟": {
  	text: "(d)"
  },
  	"⒠": {
  	text: "(e)"
  },
  	"⒡": {
  	text: "(f)"
  },
  	"⒢": {
  	text: "(g)"
  },
  	"⒣": {
  	text: "(h)"
  },
  	"⒤": {
  	text: "(i)"
  },
  	"⒥": {
  	text: "(j)"
  },
  	"⒦": {
  	text: "(k)"
  },
  	"⒧": {
  	text: "(l)"
  },
  	"⒨": {
  	text: "(m)"
  },
  	"⒩": {
  	text: "(n)"
  },
  	"⒪": {
  	text: "(o)"
  },
  	"⒫": {
  	text: "(p)"
  },
  	"⒬": {
  	text: "(q)"
  },
  	"⒭": {
  	text: "(r)"
  },
  	"⒮": {
  	text: "(s)"
  },
  	"⒯": {
  	text: "(t)"
  },
  	"⒰": {
  	text: "(u)"
  },
  	"⒱": {
  	text: "(v)"
  },
  	"⒲": {
  	text: "(w)"
  },
  	"⒳": {
  	text: "(x)"
  },
  	"⒴": {
  	text: "(y)"
  },
  	"⒵": {
  	text: "(z)"
  },
  	"Ⓐ": {
  	text: "(A)"
  },
  	"Ⓑ": {
  	text: "(B)"
  },
  	"Ⓒ": {
  	text: "(C)"
  },
  	"Ⓓ": {
  	text: "(D)"
  },
  	"Ⓔ": {
  	text: "(E)"
  },
  	"Ⓕ": {
  	text: "(F)"
  },
  	"Ⓖ": {
  	text: "(G)"
  },
  	"Ⓗ": {
  	text: "(H)"
  },
  	"Ⓘ": {
  	text: "(I)"
  },
  	"Ⓙ": {
  	text: "(J)"
  },
  	"Ⓚ": {
  	text: "(K)"
  },
  	"Ⓛ": {
  	text: "(L)"
  },
  	"Ⓜ": {
  	text: "(M)"
  },
  	"Ⓝ": {
  	text: "(N)"
  },
  	"Ⓞ": {
  	text: "(O)"
  },
  	"Ⓟ": {
  	text: "(P)"
  },
  	"Ⓠ": {
  	text: "(Q)"
  },
  	"Ⓡ": {
  	text: "(R)"
  },
  	"Ⓢ": {
  	math: "\\circledS"
  },
  	"Ⓣ": {
  	text: "(T)"
  },
  	"Ⓤ": {
  	text: "(U)"
  },
  	"Ⓥ": {
  	text: "(V)"
  },
  	"Ⓦ": {
  	text: "(W)"
  },
  	"Ⓧ": {
  	text: "(X)"
  },
  	"Ⓨ": {
  	text: "(Y)"
  },
  	"Ⓩ": {
  	text: "(Z)"
  },
  	"ⓐ": {
  	text: "(a)"
  },
  	"ⓑ": {
  	text: "(b)"
  },
  	"ⓒ": {
  	text: "(c)"
  },
  	"ⓓ": {
  	text: "(d)"
  },
  	"ⓔ": {
  	text: "(e)"
  },
  	"ⓕ": {
  	text: "(f)"
  },
  	"ⓖ": {
  	text: "(g)"
  },
  	"ⓗ": {
  	text: "(h)"
  },
  	"ⓘ": {
  	text: "(i)"
  },
  	"ⓙ": {
  	text: "(j)"
  },
  	"ⓚ": {
  	text: "(k)"
  },
  	"ⓛ": {
  	text: "(l)"
  },
  	"ⓜ": {
  	text: "(m)"
  },
  	"ⓝ": {
  	text: "(n)"
  },
  	"ⓞ": {
  	text: "(o)"
  },
  	"ⓟ": {
  	text: "(p)"
  },
  	"ⓠ": {
  	text: "(q)"
  },
  	"ⓡ": {
  	text: "(r)"
  },
  	"ⓢ": {
  	text: "(s)"
  },
  	"ⓣ": {
  	text: "(t)"
  },
  	"ⓤ": {
  	text: "(u)"
  },
  	"ⓥ": {
  	text: "(v)"
  },
  	"ⓦ": {
  	text: "(w)"
  },
  	"ⓧ": {
  	text: "(x)"
  },
  	"ⓨ": {
  	text: "(y)"
  },
  	"ⓩ": {
  	text: "(z)"
  },
  	"⓪": {
  	text: "(0)"
  },
  	"─": {
  	text: "-"
  },
  	"━": {
  	text: "="
  },
  	"│": {
  	text: "|"
  },
  	"┃": {
  	text: "|"
  },
  	"┄": {
  	text: "-"
  },
  	"┅": {
  	text: "="
  },
  	"┆": {
  	math: "\\Elzdshfnc"
  },
  	"┇": {
  	text: "|"
  },
  	"┈": {
  	text: "-"
  },
  	"┉": {
  	text: "="
  },
  	"┊": {
  	text: "|"
  },
  	"┋": {
  	text: "|"
  },
  	"┌": {
  	text: "+"
  },
  	"┍": {
  	text: "+"
  },
  	"┎": {
  	text: "+"
  },
  	"┏": {
  	text: "+"
  },
  	"┐": {
  	text: "+"
  },
  	"┑": {
  	text: "+"
  },
  	"┒": {
  	text: "+"
  },
  	"┓": {
  	text: "+"
  },
  	"└": {
  	text: "+"
  },
  	"┕": {
  	text: "+"
  },
  	"┖": {
  	text: "+"
  },
  	"┗": {
  	text: "+"
  },
  	"┘": {
  	text: "+"
  },
  	"┙": {
  	math: "\\Elzsqfnw"
  },
  	"┚": {
  	text: "+"
  },
  	"┛": {
  	text: "+"
  },
  	"├": {
  	text: "+"
  },
  	"┝": {
  	text: "+"
  },
  	"┞": {
  	text: "+"
  },
  	"┟": {
  	text: "+"
  },
  	"┠": {
  	text: "+"
  },
  	"┡": {
  	text: "+"
  },
  	"┢": {
  	text: "+"
  },
  	"┣": {
  	text: "+"
  },
  	"┤": {
  	text: "+"
  },
  	"┥": {
  	text: "+"
  },
  	"┦": {
  	text: "+"
  },
  	"┧": {
  	text: "+"
  },
  	"┨": {
  	text: "+"
  },
  	"┩": {
  	text: "+"
  },
  	"┪": {
  	text: "+"
  },
  	"┫": {
  	text: "+"
  },
  	"┬": {
  	text: "+"
  },
  	"┭": {
  	text: "+"
  },
  	"┮": {
  	text: "+"
  },
  	"┯": {
  	text: "+"
  },
  	"┰": {
  	text: "+"
  },
  	"┱": {
  	text: "+"
  },
  	"┲": {
  	text: "+"
  },
  	"┳": {
  	text: "+"
  },
  	"┴": {
  	text: "+"
  },
  	"┵": {
  	text: "+"
  },
  	"┶": {
  	text: "+"
  },
  	"┷": {
  	text: "+"
  },
  	"┸": {
  	text: "+"
  },
  	"┹": {
  	text: "+"
  },
  	"┺": {
  	text: "+"
  },
  	"┻": {
  	text: "+"
  },
  	"┼": {
  	text: "+"
  },
  	"┽": {
  	text: "+"
  },
  	"┾": {
  	text: "+"
  },
  	"┿": {
  	text: "+"
  },
  	"╀": {
  	text: "+"
  },
  	"╁": {
  	text: "+"
  },
  	"╂": {
  	text: "+"
  },
  	"╃": {
  	text: "+"
  },
  	"╄": {
  	text: "+"
  },
  	"╅": {
  	text: "+"
  },
  	"╆": {
  	text: "+"
  },
  	"╇": {
  	text: "+"
  },
  	"╈": {
  	text: "+"
  },
  	"╉": {
  	text: "+"
  },
  	"╊": {
  	text: "+"
  },
  	"╋": {
  	text: "+"
  },
  	"╌": {
  	text: "-"
  },
  	"╍": {
  	text: "="
  },
  	"╎": {
  	text: "|"
  },
  	"╏": {
  	text: "|"
  },
  	"═": {
  	text: "="
  },
  	"║": {
  	text: "|"
  },
  	"╒": {
  	text: "+"
  },
  	"╓": {
  	text: "+"
  },
  	"╔": {
  	text: "+"
  },
  	"╕": {
  	text: "+"
  },
  	"╖": {
  	text: "+"
  },
  	"╗": {
  	text: "+"
  },
  	"╘": {
  	text: "+"
  },
  	"╙": {
  	text: "+"
  },
  	"╚": {
  	text: "+"
  },
  	"╛": {
  	text: "+"
  },
  	"╜": {
  	text: "+"
  },
  	"╝": {
  	text: "+"
  },
  	"╞": {
  	text: "+"
  },
  	"╟": {
  	text: "+"
  },
  	"╠": {
  	text: "+"
  },
  	"╡": {
  	text: "+"
  },
  	"╢": {
  	text: "+"
  },
  	"╣": {
  	text: "+"
  },
  	"╤": {
  	text: "+"
  },
  	"╥": {
  	text: "+"
  },
  	"╦": {
  	text: "+"
  },
  	"╧": {
  	text: "+"
  },
  	"╨": {
  	text: "+"
  },
  	"╩": {
  	text: "+"
  },
  	"╪": {
  	text: "+"
  },
  	"╫": {
  	text: "+"
  },
  	"╬": {
  	text: "+"
  },
  	"╭": {
  	text: "+"
  },
  	"╮": {
  	text: "+"
  },
  	"╯": {
  	text: "+"
  },
  	"╰": {
  	text: "+"
  },
  	"╱": {
  	math: "\\diagup"
  },
  	"╲": {
  	text: "\\"
  },
  	"╳": {
  	text: "X"
  },
  	"╼": {
  	text: "-"
  },
  	"╽": {
  	text: "|"
  },
  	"╾": {
  	text: "-"
  },
  	"╿": {
  	text: "|"
  },
  	"▀": {
  	math: "\\blockuphalf"
  },
  	"▄": {
  	math: "\\blocklowhalf"
  },
  	"█": {
  	math: "\\blockfull"
  },
  	"▌": {
  	math: "\\blocklefthalf"
  },
  	"▐": {
  	math: "\\blockrighthalf"
  },
  	"░": {
  	math: "\\blockqtrshaded"
  },
  	"▒": {
  	math: "\\blockhalfshaded"
  },
  	"▓": {
  	math: "\\blockthreeqtrshaded"
  },
  	"■": {
  	math: "\\mdlgblksquare",
  	text: "\\ding{110}"
  },
  	"□": {
  	math: "\\square"
  },
  	"▢": {
  	math: "\\squoval"
  },
  	"▣": {
  	math: "\\blackinwhitesquare"
  },
  	"▤": {
  	math: "\\squarehfill"
  },
  	"▥": {
  	math: "\\squarevfill"
  },
  	"▦": {
  	math: "\\squarehvfill"
  },
  	"▧": {
  	math: "\\squarenwsefill"
  },
  	"▨": {
  	math: "\\squareneswfill"
  },
  	"▩": {
  	math: "\\squarecrossfill"
  },
  	"▪": {
  	math: "\\blacksquare"
  },
  	"▫": {
  	math: "\\smwhtsquare"
  },
  	"▬": {
  	math: "\\hrectangleblack"
  },
  	"▭": {
  	math: "\\fbox{~~}"
  },
  	"▮": {
  	math: "\\vrectangleblack"
  },
  	"▯": {
  	math: "\\Elzvrecto"
  },
  	"▰": {
  	math: "\\parallelogramblack"
  },
  	"▲": {
  	math: "\\bigblacktriangleup",
  	text: "\\ding{115}"
  },
  	"△": {
  	math: "\\bigtriangleup"
  },
  	"▴": {
  	math: "\\blacktriangle"
  },
  	"▵": {
  	math: "\\vartriangle"
  },
  	"▶": {
  	math: "\\RHD"
  },
  	"▷": {
  	math: "\\rhd"
  },
  	"▸": {
  	math: "\\blacktriangleright"
  },
  	"▹": {
  	math: "\\triangleright"
  },
  	"►": {
  	math: "\\blackpointerright"
  },
  	"▻": {
  	math: "\\whitepointerright"
  },
  	"▼": {
  	math: "\\bigblacktriangledown",
  	text: "\\ding{116}"
  },
  	"▽": {
  	math: "\\bigtriangledown"
  },
  	"▾": {
  	math: "\\blacktriangledown"
  },
  	"▿": {
  	math: "\\triangledown"
  },
  	"◀": {
  	math: "\\LHD"
  },
  	"◁": {
  	math: "\\lhd"
  },
  	"◂": {
  	math: "\\blacktriangleleft"
  },
  	"◃": {
  	math: "\\triangleleft"
  },
  	"◄": {
  	math: "\\blackpointerleft"
  },
  	"◅": {
  	math: "\\whitepointerleft"
  },
  	"◆": {
  	math: "\\Diamondblack",
  	text: "\\ding{117}"
  },
  	"◇": {
  	math: "\\Diamond"
  },
  	"◈": {
  	math: "\\blackinwhitediamond"
  },
  	"◉": {
  	math: "\\fisheye"
  },
  	"◊": {
  	math: "\\lozenge"
  },
  	"○": {
  	math: "\\bigcirc"
  },
  	"◌": {
  	math: "\\dottedcircle"
  },
  	"◍": {
  	math: "\\circlevertfill"
  },
  	"◎": {
  	math: "\\bullseye"
  },
  	"●": {
  	math: "\\CIRCLE",
  	text: "\\ding{108}"
  },
  	"◐": {
  	math: "\\Elzcirfl"
  },
  	"◑": {
  	math: "\\Elzcirfr"
  },
  	"◒": {
  	math: "\\Elzcirfb"
  },
  	"◓": {
  	math: "\\circletophalfblack"
  },
  	"◔": {
  	math: "\\circleurquadblack"
  },
  	"◕": {
  	math: "\\blackcircleulquadwhite"
  },
  	"◖": {
  	math: "\\LEFTCIRCLE"
  },
  	"◗": {
  	math: "\\RIGHTCIRCLE",
  	text: "\\ding{119}"
  },
  	"◘": {
  	math: "\\Elzrvbull"
  },
  	"◙": {
  	math: "\\inversewhitecircle"
  },
  	"◚": {
  	math: "\\invwhiteupperhalfcircle"
  },
  	"◛": {
  	math: "\\invwhitelowerhalfcircle"
  },
  	"◜": {
  	math: "\\ularc"
  },
  	"◝": {
  	math: "\\urarc"
  },
  	"◞": {
  	math: "\\lrarc"
  },
  	"◟": {
  	math: "\\llarc"
  },
  	"◠": {
  	math: "\\topsemicircle"
  },
  	"◡": {
  	math: "\\botsemicircle"
  },
  	"◢": {
  	math: "\\lrblacktriangle"
  },
  	"◣": {
  	math: "\\llblacktriangle"
  },
  	"◤": {
  	math: "\\ulblacktriangle"
  },
  	"◥": {
  	math: "\\urblacktriangle"
  },
  	"◦": {
  	math: "\\smwhtcircle"
  },
  	"◧": {
  	math: "\\Elzsqfl"
  },
  	"◨": {
  	math: "\\Elzsqfr"
  },
  	"◩": {
  	math: "\\squareulblack"
  },
  	"◪": {
  	math: "\\Elzsqfse"
  },
  	"◫": {
  	math: "\\boxbar"
  },
  	"◬": {
  	math: "\\trianglecdot"
  },
  	"◭": {
  	math: "\\triangleleftblack"
  },
  	"◮": {
  	math: "\\trianglerightblack"
  },
  	"◯": {
  	math: "\\bigcirc"
  },
  	"◰": {
  	math: "\\squareulquad"
  },
  	"◱": {
  	math: "\\squarellquad"
  },
  	"◲": {
  	math: "\\squarelrquad"
  },
  	"◳": {
  	math: "\\squareurquad"
  },
  	"◴": {
  	math: "\\circleulquad"
  },
  	"◵": {
  	math: "\\circlellquad"
  },
  	"◶": {
  	math: "\\circlelrquad"
  },
  	"◷": {
  	math: "\\circleurquad"
  },
  	"◸": {
  	math: "\\ultriangle"
  },
  	"◹": {
  	math: "\\urtriangle"
  },
  	"◺": {
  	math: "\\lltriangle"
  },
  	"◻": {
  	math: "\\square"
  },
  	"◼": {
  	math: "\\blacksquare"
  },
  	"◽": {
  	math: "\\mdsmwhtsquare"
  },
  	"◾": {
  	math: "\\mdsmblksquare"
  },
  	"◿": {
  	math: "\\lrtriangle"
  },
  	"★": {
  	math: "\\bigstar",
  	text: "\\ding{72}"
  },
  	"☆": {
  	math: "\\bigwhitestar",
  	text: "\\ding{73}"
  },
  	"☉": {
  	math: "\\Sun"
  },
  	"☎": {
  	text: "\\ding{37}"
  },
  	"☐": {
  	math: "\\Square"
  },
  	"☑": {
  	math: "\\CheckedBox"
  },
  	"☒": {
  	math: "\\XBox"
  },
  	"☓": {
  	text: "X"
  },
  	"☕": {
  	math: "\\steaming"
  },
  	"☛": {
  	text: "\\ding{42}"
  },
  	"☞": {
  	math: "\\pointright",
  	text: "\\ding{43}"
  },
  	"☠": {
  	math: "\\skull"
  },
  	"☡": {
  	math: "\\danger"
  },
  	"☢": {
  	math: "\\radiation"
  },
  	"☣": {
  	math: "\\biohazard"
  },
  	"☯": {
  	math: "\\yinyang"
  },
  	"☹": {
  	math: "\\frownie"
  },
  	"☺": {
  	math: "\\smiley"
  },
  	"☻": {
  	math: "\\blacksmiley"
  },
  	"☼": {
  	math: "\\sun"
  },
  	"☽": {
  	text: "{\\rightmoon}",
  	textpackages: [
  		"wasysym"
  	]
  },
  	"☾": {
  	text: "{\\leftmoon}",
  	textpackages: [
  		"wasysym"
  	]
  },
  	"☿": {
  	math: "\\mercury",
  	text: "{\\mercury}"
  },
  	"♀": {
  	math: "\\female",
  	text: "{\\venus}"
  },
  	"♁": {
  	math: "\\earth"
  },
  	"♂": {
  	math: "\\male",
  	text: "{\\male}"
  },
  	"♃": {
  	math: "\\jupiter",
  	text: "{\\jupiter}"
  },
  	"♄": {
  	math: "\\saturn",
  	text: "{\\saturn}"
  },
  	"♅": {
  	math: "\\uranus",
  	text: "{\\uranus}"
  },
  	"♆": {
  	math: "\\neptune",
  	text: "{\\neptune}"
  },
  	"♇": {
  	math: "\\pluto",
  	text: "{\\pluto}"
  },
  	"♈": {
  	math: "\\aries",
  	text: "{\\aries}"
  },
  	"♉": {
  	math: "\\taurus",
  	text: "{\\taurus}"
  },
  	"♊": {
  	math: "\\gemini",
  	text: "{\\gemini}"
  },
  	"♋": {
  	math: "\\cancer",
  	text: "{\\cancer}"
  },
  	"♌": {
  	math: "\\leo",
  	text: "{\\leo}"
  },
  	"♍": {
  	math: "\\virgo",
  	text: "{\\virgo}"
  },
  	"♎": {
  	math: "\\libra",
  	text: "{\\libra}"
  },
  	"♏": {
  	math: "\\scorpio",
  	text: "{\\scorpio}"
  },
  	"♐": {
  	math: "\\sagittarius",
  	text: "{\\sagittarius}"
  },
  	"♑": {
  	math: "\\capricornus",
  	text: "{\\capricornus}"
  },
  	"♒": {
  	math: "\\aquarius",
  	text: "{\\aquarius}"
  },
  	"♓": {
  	math: "\\pisces",
  	text: "{\\pisces}"
  },
  	"♠": {
  	math: "\\spadesuit",
  	text: "\\ding{171}"
  },
  	"♡": {
  	math: "\\heartsuit"
  },
  	"♢": {
  	math: "\\diamond"
  },
  	"♣": {
  	math: "\\clubsuit",
  	text: "\\ding{168}"
  },
  	"♤": {
  	math: "\\varspadesuit"
  },
  	"♥": {
  	math: "\\varheartsuit",
  	text: "\\ding{170}"
  },
  	"♦": {
  	math: "\\vardiamondsuit",
  	text: "\\ding{169}"
  },
  	"♧": {
  	math: "\\varclubsuit"
  },
  	"♩": {
  	math: "\\quarternote",
  	text: "{\\quarternote}"
  },
  	"♪": {
  	math: "\\eighthnote",
  	text: "{\\eighthnote}"
  },
  	"♫": {
  	math: "\\twonotes"
  },
  	"♬": {
  	math: "\\sixteenthnote"
  },
  	"♭": {
  	math: "\\flat"
  },
  	"♮": {
  	math: "\\natural"
  },
  	"♯": {
  	math: "\\sharp"
  },
  	"♻": {
  	math: "\\recycle"
  },
  	"♾": {
  	math: "\\acidfree"
  },
  	"⚀": {
  	math: "\\dicei"
  },
  	"⚁": {
  	math: "\\diceii"
  },
  	"⚂": {
  	math: "\\diceiii"
  },
  	"⚃": {
  	math: "\\diceiv"
  },
  	"⚄": {
  	math: "\\dicev"
  },
  	"⚅": {
  	math: "\\dicevi"
  },
  	"⚆": {
  	math: "\\circledrightdot"
  },
  	"⚇": {
  	math: "\\circledtwodots"
  },
  	"⚈": {
  	math: "\\blackcircledrightdot"
  },
  	"⚉": {
  	math: "\\blackcircledtwodots"
  },
  	"⚓": {
  	math: "\\anchor"
  },
  	"⚔": {
  	math: "\\swords"
  },
  	"⚠": {
  	math: "\\warning"
  },
  	"⚥": {
  	math: "\\Hermaphrodite"
  },
  	"⚪": {
  	math: "\\medcirc"
  },
  	"⚫": {
  	math: "\\medbullet"
  },
  	"⚬": {
  	math: "\\mdsmwhtcircle"
  },
  	"⚲": {
  	math: "\\neuter"
  },
  	"✁": {
  	text: "\\ding{33}"
  },
  	"✂": {
  	text: "\\ding{34}"
  },
  	"✃": {
  	text: "\\ding{35}"
  },
  	"✄": {
  	text: "\\ding{36}"
  },
  	"✆": {
  	text: "\\ding{38}"
  },
  	"✇": {
  	text: "\\ding{39}"
  },
  	"✈": {
  	text: "\\ding{40}"
  },
  	"✉": {
  	text: "\\ding{41}"
  },
  	"✌": {
  	text: "\\ding{44}"
  },
  	"✍": {
  	text: "\\ding{45}"
  },
  	"✎": {
  	math: "\\pencil",
  	text: "\\ding{46}"
  },
  	"✏": {
  	text: "\\ding{47}"
  },
  	"✐": {
  	text: "\\ding{48}"
  },
  	"✑": {
  	text: "\\ding{49}"
  },
  	"✒": {
  	text: "\\ding{50}"
  },
  	"✓": {
  	math: "\\checkmark",
  	text: "\\ding{51}"
  },
  	"✔": {
  	text: "\\ding{52}"
  },
  	"✕": {
  	text: "\\ding{53}"
  },
  	"✖": {
  	text: "\\ding{54}"
  },
  	"✗": {
  	math: "\\ballotx",
  	text: "\\ding{55}"
  },
  	"✘": {
  	text: "\\ding{56}"
  },
  	"✙": {
  	text: "\\ding{57}"
  },
  	"✚": {
  	text: "\\ding{58}"
  },
  	"✛": {
  	text: "\\ding{59}"
  },
  	"✜": {
  	text: "\\ding{60}"
  },
  	"✝": {
  	text: "\\ding{61}"
  },
  	"✞": {
  	text: "\\ding{62}"
  },
  	"✟": {
  	text: "\\ding{63}"
  },
  	"✠": {
  	math: "\\maltese",
  	text: "\\ding{64}"
  },
  	"✡": {
  	text: "\\ding{65}"
  },
  	"✢": {
  	text: "\\ding{66}"
  },
  	"✣": {
  	text: "\\ding{67}"
  },
  	"✤": {
  	text: "\\ding{68}"
  },
  	"✥": {
  	text: "\\ding{69}"
  },
  	"✦": {
  	text: "\\ding{70}"
  },
  	"✧": {
  	text: "\\ding{71}"
  },
  	"✩": {
  	text: "\\ding{73}"
  },
  	"✪": {
  	math: "\\circledstar",
  	text: "\\ding{74}"
  },
  	"✫": {
  	text: "\\ding{75}"
  },
  	"✬": {
  	text: "\\ding{76}"
  },
  	"✭": {
  	text: "\\ding{77}"
  },
  	"✮": {
  	text: "\\ding{78}"
  },
  	"✯": {
  	text: "\\ding{79}"
  },
  	"✰": {
  	text: "\\ding{80}"
  },
  	"✱": {
  	text: "\\ding{81}"
  },
  	"✲": {
  	text: "\\ding{82}"
  },
  	"✳": {
  	text: "\\ding{83}"
  },
  	"✴": {
  	text: "\\ding{84}"
  },
  	"✵": {
  	text: "\\ding{85}"
  },
  	"✶": {
  	math: "\\varstar",
  	text: "\\ding{86}"
  },
  	"✷": {
  	text: "\\ding{87}"
  },
  	"✸": {
  	text: "\\ding{88}"
  },
  	"✹": {
  	text: "\\ding{89}"
  },
  	"✺": {
  	text: "\\ding{90}"
  },
  	"✻": {
  	text: "\\ding{91}"
  },
  	"✼": {
  	text: "\\ding{92}"
  },
  	"✽": {
  	math: "\\dingasterisk",
  	text: "\\ding{93}"
  },
  	"✾": {
  	text: "\\ding{94}"
  },
  	"✿": {
  	text: "\\ding{95}"
  },
  	"❀": {
  	text: "\\ding{96}"
  },
  	"❁": {
  	text: "\\ding{97}"
  },
  	"❂": {
  	text: "\\ding{98}"
  },
  	"❃": {
  	text: "\\ding{99}"
  },
  	"❄": {
  	text: "\\ding{100}"
  },
  	"❅": {
  	text: "\\ding{101}"
  },
  	"❆": {
  	text: "\\ding{102}"
  },
  	"❇": {
  	text: "\\ding{103}"
  },
  	"❈": {
  	text: "\\ding{104}"
  },
  	"❉": {
  	text: "\\ding{105}"
  },
  	"❊": {
  	text: "\\ding{106}"
  },
  	"❋": {
  	text: "\\ding{107}"
  },
  	"❍": {
  	text: "\\ding{109}"
  },
  	"❏": {
  	text: "\\ding{111}"
  },
  	"❐": {
  	text: "\\ding{112}"
  },
  	"❑": {
  	text: "\\ding{113}"
  },
  	"❒": {
  	text: "\\ding{114}"
  },
  	"❖": {
  	text: "\\ding{118}"
  },
  	"❘": {
  	text: "\\ding{120}"
  },
  	"❙": {
  	text: "\\ding{121}"
  },
  	"❚": {
  	text: "\\ding{122}"
  },
  	"❛": {
  	text: "\\ding{123}"
  },
  	"❜": {
  	text: "\\ding{124}"
  },
  	"❝": {
  	text: "\\ding{125}"
  },
  	"❞": {
  	text: "\\ding{126}"
  },
  	"❡": {
  	text: "\\ding{161}"
  },
  	"❢": {
  	text: "\\ding{162}"
  },
  	"❣": {
  	text: "\\ding{163}"
  },
  	"❤": {
  	text: "\\ding{164}"
  },
  	"❥": {
  	text: "\\ding{165}"
  },
  	"❦": {
  	text: "\\ding{166}"
  },
  	"❧": {
  	text: "\\ding{167}"
  },
  	"❲": {
  	math: "\\lbrbrak"
  },
  	"❳": {
  	math: "\\rbrbrak"
  },
  	"❶": {
  	text: "\\ding{182}"
  },
  	"❷": {
  	text: "\\ding{183}"
  },
  	"❸": {
  	text: "\\ding{184}"
  },
  	"❹": {
  	text: "\\ding{185}"
  },
  	"❺": {
  	text: "\\ding{186}"
  },
  	"❻": {
  	text: "\\ding{187}"
  },
  	"❼": {
  	text: "\\ding{188}"
  },
  	"❽": {
  	text: "\\ding{189}"
  },
  	"❾": {
  	text: "\\ding{190}"
  },
  	"❿": {
  	text: "\\ding{191}"
  },
  	"➀": {
  	text: "\\ding{192}"
  },
  	"➁": {
  	text: "\\ding{193}"
  },
  	"➂": {
  	text: "\\ding{194}"
  },
  	"➃": {
  	text: "\\ding{195}"
  },
  	"➄": {
  	text: "\\ding{196}"
  },
  	"➅": {
  	text: "\\ding{197}"
  },
  	"➆": {
  	text: "\\ding{198}"
  },
  	"➇": {
  	text: "\\ding{199}"
  },
  	"➈": {
  	text: "\\ding{200}"
  },
  	"➉": {
  	text: "\\ding{201}"
  },
  	"➊": {
  	text: "\\ding{202}"
  },
  	"➋": {
  	text: "\\ding{203}"
  },
  	"➌": {
  	text: "\\ding{204}"
  },
  	"➍": {
  	text: "\\ding{205}"
  },
  	"➎": {
  	text: "\\ding{206}"
  },
  	"➏": {
  	text: "\\ding{207}"
  },
  	"➐": {
  	text: "\\ding{208}"
  },
  	"➑": {
  	text: "\\ding{209}"
  },
  	"➒": {
  	text: "\\ding{210}"
  },
  	"➓": {
  	text: "\\ding{211}"
  },
  	"➔": {
  	text: "\\ding{212}"
  },
  	"➘": {
  	text: "\\ding{216}"
  },
  	"➙": {
  	text: "\\ding{217}"
  },
  	"➚": {
  	text: "\\ding{218}"
  },
  	"➛": {
  	math: "\\draftingarrow",
  	text: "\\ding{219}"
  },
  	"➜": {
  	text: "\\ding{220}"
  },
  	"➝": {
  	text: "\\ding{221}"
  },
  	"➞": {
  	text: "\\ding{222}"
  },
  	"➟": {
  	text: "\\ding{223}"
  },
  	"➠": {
  	text: "\\ding{224}"
  },
  	"➡": {
  	text: "\\ding{225}"
  },
  	"➢": {
  	math: "\\arrowbullet",
  	text: "\\ding{226}"
  },
  	"➣": {
  	text: "\\ding{227}"
  },
  	"➤": {
  	text: "\\ding{228}"
  },
  	"➥": {
  	text: "\\ding{229}"
  },
  	"➦": {
  	text: "\\ding{230}"
  },
  	"➧": {
  	text: "\\ding{231}"
  },
  	"➨": {
  	text: "\\ding{232}"
  },
  	"➩": {
  	text: "\\ding{233}"
  },
  	"➪": {
  	text: "\\ding{234}"
  },
  	"➫": {
  	text: "\\ding{235}"
  },
  	"➬": {
  	text: "\\ding{236}"
  },
  	"➭": {
  	text: "\\ding{237}"
  },
  	"➮": {
  	text: "\\ding{238}"
  },
  	"➯": {
  	text: "\\ding{239}"
  },
  	"➱": {
  	text: "\\ding{241}"
  },
  	"➲": {
  	text: "\\ding{242}"
  },
  	"➳": {
  	text: "\\ding{243}"
  },
  	"➴": {
  	text: "\\ding{244}"
  },
  	"➵": {
  	text: "\\ding{245}"
  },
  	"➶": {
  	text: "\\ding{246}"
  },
  	"➷": {
  	text: "\\ding{247}"
  },
  	"➸": {
  	text: "\\ding{248}"
  },
  	"➹": {
  	text: "\\ding{249}"
  },
  	"➺": {
  	text: "\\ding{250}"
  },
  	"➻": {
  	text: "\\ding{251}"
  },
  	"➼": {
  	text: "\\ding{252}"
  },
  	"➽": {
  	text: "\\ding{253}"
  },
  	"➾": {
  	text: "\\ding{254}"
  },
  	"⟀": {
  	math: "\\threedangle"
  },
  	"⟁": {
  	math: "\\whiteinwhitetriangle"
  },
  	"⟂": {
  	math: "\\perp"
  },
  	"⟃": {
  	math: "\\subsetcirc"
  },
  	"⟄": {
  	math: "\\supsetcirc"
  },
  	"⟅": {
  	math: "\\Lbag"
  },
  	"⟆": {
  	math: "\\Rbag"
  },
  	"⟇": {
  	math: "\\veedot"
  },
  	"⟈": {
  	math: "\\bsolhsub"
  },
  	"⟉": {
  	math: "\\suphsol"
  },
  	"⟌": {
  	math: "\\longdivision"
  },
  	"⟐": {
  	math: "\\Diamonddot"
  },
  	"⟑": {
  	math: "\\wedgedot"
  },
  	"⟒": {
  	math: "\\upin"
  },
  	"⟓": {
  	math: "\\pullback"
  },
  	"⟔": {
  	math: "\\pushout"
  },
  	"⟕": {
  	math: "\\leftouterjoin"
  },
  	"⟖": {
  	math: "\\rightouterjoin"
  },
  	"⟗": {
  	math: "\\fullouterjoin"
  },
  	"⟘": {
  	math: "\\bigbot"
  },
  	"⟙": {
  	math: "\\bigtop"
  },
  	"⟚": {
  	math: "\\DashVDash"
  },
  	"⟛": {
  	math: "\\dashVdash"
  },
  	"⟜": {
  	math: "\\multimapinv"
  },
  	"⟝": {
  	math: "\\vlongdash"
  },
  	"⟞": {
  	math: "\\longdashv"
  },
  	"⟟": {
  	math: "\\cirbot"
  },
  	"⟠": {
  	math: "\\lozengeminus"
  },
  	"⟡": {
  	math: "\\concavediamond"
  },
  	"⟢": {
  	math: "\\concavediamondtickleft"
  },
  	"⟣": {
  	math: "\\concavediamondtickright"
  },
  	"⟤": {
  	math: "\\whitesquaretickleft"
  },
  	"⟥": {
  	math: "\\whitesquaretickright"
  },
  	"⟦": {
  	math: "\\llbracket"
  },
  	"⟧": {
  	math: "\\rrbracket"
  },
  	"⟨": {
  	math: "\\langle"
  },
  	"⟩": {
  	math: "\\rangle"
  },
  	"⟪": {
  	math: "\\lang"
  },
  	"⟫": {
  	math: "\\rang"
  },
  	"⟬": {
  	math: "\\Lbrbrak"
  },
  	"⟭": {
  	math: "\\Rbrbrak"
  },
  	"⟮": {
  	math: "\\lgroup"
  },
  	"⟯": {
  	math: "\\rgroup"
  },
  	"⟰": {
  	math: "\\UUparrow"
  },
  	"⟱": {
  	math: "\\DDownarrow"
  },
  	"⟲": {
  	math: "\\acwgapcirclearrow"
  },
  	"⟳": {
  	math: "\\cwgapcirclearrow"
  },
  	"⟴": {
  	math: "\\rightarrowonoplus"
  },
  	"⟵": {
  	math: "\\longleftarrow"
  },
  	"⟶": {
  	math: "\\longrightarrow"
  },
  	"⟷": {
  	math: "\\longleftrightarrow"
  },
  	"⟸": {
  	math: "\\Longleftarrow"
  },
  	"⟹": {
  	math: "\\Longrightarrow"
  },
  	"⟺": {
  	math: "\\Longleftrightarrow"
  },
  	"⟻": {
  	math: "\\longmapsfrom"
  },
  	"⟼": {
  	math: "\\longmapsto"
  },
  	"⟽": {
  	math: "\\Longmapsfrom"
  },
  	"⟾": {
  	math: "\\Longmapsto"
  },
  	"⟿": {
  	math: "\\sim\\joinrel\\leadsto"
  },
  	"⤀": {
  	math: "\\psur"
  },
  	"⤁": {
  	math: "\\nVtwoheadrightarrow"
  },
  	"⤂": {
  	math: "\\nvLeftarrow"
  },
  	"⤃": {
  	math: "\\nvRightarrow"
  },
  	"⤄": {
  	math: "\\nvLeftrightarrow"
  },
  	"⤆": {
  	math: "\\Mapsfrom"
  },
  	"⤇": {
  	math: "\\Mapsto"
  },
  	"⤈": {
  	math: "\\downarrowbarred"
  },
  	"⤉": {
  	math: "\\uparrowbarred"
  },
  	"⤊": {
  	math: "\\Uuparrow"
  },
  	"⤋": {
  	math: "\\Ddownarrow"
  },
  	"⤌": {
  	math: "\\leftbkarrow"
  },
  	"⤍": {
  	math: "\\rightbkarrow"
  },
  	"⤎": {
  	math: "\\leftdbkarrow"
  },
  	"⤏": {
  	math: "\\dbkarow"
  },
  	"⤐": {
  	math: "\\drbkarow"
  },
  	"⤑": {
  	math: "\\rightdotarrow"
  },
  	"⤒": {
  	math: "\\UpArrowBar"
  },
  	"⤓": {
  	math: "\\DownArrowBar"
  },
  	"⤔": {
  	math: "\\pinj"
  },
  	"⤕": {
  	math: "\\finj"
  },
  	"⤖": {
  	math: "\\bij"
  },
  	"⤗": {
  	math: "\\nvtwoheadrightarrowtail"
  },
  	"⤘": {
  	math: "\\nVtwoheadrightarrowtail"
  },
  	"⤙": {
  	math: "\\lefttail"
  },
  	"⤚": {
  	math: "\\righttail"
  },
  	"⤛": {
  	math: "\\leftdbltail"
  },
  	"⤜": {
  	math: "\\rightdbltail"
  },
  	"⤝": {
  	math: "\\diamondleftarrow"
  },
  	"⤞": {
  	math: "\\rightarrowdiamond"
  },
  	"⤟": {
  	math: "\\diamondleftarrowbar"
  },
  	"⤠": {
  	math: "\\barrightarrowdiamond"
  },
  	"⤡": {
  	math: "\\nwsearrow"
  },
  	"⤢": {
  	math: "\\neswarrow"
  },
  	"⤫": {
  	math: "\\rdiagovfdiag"
  },
  	"⤬": {
  	math: "\\fdiagovrdiag"
  },
  	"⤭": {
  	math: "\\seovnearrow"
  },
  	"⤮": {
  	math: "\\neovsearrow"
  },
  	"⤯": {
  	math: "\\fdiagovnearrow"
  },
  	"⤰": {
  	math: "\\rdiagovsearrow"
  },
  	"⤱": {
  	math: "\\neovnwarrow"
  },
  	"⤲": {
  	math: "\\nwovnearrow"
  },
  	"⤴": {
  	math: "\\uprightcurvearrow"
  },
  	"⤵": {
  	math: "\\downrightcurvedarrow"
  },
  	"⤸": {
  	math: "\\cwrightarcarrow"
  },
  	"⤹": {
  	math: "\\acwleftarcarrow"
  },
  	"⤺": {
  	math: "\\acwoverarcarrow"
  },
  	"⤻": {
  	math: "\\acwunderarcarrow"
  },
  	"⤼": {
  	math: "\\curvearrowrightminus"
  },
  	"⤽": {
  	math: "\\curvearrowleftplus"
  },
  	"⤾": {
  	math: "\\cwundercurvearrow"
  },
  	"⤿": {
  	math: "\\ccwundercurvearrow"
  },
  	"⥀": {
  	math: "\\Elolarr"
  },
  	"⥁": {
  	math: "\\Elorarr"
  },
  	"⥂": {
  	math: "\\ElzRlarr"
  },
  	"⥃": {
  	math: "\\leftarrowshortrightarrow"
  },
  	"⥄": {
  	math: "\\ElzrLarr"
  },
  	"⥅": {
  	math: "\\rightarrowplus"
  },
  	"⥆": {
  	math: "\\leftarrowplus"
  },
  	"⥇": {
  	math: "\\Elzrarrx"
  },
  	"⥈": {
  	math: "\\leftrightarrowcircle"
  },
  	"⥉": {
  	math: "\\twoheaduparrowcircle"
  },
  	"⥊": {
  	math: "\\leftrightharpoon"
  },
  	"⥋": {
  	math: "\\rightleftharpoon"
  },
  	"⥌": {
  	math: "\\updownharpoonrightleft"
  },
  	"⥍": {
  	math: "\\updownharpoonleftright"
  },
  	"⥎": {
  	math: "\\LeftRightVector"
  },
  	"⥏": {
  	math: "\\RightUpDownVector"
  },
  	"⥐": {
  	math: "\\DownLeftRightVector"
  },
  	"⥑": {
  	math: "\\LeftUpDownVector"
  },
  	"⥒": {
  	math: "\\LeftVectorBar"
  },
  	"⥓": {
  	math: "\\RightVectorBar"
  },
  	"⥔": {
  	math: "\\RightUpVectorBar"
  },
  	"⥕": {
  	math: "\\RightDownVectorBar"
  },
  	"⥖": {
  	math: "\\DownLeftVectorBar"
  },
  	"⥗": {
  	math: "\\DownRightVectorBar"
  },
  	"⥘": {
  	math: "\\LeftUpVectorBar"
  },
  	"⥙": {
  	math: "\\LeftDownVectorBar"
  },
  	"⥚": {
  	math: "\\LeftTeeVector"
  },
  	"⥛": {
  	math: "\\RightTeeVector"
  },
  	"⥜": {
  	math: "\\RightUpTeeVector"
  },
  	"⥝": {
  	math: "\\RightDownTeeVector"
  },
  	"⥞": {
  	math: "\\DownLeftTeeVector"
  },
  	"⥟": {
  	math: "\\DownRightTeeVector"
  },
  	"⥠": {
  	math: "\\LeftUpTeeVector"
  },
  	"⥡": {
  	math: "\\LeftDownTeeVector"
  },
  	"⥢": {
  	math: "\\leftleftharpoons"
  },
  	"⥣": {
  	math: "\\upupharpoons"
  },
  	"⥤": {
  	math: "\\rightrightharpoons"
  },
  	"⥥": {
  	math: "\\downdownharpoons"
  },
  	"⥦": {
  	math: "\\leftrightharpoonsup"
  },
  	"⥧": {
  	math: "\\leftrightharpoonsdown"
  },
  	"⥨": {
  	math: "\\rightleftharpoonsup"
  },
  	"⥩": {
  	math: "\\rightleftharpoonsdown"
  },
  	"⥪": {
  	math: "\\leftbarharpoon"
  },
  	"⥫": {
  	math: "\\barleftharpoon"
  },
  	"⥬": {
  	math: "\\rightbarharpoon"
  },
  	"⥭": {
  	math: "\\barrightharpoon"
  },
  	"⥮": {
  	math: "\\UpEquilibrium"
  },
  	"⥯": {
  	math: "\\ReverseUpEquilibrium"
  },
  	"⥰": {
  	math: "\\RoundImplies"
  },
  	"⥱": {
  	math: "\\equalrightarrow"
  },
  	"⥲": {
  	math: "\\similarrightarrow"
  },
  	"⥳": {
  	math: "\\leftarrowsimilar"
  },
  	"⥴": {
  	math: "\\rightarrowsimilar"
  },
  	"⥵": {
  	math: "\\rightarrowapprox"
  },
  	"⥶": {
  	math: "\\ltlarr"
  },
  	"⥷": {
  	math: "\\leftarrowless"
  },
  	"⥸": {
  	math: "\\gtrarr"
  },
  	"⥹": {
  	math: "\\subrarr"
  },
  	"⥺": {
  	math: "\\leftarrowsubset"
  },
  	"⥻": {
  	math: "\\suplarr"
  },
  	"⥾": {
  	math: "\\upfishtail"
  },
  	"⥿": {
  	math: "\\downfishtail"
  },
  	"⦀": {
  	math: "\\Elztfnc"
  },
  	"⦁": {
  	math: "\\spot"
  },
  	"⦂": {
  	math: "\\typecolon"
  },
  	"⦃": {
  	math: "\\lBrace"
  },
  	"⦄": {
  	math: "\\rBrace"
  },
  	"⦆": {
  	math: "\\Elroang"
  },
  	"⦇": {
  	math: "\\limg"
  },
  	"⦈": {
  	math: "\\rimg"
  },
  	"⦉": {
  	math: "\\lblot"
  },
  	"⦊": {
  	math: "\\rblot"
  },
  	"⦋": {
  	math: "\\lbrackubar"
  },
  	"⦌": {
  	math: "\\rbrackubar"
  },
  	"⦍": {
  	math: "\\lbrackultick"
  },
  	"⦎": {
  	math: "\\rbracklrtick"
  },
  	"⦏": {
  	math: "\\lbracklltick"
  },
  	"⦐": {
  	math: "\\rbrackurtick"
  },
  	"⦑": {
  	math: "\\langledot"
  },
  	"⦒": {
  	math: "\\rangledot"
  },
  	"⦓": {
  	math: "<\\kern-0.58em("
  },
  	"⦕": {
  	math: "\\Lparengtr"
  },
  	"⦖": {
  	math: "\\Rparenless"
  },
  	"⦗": {
  	math: "\\lblkbrbrak"
  },
  	"⦘": {
  	math: "\\rblkbrbrak"
  },
  	"⦙": {
  	math: "\\Elzddfnc"
  },
  	"⦚": {
  	math: "\\vzigzag"
  },
  	"⦛": {
  	math: "\\measuredangleleft"
  },
  	"⦜": {
  	math: "\\Angle"
  },
  	"⦝": {
  	math: "\\rightanglemdot"
  },
  	"⦞": {
  	math: "\\angles"
  },
  	"⦟": {
  	math: "\\angdnr"
  },
  	"⦠": {
  	math: "\\Elzlpargt"
  },
  	"⦡": {
  	math: "\\sphericalangleup"
  },
  	"⦢": {
  	math: "\\turnangle"
  },
  	"⦣": {
  	math: "\\revangle"
  },
  	"⦤": {
  	math: "\\angleubar"
  },
  	"⦥": {
  	math: "\\revangleubar"
  },
  	"⦦": {
  	math: "\\wideangledown"
  },
  	"⦧": {
  	math: "\\wideangleup"
  },
  	"⦨": {
  	math: "\\measanglerutone"
  },
  	"⦩": {
  	math: "\\measanglelutonw"
  },
  	"⦪": {
  	math: "\\measanglerdtose"
  },
  	"⦫": {
  	math: "\\measangleldtosw"
  },
  	"⦬": {
  	math: "\\measangleurtone"
  },
  	"⦭": {
  	math: "\\measangleultonw"
  },
  	"⦮": {
  	math: "\\measangledrtose"
  },
  	"⦯": {
  	math: "\\measangledltosw"
  },
  	"⦰": {
  	math: "\\revemptyset"
  },
  	"⦱": {
  	math: "\\emptysetobar"
  },
  	"⦲": {
  	math: "\\emptysetocirc"
  },
  	"⦳": {
  	math: "\\emptysetoarr"
  },
  	"⦴": {
  	math: "\\emptysetoarrl"
  },
  	"⦷": {
  	math: "\\circledparallel"
  },
  	"⦸": {
  	math: "\\circledbslash"
  },
  	"⦹": {
  	math: "\\operp"
  },
  	"⦺": {
  	math: "\\obot"
  },
  	"⦻": {
  	math: "\\olcross"
  },
  	"⦼": {
  	math: "\\odotslashdot"
  },
  	"⦽": {
  	math: "\\uparrowoncircle"
  },
  	"⦾": {
  	math: "\\circledwhitebullet"
  },
  	"⦿": {
  	math: "\\circledbullet"
  },
  	"⧀": {
  	math: "\\circledless"
  },
  	"⧁": {
  	math: "\\circledgtr"
  },
  	"⧂": {
  	math: "\\cirscir"
  },
  	"⧃": {
  	math: "\\cirE"
  },
  	"⧄": {
  	math: "\\boxslash"
  },
  	"⧅": {
  	math: "\\boxbslash"
  },
  	"⧆": {
  	math: "\\boxast"
  },
  	"⧇": {
  	math: "\\boxcircle"
  },
  	"⧈": {
  	math: "\\boxbox"
  },
  	"⧉": {
  	math: "\\boxonbox"
  },
  	"⧊": {
  	math: "\\ElzLap"
  },
  	"⧋": {
  	math: "\\Elzdefas"
  },
  	"⧌": {
  	math: "\\triangles"
  },
  	"⧍": {
  	math: "\\triangleserifs"
  },
  	"⧎": {
  	math: "\\rtriltri"
  },
  	"⧏": {
  	math: "\\LeftTriangleBar"
  },
  	"⧏̸": {
  	math: "\\NotLeftTriangleBar"
  },
  	"⧐": {
  	math: "\\RightTriangleBar"
  },
  	"⧐̸": {
  	math: "\\NotRightTriangleBar"
  },
  	"⧑": {
  	math: "\\lfbowtie"
  },
  	"⧒": {
  	math: "\\rfbowtie"
  },
  	"⧓": {
  	math: "\\fbowtie"
  },
  	"⧔": {
  	math: "\\lftimes"
  },
  	"⧕": {
  	math: "\\rftimes"
  },
  	"⧖": {
  	math: "\\hourglass"
  },
  	"⧗": {
  	math: "\\blackhourglass"
  },
  	"⧘": {
  	math: "\\lvzigzag"
  },
  	"⧙": {
  	math: "\\rvzigzag"
  },
  	"⧚": {
  	math: "\\Lvzigzag"
  },
  	"⧛": {
  	math: "\\Rvzigzag"
  },
  	"⧝": {
  	math: "\\tieinfty"
  },
  	"⧞": {
  	math: "\\nvinfty"
  },
  	"⧟": {
  	math: "\\multimapboth"
  },
  	"⧠": {
  	math: "\\laplac"
  },
  	"⧡": {
  	math: "\\lrtriangleeq"
  },
  	"⧢": {
  	math: "\\shuffle"
  },
  	"⧣": {
  	math: "\\eparsl"
  },
  	"⧤": {
  	math: "\\smeparsl"
  },
  	"⧥": {
  	math: "\\eqvparsl"
  },
  	"⧦": {
  	math: "\\gleichstark"
  },
  	"⧧": {
  	math: "\\thermod"
  },
  	"⧨": {
  	math: "\\downtriangleleftblack"
  },
  	"⧩": {
  	math: "\\downtrianglerightblack"
  },
  	"⧪": {
  	math: "\\blackdiamonddownarrow"
  },
  	"⧫": {
  	math: "\\blacklozenge"
  },
  	"⧬": {
  	math: "\\circledownarrow"
  },
  	"⧭": {
  	math: "\\blackcircledownarrow"
  },
  	"⧮": {
  	math: "\\errbarsquare"
  },
  	"⧯": {
  	math: "\\errbarblacksquare"
  },
  	"⧰": {
  	math: "\\errbardiamond"
  },
  	"⧱": {
  	math: "\\errbarblackdiamond"
  },
  	"⧲": {
  	math: "\\errbarcircle"
  },
  	"⧳": {
  	math: "\\errbarblackcircle"
  },
  	"⧴": {
  	math: "\\RuleDelayed"
  },
  	"⧵": {
  	math: "\\setminus"
  },
  	"⧶": {
  	math: "\\dsol"
  },
  	"⧷": {
  	math: "\\rsolbar"
  },
  	"⧸": {
  	math: "\\xsol"
  },
  	"⧹": {
  	math: "\\zhide"
  },
  	"⧺": {
  	math: "\\doubleplus"
  },
  	"⧻": {
  	math: "\\tripleplus"
  },
  	"⧼": {
  	math: "\\lcurvyangle"
  },
  	"⧽": {
  	math: "\\rcurvyangle"
  },
  	"⧾": {
  	math: "\\tplus"
  },
  	"⧿": {
  	math: "\\tminus"
  },
  	"⨀": {
  	math: "\\bigodot"
  },
  	"⨁": {
  	math: "\\bigoplus"
  },
  	"⨂": {
  	math: "\\bigotimes"
  },
  	"⨃": {
  	math: "\\bigcupdot"
  },
  	"⨄": {
  	math: "\\Elxuplus"
  },
  	"⨅": {
  	math: "\\ElzThr"
  },
  	"⨆": {
  	math: "\\Elxsqcup"
  },
  	"⨇": {
  	math: "\\ElzInf"
  },
  	"⨈": {
  	math: "\\ElzSup"
  },
  	"⨉": {
  	math: "\\varprod"
  },
  	"⨊": {
  	math: "\\modtwosum"
  },
  	"⨋": {
  	math: "\\sumint"
  },
  	"⨌": {
  	math: "\\iiiint"
  },
  	"⨍": {
  	math: "\\ElzCint"
  },
  	"⨎": {
  	math: "\\intBar"
  },
  	"⨏": {
  	math: "\\clockoint"
  },
  	"⨑": {
  	math: "\\awint"
  },
  	"⨒": {
  	math: "\\rppolint"
  },
  	"⨓": {
  	math: "\\scpolint"
  },
  	"⨔": {
  	math: "\\npolint"
  },
  	"⨕": {
  	math: "\\pointint"
  },
  	"⨖": {
  	math: "\\sqrint"
  },
  	"⨗": {
  	math: "\\intlarhk"
  },
  	"⨘": {
  	math: "\\intx"
  },
  	"⨙": {
  	math: "\\intcap"
  },
  	"⨚": {
  	math: "\\intcup"
  },
  	"⨛": {
  	math: "\\upint"
  },
  	"⨜": {
  	math: "\\lowint"
  },
  	"⨝": {
  	math: "\\Join"
  },
  	"⨞": {
  	math: "\\bigtriangleleft"
  },
  	"⨟": {
  	math: "\\zcmp"
  },
  	"⨠": {
  	math: "\\zpipe"
  },
  	"⨡": {
  	math: "\\zproject"
  },
  	"⨢": {
  	math: "\\ringplus"
  },
  	"⨣": {
  	math: "\\plushat"
  },
  	"⨤": {
  	math: "\\simplus"
  },
  	"⨦": {
  	math: "\\plussim"
  },
  	"⨧": {
  	math: "\\plussubtwo"
  },
  	"⨨": {
  	math: "\\plustrif"
  },
  	"⨩": {
  	math: "\\commaminus"
  },
  	"⨫": {
  	math: "\\minusfdots"
  },
  	"⨬": {
  	math: "\\minusrdots"
  },
  	"⨯": {
  	math: "\\ElzTimes"
  },
  	"⨰": {
  	math: "\\dottimes"
  },
  	"⨱": {
  	math: "\\timesbar"
  },
  	"⨲": {
  	math: "\\btimes"
  },
  	"⨳": {
  	math: "\\smashtimes"
  },
  	"⨶": {
  	math: "\\otimeshat"
  },
  	"⨷": {
  	math: "\\Otimes"
  },
  	"⨸": {
  	math: "\\odiv"
  },
  	"⨹": {
  	math: "\\triangleplus"
  },
  	"⨺": {
  	math: "\\triangleminus"
  },
  	"⨻": {
  	math: "\\triangletimes"
  },
  	"⨽": {
  	math: "\\intprodr"
  },
  	"⨾": {
  	math: "\\fcmp"
  },
  	"⨿": {
  	math: "\\amalg"
  },
  	"⩀": {
  	math: "\\capdot"
  },
  	"⩁": {
  	math: "\\uminus"
  },
  	"⩂": {
  	math: "\\barcup"
  },
  	"⩃": {
  	math: "\\barcap"
  },
  	"⩄": {
  	math: "\\capwedge"
  },
  	"⩅": {
  	math: "\\cupvee"
  },
  	"⩆": {
  	math: "\\cupovercap"
  },
  	"⩇": {
  	math: "\\capovercup"
  },
  	"⩈": {
  	math: "\\cupbarcap"
  },
  	"⩉": {
  	math: "\\capbarcup"
  },
  	"⩊": {
  	math: "\\twocups"
  },
  	"⩋": {
  	math: "\\twocaps"
  },
  	"⩌": {
  	math: "\\closedvarcup"
  },
  	"⩍": {
  	math: "\\closedvarcap"
  },
  	"⩎": {
  	math: "\\Sqcap"
  },
  	"⩏": {
  	math: "\\Sqcup"
  },
  	"⩐": {
  	math: "\\closedvarcupsmashprod"
  },
  	"⩑": {
  	math: "\\wedgeodot"
  },
  	"⩒": {
  	math: "\\veeodot"
  },
  	"⩓": {
  	math: "\\ElzAnd"
  },
  	"⩔": {
  	math: "\\ElzOr"
  },
  	"⩖": {
  	math: "\\ElOr"
  },
  	"⩗": {
  	math: "\\bigslopedvee"
  },
  	"⩘": {
  	math: "\\bigslopedwedge"
  },
  	"⩙": {
  	math: "\\veeonwedge"
  },
  	"⩚": {
  	math: "\\wedgemidvert"
  },
  	"⩛": {
  	math: "\\veemidvert"
  },
  	"⩜": {
  	math: "\\midbarwedge"
  },
  	"⩝": {
  	math: "\\midbarvee"
  },
  	"⩞": {
  	math: "\\perspcorrespond"
  },
  	"⩟": {
  	math: "\\Elzminhat"
  },
  	"⩠": {
  	math: "\\wedgedoublebar"
  },
  	"⩡": {
  	math: "\\varveebar"
  },
  	"⩢": {
  	math: "\\doublebarvee"
  },
  	"⩤": {
  	math: "\\dsub"
  },
  	"⩥": {
  	math: "\\rsub"
  },
  	"⩦": {
  	math: "\\eqdot"
  },
  	"⩧": {
  	math: "\\dotequiv"
  },
  	"⩨": {
  	math: "\\equivVert"
  },
  	"⩩": {
  	math: "\\equivVvert"
  },
  	"⩪": {
  	math: "\\dotsim"
  },
  	"⩫": {
  	math: "\\simrdots"
  },
  	"⩬": {
  	math: "\\simminussim"
  },
  	"⩭": {
  	math: "\\congdot"
  },
  	"⩮": {
  	math: "\\stackrel{*}{=}"
  },
  	"⩯": {
  	math: "\\hatapprox"
  },
  	"⩰": {
  	math: "\\approxeqq"
  },
  	"⩱": {
  	math: "\\eqqplus"
  },
  	"⩲": {
  	math: "\\pluseqq"
  },
  	"⩳": {
  	math: "\\eqqsim"
  },
  	"⩴": {
  	math: "\\Coloneqq"
  },
  	"⩵": {
  	math: "\\Equal"
  },
  	"⩶": {
  	math: "\\Same"
  },
  	"⩷": {
  	math: "\\ddotseq"
  },
  	"⩸": {
  	math: "\\equivDD"
  },
  	"⩹": {
  	math: "\\ltcir"
  },
  	"⩺": {
  	math: "\\gtcir"
  },
  	"⩻": {
  	math: "\\ltquest"
  },
  	"⩼": {
  	math: "\\gtquest"
  },
  	"⩽": {
  	math: "\\leqslant",
  	mathpackages: [
  		"amssymb"
  	]
  },
  	"⩽̸": {
  	math: "\\nleqslant",
  	mathpackages: [
  		"amssymb"
  	]
  },
  	"⩾": {
  	math: "\\geqslant",
  	mathpackages: [
  		"amssymb"
  	]
  },
  	"⩾̸": {
  	math: "\\ngeqslant",
  	mathpackages: [
  		"amssymb"
  	]
  },
  	"⩿": {
  	math: "\\lesdot"
  },
  	"⪀": {
  	math: "\\gesdot"
  },
  	"⪁": {
  	math: "\\lesdoto"
  },
  	"⪂": {
  	math: "\\gesdoto"
  },
  	"⪃": {
  	math: "\\lesdotor"
  },
  	"⪄": {
  	math: "\\gesdotol"
  },
  	"⪅": {
  	math: "\\lessapprox"
  },
  	"⪆": {
  	math: "\\gtrapprox"
  },
  	"⪇": {
  	math: "\\lneq"
  },
  	"⪈": {
  	math: "\\gneq"
  },
  	"⪉": {
  	math: "\\lnapprox"
  },
  	"⪊": {
  	math: "\\gnapprox"
  },
  	"⪋": {
  	math: "\\lesseqqgtr"
  },
  	"⪌": {
  	math: "\\gtreqqless"
  },
  	"⪍": {
  	math: "\\lsime"
  },
  	"⪎": {
  	math: "\\gsime"
  },
  	"⪏": {
  	math: "\\lsimg"
  },
  	"⪐": {
  	math: "\\gsiml"
  },
  	"⪑": {
  	math: "\\lgE"
  },
  	"⪒": {
  	math: "\\glE"
  },
  	"⪓": {
  	math: "\\lesges"
  },
  	"⪔": {
  	math: "\\gesles"
  },
  	"⪕": {
  	math: "\\eqslantless"
  },
  	"⪖": {
  	math: "\\eqslantgtr"
  },
  	"⪗": {
  	math: "\\elsdot"
  },
  	"⪘": {
  	math: "\\egsdot"
  },
  	"⪙": {
  	math: "\\eqqless"
  },
  	"⪚": {
  	math: "\\eqqgtr"
  },
  	"⪛": {
  	math: "\\eqqslantless"
  },
  	"⪜": {
  	math: "\\eqqslantgtr"
  },
  	"⪝": {
  	math: "\\Pisymbol{ppi020}{117}"
  },
  	"⪞": {
  	math: "\\Pisymbol{ppi020}{105}"
  },
  	"⪟": {
  	math: "\\simlE"
  },
  	"⪠": {
  	math: "\\simgE"
  },
  	"⪡": {
  	math: "\\NestedLessLess"
  },
  	"⪡̸": {
  	math: "\\NotNestedLessLess"
  },
  	"⪢": {
  	math: "\\NestedGreaterGreater"
  },
  	"⪢̸": {
  	math: "\\NotNestedGreaterGreater"
  },
  	"⪣": {
  	math: "\\partialmeetcontraction"
  },
  	"⪤": {
  	math: "\\glj"
  },
  	"⪥": {
  	math: "\\gla"
  },
  	"⪦": {
  	math: "\\leftslice"
  },
  	"⪧": {
  	math: "\\rightslice"
  },
  	"⪨": {
  	math: "\\lescc"
  },
  	"⪩": {
  	math: "\\gescc"
  },
  	"⪪": {
  	math: "\\smt"
  },
  	"⪫": {
  	math: "\\lat"
  },
  	"⪬": {
  	math: "\\smte"
  },
  	"⪭": {
  	math: "\\late"
  },
  	"⪮": {
  	math: "\\bumpeqq"
  },
  	"⪯": {
  	math: "\\preceq"
  },
  	"⪯̸": {
  	math: "\\not\\preceq"
  },
  	"⪰": {
  	math: "\\succeq"
  },
  	"⪰̸": {
  	math: "\\not\\succeq"
  },
  	"⪱": {
  	math: "\\precneq"
  },
  	"⪲": {
  	math: "\\succneq"
  },
  	"⪳": {
  	math: "\\preceqq"
  },
  	"⪴": {
  	math: "\\succeqq"
  },
  	"⪵": {
  	math: "\\precneqq"
  },
  	"⪶": {
  	math: "\\succneqq"
  },
  	"⪷": {
  	math: "\\precapprox"
  },
  	"⪸": {
  	math: "\\succapprox"
  },
  	"⪹": {
  	math: "\\precnapprox"
  },
  	"⪺": {
  	math: "\\succnapprox"
  },
  	"⪻": {
  	math: "\\llcurly"
  },
  	"⪼": {
  	math: "\\ggcurly"
  },
  	"⪽": {
  	math: "\\subsetdot"
  },
  	"⪾": {
  	math: "\\supsetdot"
  },
  	"⪿": {
  	math: "\\subsetplus"
  },
  	"⫀": {
  	math: "\\supsetplus"
  },
  	"⫁": {
  	math: "\\submult"
  },
  	"⫂": {
  	math: "\\supmult"
  },
  	"⫃": {
  	math: "\\subedot"
  },
  	"⫄": {
  	math: "\\supedot"
  },
  	"⫅": {
  	math: "\\subseteqq"
  },
  	"⫅̸": {
  	math: "\\nsubseteqq"
  },
  	"⫆": {
  	math: "\\supseteqq"
  },
  	"⫆̸": {
  	math: "\\nsupseteqq"
  },
  	"⫇": {
  	math: "\\subsim"
  },
  	"⫈": {
  	math: "\\supsim"
  },
  	"⫉": {
  	math: "\\subsetapprox"
  },
  	"⫊": {
  	math: "\\supsetapprox"
  },
  	"⫋": {
  	math: "\\subsetneqq"
  },
  	"⫌": {
  	math: "\\supsetneqq"
  },
  	"⫍": {
  	math: "\\lsqhook"
  },
  	"⫎": {
  	math: "\\rsqhook"
  },
  	"⫏": {
  	math: "\\csub"
  },
  	"⫐": {
  	math: "\\csup"
  },
  	"⫑": {
  	math: "\\csube"
  },
  	"⫒": {
  	math: "\\csupe"
  },
  	"⫓": {
  	math: "\\subsup"
  },
  	"⫔": {
  	math: "\\supsub"
  },
  	"⫕": {
  	math: "\\subsub"
  },
  	"⫖": {
  	math: "\\supsup"
  },
  	"⫗": {
  	math: "\\suphsub"
  },
  	"⫘": {
  	math: "\\supdsub"
  },
  	"⫙": {
  	math: "\\forkv"
  },
  	"⫚": {
  	math: "\\topfork"
  },
  	"⫛": {
  	math: "\\mlcp"
  },
  	"⫝̸": {
  	math: "\\forks"
  },
  	"⫝": {
  	math: "\\forksnot"
  },
  	"⫝̸": {
  	math: "\\forks"
  },
  	"⫞": {
  	math: "\\shortlefttack"
  },
  	"⫟": {
  	math: "\\shortdowntack"
  },
  	"⫠": {
  	math: "\\shortuptack"
  },
  	"⫡": {
  	math: "\\perps"
  },
  	"⫢": {
  	math: "\\vDdash"
  },
  	"⫣": {
  	math: "\\dashV"
  },
  	"⫤": {
  	math: "\\Dashv"
  },
  	"⫥": {
  	math: "\\DashV"
  },
  	"⫦": {
  	math: "\\varVdash"
  },
  	"⫧": {
  	math: "\\Barv"
  },
  	"⫨": {
  	math: "\\vBar"
  },
  	"⫩": {
  	math: "\\vBarv"
  },
  	"⫪": {
  	math: "\\Top"
  },
  	"⫬": {
  	math: "\\Not"
  },
  	"⫭": {
  	math: "\\bNot"
  },
  	"⫮": {
  	math: "\\revnmid"
  },
  	"⫯": {
  	math: "\\cirmid"
  },
  	"⫰": {
  	math: "\\midcir"
  },
  	"⫱": {
  	math: "\\topcir"
  },
  	"⫲": {
  	math: "\\nhpar"
  },
  	"⫳": {
  	math: "\\parsim"
  },
  	"⫴": {
  	math: "\\interleave"
  },
  	"⫵": {
  	math: "\\nhVvert"
  },
  	"⫶": {
  	math: "\\Elztdcol"
  },
  	"⫷": {
  	math: "\\lllnest"
  },
  	"⫸": {
  	math: "\\gggnest"
  },
  	"⫹": {
  	math: "\\leqqslant"
  },
  	"⫺": {
  	math: "\\geqqslant"
  },
  	"⫻": {
  	math: "\\trslash"
  },
  	"⫼": {
  	math: "\\biginterleave"
  },
  	"⫽": {
  	math: "{{/}\\!\\!{/}}"
  },
  	"⫽⃥": {
  	math: "{\\rlap{\\textbackslash}{{/}\\!\\!{/}}}"
  },
  	"⫾": {
  	math: "\\talloblong"
  },
  	"⫿": {
  	math: "\\bigtalloblong"
  },
  	"⬒": {
  	math: "\\squaretopblack"
  },
  	"⬓": {
  	math: "\\squarebotblack"
  },
  	"⬔": {
  	math: "\\squareurblack"
  },
  	"⬕": {
  	math: "\\squarellblack"
  },
  	"⬖": {
  	math: "\\diamondleftblack"
  },
  	"⬗": {
  	math: "\\diamondrightblack"
  },
  	"⬘": {
  	math: "\\diamondtopblack"
  },
  	"⬙": {
  	math: "\\diamondbotblack"
  },
  	"⬚": {
  	math: "\\dottedsquare"
  },
  	"⬛": {
  	math: "\\blacksquare"
  },
  	"⬜": {
  	math: "\\square"
  },
  	"⬝": {
  	math: "\\vysmblksquare"
  },
  	"⬞": {
  	math: "\\vysmwhtsquare"
  },
  	"⬟": {
  	math: "\\pentagonblack"
  },
  	"⬠": {
  	math: "\\pentagon"
  },
  	"⬡": {
  	math: "\\varhexagon"
  },
  	"⬢": {
  	math: "\\varhexagonblack"
  },
  	"⬣": {
  	math: "\\hexagonblack"
  },
  	"⬤": {
  	math: "\\lgblkcircle"
  },
  	"⬥": {
  	math: "\\mdblkdiamond"
  },
  	"⬦": {
  	math: "\\mdwhtdiamond"
  },
  	"⬧": {
  	math: "\\mdblklozenge"
  },
  	"⬨": {
  	math: "\\mdwhtlozenge"
  },
  	"⬩": {
  	math: "\\smblkdiamond"
  },
  	"⬪": {
  	math: "\\smblklozenge"
  },
  	"⬫": {
  	math: "\\smwhtlozenge"
  },
  	"⬬": {
  	math: "\\blkhorzoval"
  },
  	"⬭": {
  	math: "\\whthorzoval"
  },
  	"⬮": {
  	math: "\\blkvertoval"
  },
  	"⬯": {
  	math: "\\whtvertoval"
  },
  	"⬰": {
  	math: "\\circleonleftarrow"
  },
  	"⬱": {
  	math: "\\leftthreearrows"
  },
  	"⬲": {
  	math: "\\leftarrowonoplus"
  },
  	"⬳": {
  	math: "\\longleftsquigarrow"
  },
  	"⬴": {
  	math: "\\nvtwoheadleftarrow"
  },
  	"⬵": {
  	math: "\\nVtwoheadleftarrow"
  },
  	"⬶": {
  	math: "\\twoheadmapsfrom"
  },
  	"⬷": {
  	math: "\\twoheadleftdbkarrow"
  },
  	"⬸": {
  	math: "\\leftdotarrow"
  },
  	"⬹": {
  	math: "\\nvleftarrowtail"
  },
  	"⬺": {
  	math: "\\nVleftarrowtail"
  },
  	"⬻": {
  	math: "\\twoheadleftarrowtail"
  },
  	"⬼": {
  	math: "\\nvtwoheadleftarrowtail"
  },
  	"⬽": {
  	math: "\\nVtwoheadleftarrowtail"
  },
  	"⬾": {
  	math: "\\leftarrowx"
  },
  	"⬿": {
  	math: "\\leftcurvedarrow"
  },
  	"⭀": {
  	math: "\\equalleftarrow"
  },
  	"⭁": {
  	math: "\\bsimilarleftarrow"
  },
  	"⭂": {
  	math: "\\leftarrowbackapprox"
  },
  	"⭃": {
  	math: "\\rightarrowgtr"
  },
  	"⭄": {
  	math: "\\rightarrowsupset"
  },
  	"⭅": {
  	math: "\\LLeftarrow"
  },
  	"⭆": {
  	math: "\\RRightarrow"
  },
  	"⭇": {
  	math: "\\bsimilarrightarrow"
  },
  	"⭈": {
  	math: "\\rightarrowbackapprox"
  },
  	"⭉": {
  	math: "\\similarleftarrow"
  },
  	"⭊": {
  	math: "\\leftarrowapprox"
  },
  	"⭋": {
  	math: "\\leftarrowbsimilar"
  },
  	"⭌": {
  	math: "\\rightarrowbsimilar"
  },
  	"⭐": {
  	math: "\\medwhitestar"
  },
  	"⭑": {
  	math: "\\medblackstar"
  },
  	"⭒": {
  	math: "\\smwhitestar"
  },
  	"⭓": {
  	math: "\\rightpentagonblack"
  },
  	"⭔": {
  	math: "\\rightpentagon"
  },
  	"〈": {
  	math: "\\langle"
  },
  	"〉": {
  	math: "\\rangle"
  },
  	"〒": {
  	math: "\\postalmark"
  },
  	"〔": {
  	math: "\\lbrbrak"
  },
  	"〕": {
  	math: "\\rbrbrak"
  },
  	"〚": {
  	math: "\\openbracketleft"
  },
  	"〛": {
  	math: "\\openbracketright"
  },
  	"〰": {
  	math: "\\hzigzag"
  },
  	"ﬀ": {
  	text: "ff"
  },
  	"ﬁ": {
  	text: "fi"
  },
  	"ﬂ": {
  	text: "fl"
  },
  	"ﬃ": {
  	text: "ffi"
  },
  	"ﬄ": {
  	text: "ffl"
  },
  	"ﬅ": {
  	text: "st"
  },
  	"ﬆ": {
  	text: "st"
  },
  	"�": {
  	text: "{\\dbend}"
  },
  	"𝐀": {
  	math: "\\mathbf{A}"
  },
  	"𝐁": {
  	math: "\\mathbf{B}"
  },
  	"𝐂": {
  	math: "\\mathbf{C}"
  },
  	"𝐃": {
  	math: "\\mathbf{D}"
  },
  	"𝐄": {
  	math: "\\mathbf{E}"
  },
  	"𝐅": {
  	math: "\\mathbf{F}"
  },
  	"𝐆": {
  	math: "\\mathbf{G}"
  },
  	"𝐇": {
  	math: "\\mathbf{H}"
  },
  	"𝐈": {
  	math: "\\mathbf{I}"
  },
  	"𝐉": {
  	math: "\\mathbf{J}"
  },
  	"𝐊": {
  	math: "\\mathbf{K}"
  },
  	"𝐋": {
  	math: "\\mathbf{L}"
  },
  	"𝐌": {
  	math: "\\mathbf{M}"
  },
  	"𝐍": {
  	math: "\\mathbf{N}"
  },
  	"𝐎": {
  	math: "\\mathbf{O}"
  },
  	"𝐏": {
  	math: "\\mathbf{P}"
  },
  	"𝐐": {
  	math: "\\mathbf{Q}"
  },
  	"𝐑": {
  	math: "\\mathbf{R}"
  },
  	"𝐒": {
  	math: "\\mathbf{S}"
  },
  	"𝐓": {
  	math: "\\mathbf{T}"
  },
  	"𝐔": {
  	math: "\\mathbf{U}"
  },
  	"𝐕": {
  	math: "\\mathbf{V}"
  },
  	"𝐖": {
  	math: "\\mathbf{W}"
  },
  	"𝐗": {
  	math: "\\mathbf{X}"
  },
  	"𝐘": {
  	math: "\\mathbf{Y}"
  },
  	"𝐙": {
  	math: "\\mathbf{Z}"
  },
  	"𝐚": {
  	math: "\\mathbf{a}"
  },
  	"𝐛": {
  	math: "\\mathbf{b}"
  },
  	"𝐜": {
  	math: "\\mathbf{c}"
  },
  	"𝐝": {
  	math: "\\mathbf{d}"
  },
  	"𝐞": {
  	math: "\\mathbf{e}"
  },
  	"𝐟": {
  	math: "\\mathbf{f}"
  },
  	"𝐠": {
  	math: "\\mathbf{g}"
  },
  	"𝐡": {
  	math: "\\mathbf{h}"
  },
  	"𝐢": {
  	math: "\\mathbf{i}"
  },
  	"𝐣": {
  	math: "\\mathbf{j}"
  },
  	"𝐤": {
  	math: "\\mathbf{k}"
  },
  	"𝐥": {
  	math: "\\mathbf{l}"
  },
  	"𝐦": {
  	math: "\\mathbf{m}"
  },
  	"𝐧": {
  	math: "\\mathbf{n}"
  },
  	"𝐨": {
  	math: "\\mathbf{o}"
  },
  	"𝐩": {
  	math: "\\mathbf{p}"
  },
  	"𝐪": {
  	math: "\\mathbf{q}"
  },
  	"𝐫": {
  	math: "\\mathbf{r}"
  },
  	"𝐬": {
  	math: "\\mathbf{s}"
  },
  	"𝐭": {
  	math: "\\mathbf{t}"
  },
  	"𝐮": {
  	math: "\\mathbf{u}"
  },
  	"𝐯": {
  	math: "\\mathbf{v}"
  },
  	"𝐰": {
  	math: "\\mathbf{w}"
  },
  	"𝐱": {
  	math: "\\mathbf{x}"
  },
  	"𝐲": {
  	math: "\\mathbf{y}"
  },
  	"𝐳": {
  	math: "\\mathbf{z}"
  },
  	"𝐴": {
  	math: "\\mathsl{A}"
  },
  	"𝐵": {
  	math: "\\mathsl{B}"
  },
  	"𝐶": {
  	math: "\\mathsl{C}"
  },
  	"𝐷": {
  	math: "\\mathsl{D}"
  },
  	"𝐸": {
  	math: "\\mathsl{E}"
  },
  	"𝐹": {
  	math: "\\mathsl{F}"
  },
  	"𝐺": {
  	math: "\\mathsl{G}"
  },
  	"𝐻": {
  	math: "\\mathsl{H}"
  },
  	"𝐼": {
  	math: "\\mathsl{I}"
  },
  	"𝐽": {
  	math: "\\mathsl{J}"
  },
  	"𝐾": {
  	math: "\\mathsl{K}"
  },
  	"𝐿": {
  	math: "\\mathsl{L}"
  },
  	"𝑀": {
  	math: "\\mathsl{M}"
  },
  	"𝑁": {
  	math: "\\mathsl{N}"
  },
  	"𝑂": {
  	math: "\\mathsl{O}"
  },
  	"𝑃": {
  	math: "\\mathsl{P}"
  },
  	"𝑄": {
  	math: "\\mathsl{Q}"
  },
  	"𝑅": {
  	math: "\\mathsl{R}"
  },
  	"𝑆": {
  	math: "\\mathsl{S}"
  },
  	"𝑇": {
  	math: "\\mathsl{T}"
  },
  	"𝑈": {
  	math: "\\mathsl{U}"
  },
  	"𝑉": {
  	math: "\\mathsl{V}"
  },
  	"𝑊": {
  	math: "\\mathsl{W}"
  },
  	"𝑋": {
  	math: "\\mathsl{X}"
  },
  	"𝑌": {
  	math: "\\mathsl{Y}"
  },
  	"𝑍": {
  	math: "\\mathsl{Z}"
  },
  	"𝑎": {
  	math: "\\mathsl{a}"
  },
  	"𝑏": {
  	math: "\\mathsl{b}"
  },
  	"𝑐": {
  	math: "\\mathsl{c}"
  },
  	"𝑑": {
  	math: "\\mathsl{d}"
  },
  	"𝑒": {
  	math: "\\mathsl{e}"
  },
  	"𝑓": {
  	math: "\\mathsl{f}"
  },
  	"𝑔": {
  	math: "\\mathsl{g}"
  },
  	"𝑖": {
  	math: "\\mathsl{i}"
  },
  	"𝑗": {
  	math: "\\mathsl{j}"
  },
  	"𝑘": {
  	math: "\\mathsl{k}"
  },
  	"𝑙": {
  	math: "\\mathsl{l}"
  },
  	"𝑚": {
  	math: "\\mathsl{m}"
  },
  	"𝑛": {
  	math: "\\mathsl{n}"
  },
  	"𝑜": {
  	math: "\\mathsl{o}"
  },
  	"𝑝": {
  	math: "\\mathsl{p}"
  },
  	"𝑞": {
  	math: "\\mathsl{q}"
  },
  	"𝑟": {
  	math: "\\mathsl{r}"
  },
  	"𝑠": {
  	math: "\\mathsl{s}"
  },
  	"𝑡": {
  	math: "\\mathsl{t}"
  },
  	"𝑢": {
  	math: "\\mathsl{u}"
  },
  	"𝑣": {
  	math: "\\mathsl{v}"
  },
  	"𝑤": {
  	math: "\\mathsl{w}"
  },
  	"𝑥": {
  	math: "\\mathsl{x}"
  },
  	"𝑦": {
  	math: "\\mathsl{y}"
  },
  	"𝑧": {
  	math: "\\mathsl{z}"
  },
  	"𝑨": {
  	math: "\\mathbit{A}"
  },
  	"𝑩": {
  	math: "\\mathbit{B}"
  },
  	"𝑪": {
  	math: "\\mathbit{C}"
  },
  	"𝑫": {
  	math: "\\mathbit{D}"
  },
  	"𝑬": {
  	math: "\\mathbit{E}"
  },
  	"𝑭": {
  	math: "\\mathbit{F}"
  },
  	"𝑮": {
  	math: "\\mathbit{G}"
  },
  	"𝑯": {
  	math: "\\mathbit{H}"
  },
  	"𝑰": {
  	math: "\\mathbit{I}"
  },
  	"𝑱": {
  	math: "\\mathbit{J}"
  },
  	"𝑲": {
  	math: "\\mathbit{K}"
  },
  	"𝑳": {
  	math: "\\mathbit{L}"
  },
  	"𝑴": {
  	math: "\\mathbit{M}"
  },
  	"𝑵": {
  	math: "\\mathbit{N}"
  },
  	"𝑶": {
  	math: "\\mathbit{O}"
  },
  	"𝑷": {
  	math: "\\mathbit{P}"
  },
  	"𝑸": {
  	math: "\\mathbit{Q}"
  },
  	"𝑹": {
  	math: "\\mathbit{R}"
  },
  	"𝑺": {
  	math: "\\mathbit{S}"
  },
  	"𝑻": {
  	math: "\\mathbit{T}"
  },
  	"𝑼": {
  	math: "\\mathbit{U}"
  },
  	"𝑽": {
  	math: "\\mathbit{V}"
  },
  	"𝑾": {
  	math: "\\mathbit{W}"
  },
  	"𝑿": {
  	math: "\\mathbit{X}"
  },
  	"𝒀": {
  	math: "\\mathbit{Y}"
  },
  	"𝒁": {
  	math: "\\mathbit{Z}"
  },
  	"𝒂": {
  	math: "\\mathbit{a}"
  },
  	"𝒃": {
  	math: "\\mathbit{b}"
  },
  	"𝒄": {
  	math: "\\mathbit{c}"
  },
  	"𝒅": {
  	math: "\\mathbit{d}"
  },
  	"𝒆": {
  	math: "\\mathbit{e}"
  },
  	"𝒇": {
  	math: "\\mathbit{f}"
  },
  	"𝒈": {
  	math: "\\mathbit{g}"
  },
  	"𝒉": {
  	math: "\\mathbit{h}"
  },
  	"𝒊": {
  	math: "\\mathbit{i}"
  },
  	"𝒋": {
  	math: "\\mathbit{j}"
  },
  	"𝒌": {
  	math: "\\mathbit{k}"
  },
  	"𝒍": {
  	math: "\\mathbit{l}"
  },
  	"𝒎": {
  	math: "\\mathbit{m}"
  },
  	"𝒏": {
  	math: "\\mathbit{n}"
  },
  	"𝒐": {
  	math: "\\mathbit{o}"
  },
  	"𝒑": {
  	math: "\\mathbit{p}"
  },
  	"𝒒": {
  	math: "\\mathbit{q}"
  },
  	"𝒓": {
  	math: "\\mathbit{r}"
  },
  	"𝒔": {
  	math: "\\mathbit{s}"
  },
  	"𝒕": {
  	math: "\\mathbit{t}"
  },
  	"𝒖": {
  	math: "\\mathbit{u}"
  },
  	"𝒗": {
  	math: "\\mathbit{v}"
  },
  	"𝒘": {
  	math: "\\mathbit{w}"
  },
  	"𝒙": {
  	math: "\\mathbit{x}"
  },
  	"𝒚": {
  	math: "\\mathbit{y}"
  },
  	"𝒛": {
  	math: "\\mathbit{z}"
  },
  	"𝒜": {
  	math: "\\mathscr{A}"
  },
  	"𝒞": {
  	math: "\\mathscr{C}"
  },
  	"𝒟": {
  	math: "\\mathscr{D}"
  },
  	"𝒢": {
  	math: "\\mathscr{G}"
  },
  	"𝒥": {
  	math: "\\mathscr{J}"
  },
  	"𝒦": {
  	math: "\\mathscr{K}"
  },
  	"𝒩": {
  	math: "\\mathscr{N}"
  },
  	"𝒪": {
  	math: "\\mathscr{O}"
  },
  	"𝒫": {
  	math: "\\mathscr{P}"
  },
  	"𝒬": {
  	math: "\\mathscr{Q}"
  },
  	"𝒮": {
  	math: "\\mathscr{S}"
  },
  	"𝒯": {
  	math: "\\mathscr{T}"
  },
  	"𝒰": {
  	math: "\\mathscr{U}"
  },
  	"𝒱": {
  	math: "\\mathscr{V}"
  },
  	"𝒲": {
  	math: "\\mathscr{W}"
  },
  	"𝒳": {
  	math: "\\mathscr{X}"
  },
  	"𝒴": {
  	math: "\\mathscr{Y}"
  },
  	"𝒵": {
  	math: "\\mathscr{Z}"
  },
  	"𝒶": {
  	math: "\\mathscr{a}"
  },
  	"𝒷": {
  	math: "\\mathscr{b}"
  },
  	"𝒸": {
  	math: "\\mathscr{c}"
  },
  	"𝒹": {
  	math: "\\mathscr{d}"
  },
  	"𝒻": {
  	math: "\\mathscr{f}"
  },
  	"𝒽": {
  	math: "\\mathscr{h}"
  },
  	"𝒾": {
  	math: "\\mathscr{i}"
  },
  	"𝒿": {
  	math: "\\mathscr{j}"
  },
  	"𝓀": {
  	math: "\\mathscr{k}"
  },
  	"𝓁": {
  	math: "\\mathscr{l}"
  },
  	"𝓂": {
  	math: "\\mathscr{m}"
  },
  	"𝓃": {
  	math: "\\mathscr{n}"
  },
  	"𝓅": {
  	math: "\\mathscr{p}"
  },
  	"𝓆": {
  	math: "\\mathscr{q}"
  },
  	"𝓇": {
  	math: "\\mathscr{r}"
  },
  	"𝓈": {
  	math: "\\mathscr{s}"
  },
  	"𝓉": {
  	math: "\\mathscr{t}"
  },
  	"𝓊": {
  	math: "\\mathscr{u}"
  },
  	"𝓋": {
  	math: "\\mathscr{v}"
  },
  	"𝓌": {
  	math: "\\mathscr{w}"
  },
  	"𝓍": {
  	math: "\\mathscr{x}"
  },
  	"𝓎": {
  	math: "\\mathscr{y}"
  },
  	"𝓏": {
  	math: "\\mathscr{z}"
  },
  	"𝓐": {
  	math: "\\mathmit{A}"
  },
  	"𝓑": {
  	math: "\\mathmit{B}"
  },
  	"𝓒": {
  	math: "\\mathmit{C}"
  },
  	"𝓓": {
  	math: "\\mathmit{D}"
  },
  	"𝓔": {
  	math: "\\mathmit{E}"
  },
  	"𝓕": {
  	math: "\\mathmit{F}"
  },
  	"𝓖": {
  	math: "\\mathmit{G}"
  },
  	"𝓗": {
  	math: "\\mathmit{H}"
  },
  	"𝓘": {
  	math: "\\mathmit{I}"
  },
  	"𝓙": {
  	math: "\\mathmit{J}"
  },
  	"𝓚": {
  	math: "\\mathmit{K}"
  },
  	"𝓛": {
  	math: "\\mathmit{L}"
  },
  	"𝓜": {
  	math: "\\mathmit{M}"
  },
  	"𝓝": {
  	math: "\\mathmit{N}"
  },
  	"𝓞": {
  	math: "\\mathmit{O}"
  },
  	"𝓟": {
  	math: "\\mathmit{P}"
  },
  	"𝓠": {
  	math: "\\mathmit{Q}"
  },
  	"𝓡": {
  	math: "\\mathmit{R}"
  },
  	"𝓢": {
  	math: "\\mathmit{S}"
  },
  	"𝓣": {
  	math: "\\mathmit{T}"
  },
  	"𝓤": {
  	math: "\\mathmit{U}"
  },
  	"𝓥": {
  	math: "\\mathmit{V}"
  },
  	"𝓦": {
  	math: "\\mathmit{W}"
  },
  	"𝓧": {
  	math: "\\mathmit{X}"
  },
  	"𝓨": {
  	math: "\\mathmit{Y}"
  },
  	"𝓩": {
  	math: "\\mathmit{Z}"
  },
  	"𝓪": {
  	math: "\\mathmit{a}"
  },
  	"𝓫": {
  	math: "\\mathmit{b}"
  },
  	"𝓬": {
  	math: "\\mathmit{c}"
  },
  	"𝓭": {
  	math: "\\mathmit{d}"
  },
  	"𝓮": {
  	math: "\\mathmit{e}"
  },
  	"𝓯": {
  	math: "\\mathmit{f}"
  },
  	"𝓰": {
  	math: "\\mathmit{g}"
  },
  	"𝓱": {
  	math: "\\mathmit{h}"
  },
  	"𝓲": {
  	math: "\\mathmit{i}"
  },
  	"𝓳": {
  	math: "\\mathmit{j}"
  },
  	"𝓴": {
  	math: "\\mathmit{k}"
  },
  	"𝓵": {
  	math: "\\mathmit{l}"
  },
  	"𝓶": {
  	math: "\\mathmit{m}"
  },
  	"𝓷": {
  	math: "\\mathmit{n}"
  },
  	"𝓸": {
  	math: "\\mathmit{o}"
  },
  	"𝓹": {
  	math: "\\mathmit{p}"
  },
  	"𝓺": {
  	math: "\\mathmit{q}"
  },
  	"𝓻": {
  	math: "\\mathmit{r}"
  },
  	"𝓼": {
  	math: "\\mathmit{s}"
  },
  	"𝓽": {
  	math: "\\mathmit{t}"
  },
  	"𝓾": {
  	math: "\\mathmit{u}"
  },
  	"𝓿": {
  	math: "\\mathmit{v}"
  },
  	"𝔀": {
  	math: "\\mathmit{w}"
  },
  	"𝔁": {
  	math: "\\mathmit{x}"
  },
  	"𝔂": {
  	math: "\\mathmit{y}"
  },
  	"𝔃": {
  	math: "\\mathmit{z}"
  },
  	"𝔄": {
  	math: "\\mathfrak{A}"
  },
  	"𝔅": {
  	math: "\\mathfrak{B}"
  },
  	"𝔇": {
  	math: "\\mathfrak{D}"
  },
  	"𝔈": {
  	math: "\\mathfrak{E}"
  },
  	"𝔉": {
  	math: "\\mathfrak{F}"
  },
  	"𝔊": {
  	math: "\\mathfrak{G}"
  },
  	"𝔍": {
  	math: "\\mathfrak{J}"
  },
  	"𝔎": {
  	math: "\\mathfrak{K}"
  },
  	"𝔏": {
  	math: "\\mathfrak{L}"
  },
  	"𝔐": {
  	math: "\\mathfrak{M}"
  },
  	"𝔑": {
  	math: "\\mathfrak{N}"
  },
  	"𝔒": {
  	math: "\\mathfrak{O}"
  },
  	"𝔓": {
  	math: "\\mathfrak{P}"
  },
  	"𝔔": {
  	math: "\\mathfrak{Q}"
  },
  	"𝔖": {
  	math: "\\mathfrak{S}"
  },
  	"𝔗": {
  	math: "\\mathfrak{T}"
  },
  	"𝔘": {
  	math: "\\mathfrak{U}"
  },
  	"𝔙": {
  	math: "\\mathfrak{V}"
  },
  	"𝔚": {
  	math: "\\mathfrak{W}"
  },
  	"𝔛": {
  	math: "\\mathfrak{X}"
  },
  	"𝔜": {
  	math: "\\mathfrak{Y}"
  },
  	"𝔞": {
  	math: "\\mathfrak{a}"
  },
  	"𝔟": {
  	math: "\\mathfrak{b}"
  },
  	"𝔠": {
  	math: "\\mathfrak{c}"
  },
  	"𝔡": {
  	math: "\\mathfrak{d}"
  },
  	"𝔢": {
  	math: "\\mathfrak{e}"
  },
  	"𝔣": {
  	math: "\\mathfrak{f}"
  },
  	"𝔤": {
  	math: "\\mathfrak{g}"
  },
  	"𝔥": {
  	math: "\\mathfrak{h}"
  },
  	"𝔦": {
  	math: "\\mathfrak{i}"
  },
  	"𝔧": {
  	math: "\\mathfrak{j}"
  },
  	"𝔨": {
  	math: "\\mathfrak{k}"
  },
  	"𝔩": {
  	math: "\\mathfrak{l}"
  },
  	"𝔪": {
  	math: "\\mathfrak{m}"
  },
  	"𝔫": {
  	math: "\\mathfrak{n}"
  },
  	"𝔬": {
  	math: "\\mathfrak{o}"
  },
  	"𝔭": {
  	math: "\\mathfrak{p}"
  },
  	"𝔮": {
  	math: "\\mathfrak{q}"
  },
  	"𝔯": {
  	math: "\\mathfrak{r}"
  },
  	"𝔰": {
  	math: "\\mathfrak{s}"
  },
  	"𝔱": {
  	math: "\\mathfrak{t}"
  },
  	"𝔲": {
  	math: "\\mathfrak{u}"
  },
  	"𝔳": {
  	math: "\\mathfrak{v}"
  },
  	"𝔴": {
  	math: "\\mathfrak{w}"
  },
  	"𝔵": {
  	math: "\\mathfrak{x}"
  },
  	"𝔶": {
  	math: "\\mathfrak{y}"
  },
  	"𝔷": {
  	math: "\\mathfrak{z}"
  },
  	"𝔸": {
  	math: "\\mathbb{A}"
  },
  	"𝔹": {
  	math: "\\mathbb{B}"
  },
  	"𝔻": {
  	math: "\\mathbb{D}"
  },
  	"𝔼": {
  	math: "\\mathbb{E}"
  },
  	"𝔽": {
  	math: "\\mathbb{F}"
  },
  	"𝔾": {
  	math: "\\mathbb{G}"
  },
  	"𝕀": {
  	math: "\\mathbb{I}"
  },
  	"𝕁": {
  	math: "\\mathbb{J}"
  },
  	"𝕂": {
  	math: "\\mathbb{K}"
  },
  	"𝕃": {
  	math: "\\mathbb{L}"
  },
  	"𝕄": {
  	math: "\\mathbb{M}"
  },
  	"𝕆": {
  	math: "\\mathbb{O}"
  },
  	"𝕊": {
  	math: "\\mathbb{S}"
  },
  	"𝕋": {
  	math: "\\mathbb{T}"
  },
  	"𝕌": {
  	math: "\\mathbb{U}"
  },
  	"𝕍": {
  	math: "\\mathbb{V}"
  },
  	"𝕎": {
  	math: "\\mathbb{W}"
  },
  	"𝕏": {
  	math: "\\mathbb{X}"
  },
  	"𝕐": {
  	math: "\\mathbb{Y}"
  },
  	"𝕒": {
  	math: "\\mathbb{a}"
  },
  	"𝕓": {
  	math: "\\mathbb{b}"
  },
  	"𝕔": {
  	math: "\\mathbb{c}"
  },
  	"𝕕": {
  	math: "\\mathbb{d}"
  },
  	"𝕖": {
  	math: "\\mathbb{e}"
  },
  	"𝕗": {
  	math: "\\mathbb{f}"
  },
  	"𝕘": {
  	math: "\\mathbb{g}"
  },
  	"𝕙": {
  	math: "\\mathbb{h}"
  },
  	"𝕚": {
  	math: "\\mathbb{i}"
  },
  	"𝕛": {
  	math: "\\mathbb{j}"
  },
  	"𝕜": {
  	math: "\\mathbb{k}"
  },
  	"𝕝": {
  	math: "\\mathbb{l}"
  },
  	"𝕞": {
  	math: "\\mathbb{m}"
  },
  	"𝕟": {
  	math: "\\mathbb{n}"
  },
  	"𝕠": {
  	math: "\\mathbb{o}"
  },
  	"𝕡": {
  	math: "\\mathbb{p}"
  },
  	"𝕢": {
  	math: "\\mathbb{q}"
  },
  	"𝕣": {
  	math: "\\mathbb{r}"
  },
  	"𝕤": {
  	math: "\\mathbb{s}"
  },
  	"𝕥": {
  	math: "\\mathbb{t}"
  },
  	"𝕦": {
  	math: "\\mathbb{u}"
  },
  	"𝕧": {
  	math: "\\mathbb{v}"
  },
  	"𝕨": {
  	math: "\\mathbb{w}"
  },
  	"𝕩": {
  	math: "\\mathbb{x}"
  },
  	"𝕪": {
  	math: "\\mathbb{y}"
  },
  	"𝕫": {
  	math: "\\mathbb{z}"
  },
  	"𝕬": {
  	math: "\\mathslbb{A}"
  },
  	"𝕭": {
  	math: "\\mathslbb{B}"
  },
  	"𝕮": {
  	math: "\\mathslbb{C}"
  },
  	"𝕯": {
  	math: "\\mathslbb{D}"
  },
  	"𝕰": {
  	math: "\\mathslbb{E}"
  },
  	"𝕱": {
  	math: "\\mathslbb{F}"
  },
  	"𝕲": {
  	math: "\\mathslbb{G}"
  },
  	"𝕳": {
  	math: "\\mathslbb{H}"
  },
  	"𝕴": {
  	math: "\\mathslbb{I}"
  },
  	"𝕵": {
  	math: "\\mathslbb{J}"
  },
  	"𝕶": {
  	math: "\\mathslbb{K}"
  },
  	"𝕷": {
  	math: "\\mathslbb{L}"
  },
  	"𝕸": {
  	math: "\\mathslbb{M}"
  },
  	"𝕹": {
  	math: "\\mathslbb{N}"
  },
  	"𝕺": {
  	math: "\\mathslbb{O}"
  },
  	"𝕻": {
  	math: "\\mathslbb{P}"
  },
  	"𝕼": {
  	math: "\\mathslbb{Q}"
  },
  	"𝕽": {
  	math: "\\mathslbb{R}"
  },
  	"𝕾": {
  	math: "\\mathslbb{S}"
  },
  	"𝕿": {
  	math: "\\mathslbb{T}"
  },
  	"𝖀": {
  	math: "\\mathslbb{U}"
  },
  	"𝖁": {
  	math: "\\mathslbb{V}"
  },
  	"𝖂": {
  	math: "\\mathslbb{W}"
  },
  	"𝖃": {
  	math: "\\mathslbb{X}"
  },
  	"𝖄": {
  	math: "\\mathslbb{Y}"
  },
  	"𝖅": {
  	math: "\\mathslbb{Z}"
  },
  	"𝖆": {
  	math: "\\mathslbb{a}"
  },
  	"𝖇": {
  	math: "\\mathslbb{b}"
  },
  	"𝖈": {
  	math: "\\mathslbb{c}"
  },
  	"𝖉": {
  	math: "\\mathslbb{d}"
  },
  	"𝖊": {
  	math: "\\mathslbb{e}"
  },
  	"𝖋": {
  	math: "\\mathslbb{f}"
  },
  	"𝖌": {
  	math: "\\mathslbb{g}"
  },
  	"𝖍": {
  	math: "\\mathslbb{h}"
  },
  	"𝖎": {
  	math: "\\mathslbb{i}"
  },
  	"𝖏": {
  	math: "\\mathslbb{j}"
  },
  	"𝖐": {
  	math: "\\mathslbb{k}"
  },
  	"𝖑": {
  	math: "\\mathslbb{l}"
  },
  	"𝖒": {
  	math: "\\mathslbb{m}"
  },
  	"𝖓": {
  	math: "\\mathslbb{n}"
  },
  	"𝖔": {
  	math: "\\mathslbb{o}"
  },
  	"𝖕": {
  	math: "\\mathslbb{p}"
  },
  	"𝖖": {
  	math: "\\mathslbb{q}"
  },
  	"𝖗": {
  	math: "\\mathslbb{r}"
  },
  	"𝖘": {
  	math: "\\mathslbb{s}"
  },
  	"𝖙": {
  	math: "\\mathslbb{t}"
  },
  	"𝖚": {
  	math: "\\mathslbb{u}"
  },
  	"𝖛": {
  	math: "\\mathslbb{v}"
  },
  	"𝖜": {
  	math: "\\mathslbb{w}"
  },
  	"𝖝": {
  	math: "\\mathslbb{x}"
  },
  	"𝖞": {
  	math: "\\mathslbb{y}"
  },
  	"𝖟": {
  	math: "\\mathslbb{z}"
  },
  	"𝖠": {
  	math: "\\mathsf{A}"
  },
  	"𝖡": {
  	math: "\\mathsf{B}"
  },
  	"𝖢": {
  	math: "\\mathsf{C}"
  },
  	"𝖣": {
  	math: "\\mathsf{D}"
  },
  	"𝖤": {
  	math: "\\mathsf{E}"
  },
  	"𝖥": {
  	math: "\\mathsf{F}"
  },
  	"𝖦": {
  	math: "\\mathsf{G}"
  },
  	"𝖧": {
  	math: "\\mathsf{H}"
  },
  	"𝖨": {
  	math: "\\mathsf{I}"
  },
  	"𝖩": {
  	math: "\\mathsf{J}"
  },
  	"𝖪": {
  	math: "\\mathsf{K}"
  },
  	"𝖫": {
  	math: "\\mathsf{L}"
  },
  	"𝖬": {
  	math: "\\mathsf{M}"
  },
  	"𝖭": {
  	math: "\\mathsf{N}"
  },
  	"𝖮": {
  	math: "\\mathsf{O}"
  },
  	"𝖯": {
  	math: "\\mathsf{P}"
  },
  	"𝖰": {
  	math: "\\mathsf{Q}"
  },
  	"𝖱": {
  	math: "\\mathsf{R}"
  },
  	"𝖲": {
  	math: "\\mathsf{S}"
  },
  	"𝖳": {
  	math: "\\mathsf{T}"
  },
  	"𝖴": {
  	math: "\\mathsf{U}"
  },
  	"𝖵": {
  	math: "\\mathsf{V}"
  },
  	"𝖶": {
  	math: "\\mathsf{W}"
  },
  	"𝖷": {
  	math: "\\mathsf{X}"
  },
  	"𝖸": {
  	math: "\\mathsf{Y}"
  },
  	"𝖹": {
  	math: "\\mathsf{Z}"
  },
  	"𝖺": {
  	math: "\\mathsf{a}"
  },
  	"𝖻": {
  	math: "\\mathsf{b}"
  },
  	"𝖼": {
  	math: "\\mathsf{c}"
  },
  	"𝖽": {
  	math: "\\mathsf{d}"
  },
  	"𝖾": {
  	math: "\\mathsf{e}"
  },
  	"𝖿": {
  	math: "\\mathsf{f}"
  },
  	"𝗀": {
  	math: "\\mathsf{g}"
  },
  	"𝗁": {
  	math: "\\mathsf{h}"
  },
  	"𝗂": {
  	math: "\\mathsf{i}"
  },
  	"𝗃": {
  	math: "\\mathsf{j}"
  },
  	"𝗄": {
  	math: "\\mathsf{k}"
  },
  	"𝗅": {
  	math: "\\mathsf{l}"
  },
  	"𝗆": {
  	math: "\\mathsf{m}"
  },
  	"𝗇": {
  	math: "\\mathsf{n}"
  },
  	"𝗈": {
  	math: "\\mathsf{o}"
  },
  	"𝗉": {
  	math: "\\mathsf{p}"
  },
  	"𝗊": {
  	math: "\\mathsf{q}"
  },
  	"𝗋": {
  	math: "\\mathsf{r}"
  },
  	"𝗌": {
  	math: "\\mathsf{s}"
  },
  	"𝗍": {
  	math: "\\mathsf{t}"
  },
  	"𝗎": {
  	math: "\\mathsf{u}"
  },
  	"𝗏": {
  	math: "\\mathsf{v}"
  },
  	"𝗐": {
  	math: "\\mathsf{w}"
  },
  	"𝗑": {
  	math: "\\mathsf{x}"
  },
  	"𝗒": {
  	math: "\\mathsf{y}"
  },
  	"𝗓": {
  	math: "\\mathsf{z}"
  },
  	"𝗔": {
  	math: "\\mathsfbf{A}"
  },
  	"𝗕": {
  	math: "\\mathsfbf{B}"
  },
  	"𝗖": {
  	math: "\\mathsfbf{C}"
  },
  	"𝗗": {
  	math: "\\mathsfbf{D}"
  },
  	"𝗘": {
  	math: "\\mathsfbf{E}"
  },
  	"𝗙": {
  	math: "\\mathsfbf{F}"
  },
  	"𝗚": {
  	math: "\\mathsfbf{G}"
  },
  	"𝗛": {
  	math: "\\mathsfbf{H}"
  },
  	"𝗜": {
  	math: "\\mathsfbf{I}"
  },
  	"𝗝": {
  	math: "\\mathsfbf{J}"
  },
  	"𝗞": {
  	math: "\\mathsfbf{K}"
  },
  	"𝗟": {
  	math: "\\mathsfbf{L}"
  },
  	"𝗠": {
  	math: "\\mathsfbf{M}"
  },
  	"𝗡": {
  	math: "\\mathsfbf{N}"
  },
  	"𝗢": {
  	math: "\\mathsfbf{O}"
  },
  	"𝗣": {
  	math: "\\mathsfbf{P}"
  },
  	"𝗤": {
  	math: "\\mathsfbf{Q}"
  },
  	"𝗥": {
  	math: "\\mathsfbf{R}"
  },
  	"𝗦": {
  	math: "\\mathsfbf{S}"
  },
  	"𝗧": {
  	math: "\\mathsfbf{T}"
  },
  	"𝗨": {
  	math: "\\mathsfbf{U}"
  },
  	"𝗩": {
  	math: "\\mathsfbf{V}"
  },
  	"𝗪": {
  	math: "\\mathsfbf{W}"
  },
  	"𝗫": {
  	math: "\\mathsfbf{X}"
  },
  	"𝗬": {
  	math: "\\mathsfbf{Y}"
  },
  	"𝗭": {
  	math: "\\mathsfbf{Z}"
  },
  	"𝗮": {
  	math: "\\mathsfbf{a}"
  },
  	"𝗯": {
  	math: "\\mathsfbf{b}"
  },
  	"𝗰": {
  	math: "\\mathsfbf{c}"
  },
  	"𝗱": {
  	math: "\\mathsfbf{d}"
  },
  	"𝗲": {
  	math: "\\mathsfbf{e}"
  },
  	"𝗳": {
  	math: "\\mathsfbf{f}"
  },
  	"𝗴": {
  	math: "\\mathsfbf{g}"
  },
  	"𝗵": {
  	math: "\\mathsfbf{h}"
  },
  	"𝗶": {
  	math: "\\mathsfbf{i}"
  },
  	"𝗷": {
  	math: "\\mathsfbf{j}"
  },
  	"𝗸": {
  	math: "\\mathsfbf{k}"
  },
  	"𝗹": {
  	math: "\\mathsfbf{l}"
  },
  	"𝗺": {
  	math: "\\mathsfbf{m}"
  },
  	"𝗻": {
  	math: "\\mathsfbf{n}"
  },
  	"𝗼": {
  	math: "\\mathsfbf{o}"
  },
  	"𝗽": {
  	math: "\\mathsfbf{p}"
  },
  	"𝗾": {
  	math: "\\mathsfbf{q}"
  },
  	"𝗿": {
  	math: "\\mathsfbf{r}"
  },
  	"𝘀": {
  	math: "\\mathsfbf{s}"
  },
  	"𝘁": {
  	math: "\\mathsfbf{t}"
  },
  	"𝘂": {
  	math: "\\mathsfbf{u}"
  },
  	"𝘃": {
  	math: "\\mathsfbf{v}"
  },
  	"𝘄": {
  	math: "\\mathsfbf{w}"
  },
  	"𝘅": {
  	math: "\\mathsfbf{x}"
  },
  	"𝘆": {
  	math: "\\mathsfbf{y}"
  },
  	"𝘇": {
  	math: "\\mathsfbf{z}"
  },
  	"𝘈": {
  	math: "\\mathsfsl{A}"
  },
  	"𝘉": {
  	math: "\\mathsfsl{B}"
  },
  	"𝘊": {
  	math: "\\mathsfsl{C}"
  },
  	"𝘋": {
  	math: "\\mathsfsl{D}"
  },
  	"𝘌": {
  	math: "\\mathsfsl{E}"
  },
  	"𝘍": {
  	math: "\\mathsfsl{F}"
  },
  	"𝘎": {
  	math: "\\mathsfsl{G}"
  },
  	"𝘏": {
  	math: "\\mathsfsl{H}"
  },
  	"𝘐": {
  	math: "\\mathsfsl{I}"
  },
  	"𝘑": {
  	math: "\\mathsfsl{J}"
  },
  	"𝘒": {
  	math: "\\mathsfsl{K}"
  },
  	"𝘓": {
  	math: "\\mathsfsl{L}"
  },
  	"𝘔": {
  	math: "\\mathsfsl{M}"
  },
  	"𝘕": {
  	math: "\\mathsfsl{N}"
  },
  	"𝘖": {
  	math: "\\mathsfsl{O}"
  },
  	"𝘗": {
  	math: "\\mathsfsl{P}"
  },
  	"𝘘": {
  	math: "\\mathsfsl{Q}"
  },
  	"𝘙": {
  	math: "\\mathsfsl{R}"
  },
  	"𝘚": {
  	math: "\\mathsfsl{S}"
  },
  	"𝘛": {
  	math: "\\mathsfsl{T}"
  },
  	"𝘜": {
  	math: "\\mathsfsl{U}"
  },
  	"𝘝": {
  	math: "\\mathsfsl{V}"
  },
  	"𝘞": {
  	math: "\\mathsfsl{W}"
  },
  	"𝘟": {
  	math: "\\mathsfsl{X}"
  },
  	"𝘠": {
  	math: "\\mathsfsl{Y}"
  },
  	"𝘡": {
  	math: "\\mathsfsl{Z}"
  },
  	"𝘢": {
  	math: "\\mathsfsl{a}"
  },
  	"𝘣": {
  	math: "\\mathsfsl{b}"
  },
  	"𝘤": {
  	math: "\\mathsfsl{c}"
  },
  	"𝘥": {
  	math: "\\mathsfsl{d}"
  },
  	"𝘦": {
  	math: "\\mathsfsl{e}"
  },
  	"𝘧": {
  	math: "\\mathsfsl{f}"
  },
  	"𝘨": {
  	math: "\\mathsfsl{g}"
  },
  	"𝘩": {
  	math: "\\mathsfsl{h}"
  },
  	"𝘪": {
  	math: "\\mathsfsl{i}"
  },
  	"𝘫": {
  	math: "\\mathsfsl{j}"
  },
  	"𝘬": {
  	math: "\\mathsfsl{k}"
  },
  	"𝘭": {
  	math: "\\mathsfsl{l}"
  },
  	"𝘮": {
  	math: "\\mathsfsl{m}"
  },
  	"𝘯": {
  	math: "\\mathsfsl{n}"
  },
  	"𝘰": {
  	math: "\\mathsfsl{o}"
  },
  	"𝘱": {
  	math: "\\mathsfsl{p}"
  },
  	"𝘲": {
  	math: "\\mathsfsl{q}"
  },
  	"𝘳": {
  	math: "\\mathsfsl{r}"
  },
  	"𝘴": {
  	math: "\\mathsfsl{s}"
  },
  	"𝘵": {
  	math: "\\mathsfsl{t}"
  },
  	"𝘶": {
  	math: "\\mathsfsl{u}"
  },
  	"𝘷": {
  	math: "\\mathsfsl{v}"
  },
  	"𝘸": {
  	math: "\\mathsfsl{w}"
  },
  	"𝘹": {
  	math: "\\mathsfsl{x}"
  },
  	"𝘺": {
  	math: "\\mathsfsl{y}"
  },
  	"𝘻": {
  	math: "\\mathsfsl{z}"
  },
  	"𝘼": {
  	math: "\\mathsfbfsl{A}"
  },
  	"𝘽": {
  	math: "\\mathsfbfsl{B}"
  },
  	"𝘾": {
  	math: "\\mathsfbfsl{C}"
  },
  	"𝘿": {
  	math: "\\mathsfbfsl{D}"
  },
  	"𝙀": {
  	math: "\\mathsfbfsl{E}"
  },
  	"𝙁": {
  	math: "\\mathsfbfsl{F}"
  },
  	"𝙂": {
  	math: "\\mathsfbfsl{G}"
  },
  	"𝙃": {
  	math: "\\mathsfbfsl{H}"
  },
  	"𝙄": {
  	math: "\\mathsfbfsl{I}"
  },
  	"𝙅": {
  	math: "\\mathsfbfsl{J}"
  },
  	"𝙆": {
  	math: "\\mathsfbfsl{K}"
  },
  	"𝙇": {
  	math: "\\mathsfbfsl{L}"
  },
  	"𝙈": {
  	math: "\\mathsfbfsl{M}"
  },
  	"𝙉": {
  	math: "\\mathsfbfsl{N}"
  },
  	"𝙊": {
  	math: "\\mathsfbfsl{O}"
  },
  	"𝙋": {
  	math: "\\mathsfbfsl{P}"
  },
  	"𝙌": {
  	math: "\\mathsfbfsl{Q}"
  },
  	"𝙍": {
  	math: "\\mathsfbfsl{R}"
  },
  	"𝙎": {
  	math: "\\mathsfbfsl{S}"
  },
  	"𝙏": {
  	math: "\\mathsfbfsl{T}"
  },
  	"𝙐": {
  	math: "\\mathsfbfsl{U}"
  },
  	"𝙑": {
  	math: "\\mathsfbfsl{V}"
  },
  	"𝙒": {
  	math: "\\mathsfbfsl{W}"
  },
  	"𝙓": {
  	math: "\\mathsfbfsl{X}"
  },
  	"𝙔": {
  	math: "\\mathsfbfsl{Y}"
  },
  	"𝙕": {
  	math: "\\mathsfbfsl{Z}"
  },
  	"𝙖": {
  	math: "\\mathsfbfsl{a}"
  },
  	"𝙗": {
  	math: "\\mathsfbfsl{b}"
  },
  	"𝙘": {
  	math: "\\mathsfbfsl{c}"
  },
  	"𝙙": {
  	math: "\\mathsfbfsl{d}"
  },
  	"𝙚": {
  	math: "\\mathsfbfsl{e}"
  },
  	"𝙛": {
  	math: "\\mathsfbfsl{f}"
  },
  	"𝙜": {
  	math: "\\mathsfbfsl{g}"
  },
  	"𝙝": {
  	math: "\\mathsfbfsl{h}"
  },
  	"𝙞": {
  	math: "\\mathsfbfsl{i}"
  },
  	"𝙟": {
  	math: "\\mathsfbfsl{j}"
  },
  	"𝙠": {
  	math: "\\mathsfbfsl{k}"
  },
  	"𝙡": {
  	math: "\\mathsfbfsl{l}"
  },
  	"𝙢": {
  	math: "\\mathsfbfsl{m}"
  },
  	"𝙣": {
  	math: "\\mathsfbfsl{n}"
  },
  	"𝙤": {
  	math: "\\mathsfbfsl{o}"
  },
  	"𝙥": {
  	math: "\\mathsfbfsl{p}"
  },
  	"𝙦": {
  	math: "\\mathsfbfsl{q}"
  },
  	"𝙧": {
  	math: "\\mathsfbfsl{r}"
  },
  	"𝙨": {
  	math: "\\mathsfbfsl{s}"
  },
  	"𝙩": {
  	math: "\\mathsfbfsl{t}"
  },
  	"𝙪": {
  	math: "\\mathsfbfsl{u}"
  },
  	"𝙫": {
  	math: "\\mathsfbfsl{v}"
  },
  	"𝙬": {
  	math: "\\mathsfbfsl{w}"
  },
  	"𝙭": {
  	math: "\\mathsfbfsl{x}"
  },
  	"𝙮": {
  	math: "\\mathsfbfsl{y}"
  },
  	"𝙯": {
  	math: "\\mathsfbfsl{z}"
  },
  	"𝙰": {
  	math: "\\mathtt{A}"
  },
  	"𝙱": {
  	math: "\\mathtt{B}"
  },
  	"𝙲": {
  	math: "\\mathtt{C}"
  },
  	"𝙳": {
  	math: "\\mathtt{D}"
  },
  	"𝙴": {
  	math: "\\mathtt{E}"
  },
  	"𝙵": {
  	math: "\\mathtt{F}"
  },
  	"𝙶": {
  	math: "\\mathtt{G}"
  },
  	"𝙷": {
  	math: "\\mathtt{H}"
  },
  	"𝙸": {
  	math: "\\mathtt{I}"
  },
  	"𝙹": {
  	math: "\\mathtt{J}"
  },
  	"𝙺": {
  	math: "\\mathtt{K}"
  },
  	"𝙻": {
  	math: "\\mathtt{L}"
  },
  	"𝙼": {
  	math: "\\mathtt{M}"
  },
  	"𝙽": {
  	math: "\\mathtt{N}"
  },
  	"𝙾": {
  	math: "\\mathtt{O}"
  },
  	"𝙿": {
  	math: "\\mathtt{P}"
  },
  	"𝚀": {
  	math: "\\mathtt{Q}"
  },
  	"𝚁": {
  	math: "\\mathtt{R}"
  },
  	"𝚂": {
  	math: "\\mathtt{S}"
  },
  	"𝚃": {
  	math: "\\mathtt{T}"
  },
  	"𝚄": {
  	math: "\\mathtt{U}"
  },
  	"𝚅": {
  	math: "\\mathtt{V}"
  },
  	"𝚆": {
  	math: "\\mathtt{W}"
  },
  	"𝚇": {
  	math: "\\mathtt{X}"
  },
  	"𝚈": {
  	math: "\\mathtt{Y}"
  },
  	"𝚉": {
  	math: "\\mathtt{Z}"
  },
  	"𝚊": {
  	math: "\\mathtt{a}"
  },
  	"𝚋": {
  	math: "\\mathtt{b}"
  },
  	"𝚌": {
  	math: "\\mathtt{c}"
  },
  	"𝚍": {
  	math: "\\mathtt{d}"
  },
  	"𝚎": {
  	math: "\\mathtt{e}"
  },
  	"𝚏": {
  	math: "\\mathtt{f}"
  },
  	"𝚐": {
  	math: "\\mathtt{g}"
  },
  	"𝚑": {
  	math: "\\mathtt{h}"
  },
  	"𝚒": {
  	math: "\\mathtt{i}"
  },
  	"𝚓": {
  	math: "\\mathtt{j}"
  },
  	"𝚔": {
  	math: "\\mathtt{k}"
  },
  	"𝚕": {
  	math: "\\mathtt{l}"
  },
  	"𝚖": {
  	math: "\\mathtt{m}"
  },
  	"𝚗": {
  	math: "\\mathtt{n}"
  },
  	"𝚘": {
  	math: "\\mathtt{o}"
  },
  	"𝚙": {
  	math: "\\mathtt{p}"
  },
  	"𝚚": {
  	math: "\\mathtt{q}"
  },
  	"𝚛": {
  	math: "\\mathtt{r}"
  },
  	"𝚜": {
  	math: "\\mathtt{s}"
  },
  	"𝚝": {
  	math: "\\mathtt{t}"
  },
  	"𝚞": {
  	math: "\\mathtt{u}"
  },
  	"𝚟": {
  	math: "\\mathtt{v}"
  },
  	"𝚠": {
  	math: "\\mathtt{w}"
  },
  	"𝚡": {
  	math: "\\mathtt{x}"
  },
  	"𝚢": {
  	math: "\\mathtt{y}"
  },
  	"𝚣": {
  	math: "\\mathtt{z}"
  },
  	"𝚤": {
  	math: "\\imath"
  },
  	"𝚥": {
  	math: "\\jmath"
  },
  	"𝚨": {
  	math: "\\mathbf{A}"
  },
  	"𝚩": {
  	math: "\\mathbf{B}"
  },
  	"𝚪": {
  	math: "\\mathbf{\\Gamma}"
  },
  	"𝚫": {
  	math: "\\mathbf{\\Delta}"
  },
  	"𝚬": {
  	math: "\\mathbf{E}"
  },
  	"𝚭": {
  	math: "\\mathbf{Z}"
  },
  	"𝚮": {
  	math: "\\mathbf{H}"
  },
  	"𝚯": {
  	math: "\\mathbf{\\Theta}"
  },
  	"𝚰": {
  	math: "\\mathbf{I}"
  },
  	"𝚱": {
  	math: "\\mathbf{K}"
  },
  	"𝚲": {
  	math: "\\mathbf{\\Lambda}"
  },
  	"𝚳": {
  	math: "M"
  },
  	"𝚴": {
  	math: "N"
  },
  	"𝚵": {
  	math: "\\mathbf{\\Xi}"
  },
  	"𝚶": {
  	math: "O"
  },
  	"𝚷": {
  	math: "\\mathbf{\\Pi}"
  },
  	"𝚸": {
  	math: "\\mathbf{P}"
  },
  	"𝚹": {
  	math: "\\mathbf{\\vartheta}"
  },
  	"𝚺": {
  	math: "\\mathbf{\\Sigma}"
  },
  	"𝚻": {
  	math: "\\mathbf{T}"
  },
  	"𝚼": {
  	math: "\\mathbf{\\Upsilon}"
  },
  	"𝚽": {
  	math: "\\mathbf{\\Phi}"
  },
  	"𝚾": {
  	math: "\\mathbf{X}"
  },
  	"𝚿": {
  	math: "\\mathbf{\\Psi}"
  },
  	"𝛀": {
  	math: "\\mathbf{\\Omega}"
  },
  	"𝛁": {
  	math: "\\mathbf{\\nabla}"
  },
  	"𝛂": {
  	math: "\\mathbf{\\alpha}"
  },
  	"𝛃": {
  	math: "\\mathbf{\\beta}"
  },
  	"𝛄": {
  	math: "\\mathbf{\\gamma}"
  },
  	"𝛅": {
  	math: "\\mathbf{\\delta}"
  },
  	"𝛆": {
  	math: "\\mathbf{\\epsilon}"
  },
  	"𝛇": {
  	math: "\\mathbf{\\zeta}"
  },
  	"𝛈": {
  	math: "\\mathbf{\\eta}"
  },
  	"𝛉": {
  	math: "\\mathbf{\\theta}"
  },
  	"𝛊": {
  	math: "\\mathbf{I}"
  },
  	"𝛋": {
  	math: "\\mathbf{K}"
  },
  	"𝛌": {
  	math: "\\mathbf{\\lambda}"
  },
  	"𝛍": {
  	math: "M"
  },
  	"𝛎": {
  	math: "N"
  },
  	"𝛏": {
  	math: "\\mathbf{\\xi}"
  },
  	"𝛐": {
  	math: "O"
  },
  	"𝛑": {
  	math: "\\mathbf{\\pi}"
  },
  	"𝛒": {
  	math: "\\mathbf{P}"
  },
  	"𝛓": {
  	math: "\\mathbf{\\varsigma}"
  },
  	"𝛔": {
  	math: "\\mathbf{\\sigma}"
  },
  	"𝛕": {
  	math: "\\mathbf{T}"
  },
  	"𝛖": {
  	math: "\\mathbf{\\upsilon}"
  },
  	"𝛗": {
  	math: "\\mathbf{\\phi}"
  },
  	"𝛘": {
  	math: "\\mathbf{X}"
  },
  	"𝛙": {
  	math: "\\mathbf{\\psi}"
  },
  	"𝛚": {
  	math: "\\mathbf{\\omega}"
  },
  	"𝛛": {
  	math: "\\partial"
  },
  	"𝛜": {
  	math: "\\in"
  },
  	"𝛝": {
  	math: "\\mathbf{\\vartheta}"
  },
  	"𝛞": {
  	math: "\\mathbf{\\varkappa}"
  },
  	"𝛟": {
  	math: "\\mathbf{\\phi}"
  },
  	"𝛠": {
  	math: "\\mathbf{\\varrho}"
  },
  	"𝛡": {
  	math: "\\mathbf{\\varpi}"
  },
  	"𝛢": {
  	math: "\\mathsl{A}"
  },
  	"𝛣": {
  	math: "\\mathsl{B}"
  },
  	"𝛤": {
  	math: "\\mathsl{\\Gamma}"
  },
  	"𝛥": {
  	math: "\\mathsl{\\Delta}"
  },
  	"𝛦": {
  	math: "\\mathsl{E}"
  },
  	"𝛧": {
  	math: "\\mathsl{Z}"
  },
  	"𝛨": {
  	math: "\\mathsl{H}"
  },
  	"𝛩": {
  	math: "\\mathsl{\\Theta}"
  },
  	"𝛪": {
  	math: "\\mathsl{I}"
  },
  	"𝛫": {
  	math: "\\mathsl{K}"
  },
  	"𝛬": {
  	math: "\\mathsl{\\Lambda}"
  },
  	"𝛭": {
  	math: "M"
  },
  	"𝛮": {
  	math: "N"
  },
  	"𝛯": {
  	math: "\\mathsl{\\Xi}"
  },
  	"𝛰": {
  	math: "O"
  },
  	"𝛱": {
  	math: "\\mathsl{\\Pi}"
  },
  	"𝛲": {
  	math: "\\mathsl{P}"
  },
  	"𝛳": {
  	math: "\\mathsl{\\Theta}"
  },
  	"𝛴": {
  	math: "\\mathsl{\\Sigma}"
  },
  	"𝛵": {
  	math: "\\mathsl{T}"
  },
  	"𝛶": {
  	math: "\\mathsl{\\Upsilon}"
  },
  	"𝛷": {
  	math: "\\mathsl{\\Phi}"
  },
  	"𝛸": {
  	math: "\\mathsl{X}"
  },
  	"𝛹": {
  	math: "\\mathsl{\\Psi}"
  },
  	"𝛺": {
  	math: "\\mathsl{\\Omega}"
  },
  	"𝛻": {
  	math: "\\mathsl{\\nabla}"
  },
  	"𝛼": {
  	math: "\\mathsl{A}"
  },
  	"𝛽": {
  	math: "\\mathsl{B}"
  },
  	"𝛾": {
  	math: "\\mathsl{\\gamma}"
  },
  	"𝛿": {
  	math: "\\mathsl{\\delta}"
  },
  	"𝜀": {
  	math: "\\mathsl{E}"
  },
  	"𝜁": {
  	math: "\\mathsl{Z}"
  },
  	"𝜂": {
  	math: "\\mathsl{H}"
  },
  	"𝜃": {
  	math: "\\mathsl{\\theta}"
  },
  	"𝜄": {
  	math: "\\mathsl{I}"
  },
  	"𝜅": {
  	math: "\\mathsl{K}"
  },
  	"𝜆": {
  	math: "\\mathsl{\\lambda}"
  },
  	"𝜇": {
  	math: "\\mu"
  },
  	"𝜈": {
  	math: "\\nu"
  },
  	"𝜉": {
  	math: "\\mathsl{\\xi}"
  },
  	"𝜊": {
  	math: "o"
  },
  	"𝜋": {
  	math: "\\mathsl{\\pi}"
  },
  	"𝜌": {
  	math: "\\mathsl{P}"
  },
  	"𝜍": {
  	math: "\\mathsl{\\varsigma}"
  },
  	"𝜎": {
  	math: "\\mathsl{\\sigma}"
  },
  	"𝜏": {
  	math: "\\mathsl{T}"
  },
  	"𝜐": {
  	math: "\\mathsl{\\upsilon}"
  },
  	"𝜑": {
  	math: "\\mathsl{\\varphi}"
  },
  	"𝜒": {
  	math: "\\mathsl{X}"
  },
  	"𝜓": {
  	math: "\\mathsl{\\psi}"
  },
  	"𝜔": {
  	math: "\\mathsl{\\omega}"
  },
  	"𝜕": {
  	math: "\\partial"
  },
  	"𝜖": {
  	math: "\\in"
  },
  	"𝜗": {
  	math: "\\mathsl{\\vartheta}"
  },
  	"𝜘": {
  	math: "\\mathsl{\\varkappa}"
  },
  	"𝜙": {
  	math: "\\mathsl{\\phi}"
  },
  	"𝜚": {
  	math: "\\mathsl{\\varrho}"
  },
  	"𝜛": {
  	math: "\\mathsl{\\varpi}"
  },
  	"𝜜": {
  	math: "\\mathbit{A}"
  },
  	"𝜝": {
  	math: "\\mathbit{B}"
  },
  	"𝜞": {
  	math: "\\mathbit{\\Gamma}"
  },
  	"𝜟": {
  	math: "\\mathbit{\\Delta}"
  },
  	"𝜠": {
  	math: "\\mathbit{E}"
  },
  	"𝜡": {
  	math: "\\mathbit{Z}"
  },
  	"𝜢": {
  	math: "\\mathbit{H}"
  },
  	"𝜣": {
  	math: "\\mathbit{\\Theta}"
  },
  	"𝜤": {
  	math: "\\mathbit{I}"
  },
  	"𝜥": {
  	math: "\\mathbit{K}"
  },
  	"𝜦": {
  	math: "\\mathbit{\\Lambda}"
  },
  	"𝜧": {
  	math: "M"
  },
  	"𝜨": {
  	math: "N"
  },
  	"𝜩": {
  	math: "\\mathbit{\\Xi}"
  },
  	"𝜪": {
  	math: "O"
  },
  	"𝜫": {
  	math: "\\mathbit{\\Pi}"
  },
  	"𝜬": {
  	math: "\\mathbit{P}"
  },
  	"𝜭": {
  	math: "\\mathbit{O}"
  },
  	"𝜮": {
  	math: "\\mathbit{\\Sigma}"
  },
  	"𝜯": {
  	math: "\\mathbit{T}"
  },
  	"𝜰": {
  	math: "\\mathbit{\\Upsilon}"
  },
  	"𝜱": {
  	math: "\\mathbit{\\Phi}"
  },
  	"𝜲": {
  	math: "\\mathbit{X}"
  },
  	"𝜳": {
  	math: "\\mathbit{\\Psi}"
  },
  	"𝜴": {
  	math: "\\mathbit{\\Omega}"
  },
  	"𝜵": {
  	math: "\\mathbit{\\nabla}"
  },
  	"𝜶": {
  	math: "\\mathbit{\\alpha}"
  },
  	"𝜷": {
  	math: "\\mathbit{\\beta}"
  },
  	"𝜸": {
  	math: "\\mathbit{\\gamma}"
  },
  	"𝜹": {
  	math: "\\mathbit{\\delta}"
  },
  	"𝜺": {
  	math: "\\mathbit{\\epsilon}"
  },
  	"𝜻": {
  	math: "\\mathbit{\\zeta}"
  },
  	"𝜼": {
  	math: "\\mathbit{\\eta}"
  },
  	"𝜽": {
  	math: "\\mathbit{\\theta}"
  },
  	"𝜾": {
  	math: "\\mathbit{\\imath}"
  },
  	"𝜿": {
  	math: "\\mathbit{\\kappa}"
  },
  	"𝝀": {
  	math: "\\mathbit{\\lambda}"
  },
  	"𝝁": {
  	math: "\\mu"
  },
  	"𝝂": {
  	math: "N"
  },
  	"𝝃": {
  	math: "\\mathbit{\\xi}"
  },
  	"𝝄": {
  	math: "O"
  },
  	"𝝅": {
  	math: "\\mathbit{\\pi}"
  },
  	"𝝆": {
  	math: "\\mathbit{\\rho}"
  },
  	"𝝇": {
  	math: "\\mathbit{\\varsigma}"
  },
  	"𝝈": {
  	math: "\\mathbit{\\sigma}"
  },
  	"𝝉": {
  	math: "\\mathbit{\\tau}"
  },
  	"𝝊": {
  	math: "\\mathbit{\\upsilon}"
  },
  	"𝝋": {
  	math: "\\mathbit{\\varphi}"
  },
  	"𝝌": {
  	math: "\\mathbit{\\chi}"
  },
  	"𝝍": {
  	math: "\\mathbit{\\psi}"
  },
  	"𝝎": {
  	math: "\\mathbit{\\omega}"
  },
  	"𝝏": {
  	math: "\\partial"
  },
  	"𝝐": {
  	math: "\\in"
  },
  	"𝝑": {
  	math: "\\mathbit{\\vartheta}"
  },
  	"𝝒": {
  	math: "\\mathbit{\\varkappa}"
  },
  	"𝝓": {
  	math: "\\mathbit{\\phi}"
  },
  	"𝝔": {
  	math: "\\mathbit{\\varrho}"
  },
  	"𝝕": {
  	math: "\\mathbit{\\varpi}"
  },
  	"𝝖": {
  	math: "\\mathsfbf{A}"
  },
  	"𝝗": {
  	math: "\\mathsfbf{B}"
  },
  	"𝝘": {
  	math: "\\mathsfbf{\\Gamma}"
  },
  	"𝝙": {
  	math: "\\mathsfbf{\\Delta}"
  },
  	"𝝚": {
  	math: "\\mathsfbf{E}"
  },
  	"𝝛": {
  	math: "\\mathsfbf{Z}"
  },
  	"𝝜": {
  	math: "\\mathsfbf{H}"
  },
  	"𝝝": {
  	math: "\\mathsfbf{\\Theta}"
  },
  	"𝝞": {
  	math: "\\mathsfbf{I}"
  },
  	"𝝟": {
  	math: "\\mathsfbf{K}"
  },
  	"𝝠": {
  	math: "\\mathsfbf{\\Lambda}"
  },
  	"𝝡": {
  	math: "M"
  },
  	"𝝢": {
  	math: "N"
  },
  	"𝝣": {
  	math: "\\mathsfbf{\\Xi}"
  },
  	"𝝤": {
  	math: "O"
  },
  	"𝝥": {
  	math: "\\mathsfbf{\\Pi}"
  },
  	"𝝦": {
  	math: "\\mathsfbf{P}"
  },
  	"𝝧": {
  	math: "\\mathsfbf{\\Theta}"
  },
  	"𝝨": {
  	math: "\\mathsfbf{\\Sigma}"
  },
  	"𝝩": {
  	math: "\\mathsfbf{T}"
  },
  	"𝝪": {
  	math: "\\mathsfbf{\\Upsilon}"
  },
  	"𝝫": {
  	math: "\\mathsfbf{\\Phi}"
  },
  	"𝝬": {
  	math: "\\mathsfbf{X}"
  },
  	"𝝭": {
  	math: "\\mathsfbf{\\Psi}"
  },
  	"𝝮": {
  	math: "\\mathsfbf{\\Omega}"
  },
  	"𝝯": {
  	math: "\\mathsfbf{\\nabla}"
  },
  	"𝝰": {
  	math: "\\mathsfbf{\\alpha}"
  },
  	"𝝱": {
  	math: "\\mathsfbf{\\beta}"
  },
  	"𝝲": {
  	math: "\\mathsfbf{\\gamma}"
  },
  	"𝝳": {
  	math: "\\mathsfbf{\\delta}"
  },
  	"𝝴": {
  	math: "\\mathsfbf{\\varepsilon}"
  },
  	"𝝵": {
  	math: "\\mathsfbf{\\zeta}"
  },
  	"𝝶": {
  	math: "\\mathsfbf{\\eta}"
  },
  	"𝝷": {
  	math: "\\mathsfbf{\\theta}"
  },
  	"𝝸": {
  	math: "\\mathsfbf{\\imath}"
  },
  	"𝝹": {
  	math: "\\mathsfbf{\\kappa}"
  },
  	"𝝺": {
  	math: "\\mathsfbf{\\lambda}"
  },
  	"𝝻": {
  	math: "\\mu"
  },
  	"𝝼": {
  	math: "\\nu"
  },
  	"𝝽": {
  	math: "\\mathsfbf{\\xi}"
  },
  	"𝝾": {
  	math: "o"
  },
  	"𝝿": {
  	math: "\\mathsfbf{\\pi}"
  },
  	"𝞀": {
  	math: "\\mathsfbf{\\rho}"
  },
  	"𝞁": {
  	math: "\\mathsfbf{\\varsigma}"
  },
  	"𝞂": {
  	math: "\\mathsfbf{\\sigma}"
  },
  	"𝞃": {
  	math: "\\mathsfbf{\\tau}"
  },
  	"𝞄": {
  	math: "\\mathsfbf{\\upsilon}"
  },
  	"𝞅": {
  	math: "\\mathsfbf{\\varphi}"
  },
  	"𝞆": {
  	math: "\\mathsfbf{\\chi}"
  },
  	"𝞇": {
  	math: "\\mathsfbf{\\psi}"
  },
  	"𝞈": {
  	math: "\\mathsfbf{\\omega}"
  },
  	"𝞉": {
  	math: "\\partial"
  },
  	"𝞊": {
  	math: "\\in"
  },
  	"𝞋": {
  	math: "\\mathsfbf{\\vartheta}"
  },
  	"𝞌": {
  	math: "\\mathsfbf{\\varkappa}"
  },
  	"𝞍": {
  	math: "\\mathsfbf{\\phi}"
  },
  	"𝞎": {
  	math: "\\mathsfbf{\\varrho}"
  },
  	"𝞏": {
  	math: "\\mathsfbf{\\varpi}"
  },
  	"𝞐": {
  	math: "\\mathsfbfsl{A}"
  },
  	"𝞑": {
  	math: "\\mathsfbfsl{B}"
  },
  	"𝞒": {
  	math: "\\mathsfbfsl{\\Gamma}"
  },
  	"𝞓": {
  	math: "\\mathsfbfsl{\\Delta}"
  },
  	"𝞔": {
  	math: "\\mathsfbfsl{E}"
  },
  	"𝞕": {
  	math: "\\mathsfbfsl{Z}"
  },
  	"𝞖": {
  	math: "\\mathsfbfsl{H}"
  },
  	"𝞗": {
  	math: "\\mathsfbfsl{\\Theta}"
  },
  	"𝞘": {
  	math: "\\mathsfbfsl{I}"
  },
  	"𝞙": {
  	math: "\\mathsfbfsl{K}"
  },
  	"𝞚": {
  	math: "\\mathsfbfsl{\\Lambda}"
  },
  	"𝞛": {
  	math: "\\mathsfbfsl{M}"
  },
  	"𝞜": {
  	math: "\\mathsfbfsl{N}"
  },
  	"𝞝": {
  	math: "\\mathsfbfsl{\\Xi}"
  },
  	"𝞞": {
  	math: "\\mathsfbfsl{O}"
  },
  	"𝞟": {
  	math: "\\mathsfbfsl{\\Pi}"
  },
  	"𝞠": {
  	math: "\\mathsfbfsl{P}"
  },
  	"𝞡": {
  	math: "\\mathsfbfsl{\\Theta}"
  },
  	"𝞢": {
  	math: "\\mathsfbfsl{\\Sigma}"
  },
  	"𝞣": {
  	math: "\\mathsfbfsl{T}"
  },
  	"𝞤": {
  	math: "\\mathsfbfsl{\\Upsilon}"
  },
  	"𝞥": {
  	math: "\\mathsfbfsl{\\Phi}"
  },
  	"𝞦": {
  	math: "\\mathsfbfsl{X}"
  },
  	"𝞧": {
  	math: "\\mathsfbfsl{\\Psi}"
  },
  	"𝞨": {
  	math: "\\mathsfbfsl{\\Omega}"
  },
  	"𝞩": {
  	math: "\\mathsfbfsl{\\nabla}"
  },
  	"𝞪": {
  	math: "\\mathsfbfsl{\\alpha}"
  },
  	"𝞫": {
  	math: "\\mathsfbfsl{\\beta}"
  },
  	"𝞬": {
  	math: "\\mathsfbfsl{\\gamma}"
  },
  	"𝞭": {
  	math: "\\mathsfbfsl{\\delta}"
  },
  	"𝞮": {
  	math: "\\mathsfbfsl{\\varepsilon}"
  },
  	"𝞯": {
  	math: "\\mathsfbfsl{\\zeta}"
  },
  	"𝞰": {
  	math: "\\mathsfbfsl{\\eta}"
  },
  	"𝞱": {
  	math: "\\mathsfbfsl{\\theta}"
  },
  	"𝞲": {
  	math: "\\mathsfbfsl{\\imath}"
  },
  	"𝞳": {
  	math: "\\mathsfbfsl{\\kappa}"
  },
  	"𝞴": {
  	math: "\\mathsfbfsl{\\lambda}"
  },
  	"𝞵": {
  	math: "\\mu"
  },
  	"𝞶": {
  	math: "\\nu"
  },
  	"𝞷": {
  	math: "\\mathsfbfsl{\\xi}"
  },
  	"𝞸": {
  	math: "o"
  },
  	"𝞹": {
  	math: "\\mathsfbfsl{\\pi}"
  },
  	"𝞺": {
  	math: "\\mathsfbfsl{\\rho}"
  },
  	"𝞻": {
  	math: "\\mathsfbfsl{\\varsigma}"
  },
  	"𝞼": {
  	math: "\\mathsfbfsl{\\sigma}"
  },
  	"𝞽": {
  	math: "\\mathsfbfsl{\\tau}"
  },
  	"𝞾": {
  	math: "\\mathsfbfsl{\\upsilon}"
  },
  	"𝞿": {
  	math: "\\mathsfbfsl{\\varphi}"
  },
  	"𝟀": {
  	math: "\\mathsfbfsl{\\chi}"
  },
  	"𝟁": {
  	math: "\\mathsfbfsl{\\psi}"
  },
  	"𝟂": {
  	math: "\\mathsfbfsl{\\omega}"
  },
  	"𝟃": {
  	math: "\\partial"
  },
  	"𝟄": {
  	math: "\\in"
  },
  	"𝟅": {
  	math: "\\mathsfbfsl{\\vartheta}"
  },
  	"𝟆": {
  	math: "\\mathsfbfsl{\\varkappa}"
  },
  	"𝟇": {
  	math: "\\mathsfbfsl{\\phi}"
  },
  	"𝟈": {
  	math: "\\mathsfbfsl{\\varrho}"
  },
  	"𝟉": {
  	math: "\\mathsfbfsl{\\varpi}"
  },
  	"𝟊": {
  	math: "\\mbfDigamma"
  },
  	"𝟋": {
  	math: "\\mbfdigamma"
  },
  	"𝟎": {
  	math: "\\mathbf{0}"
  },
  	"𝟏": {
  	math: "\\mathbf{1}"
  },
  	"𝟐": {
  	math: "\\mathbf{2}"
  },
  	"𝟑": {
  	math: "\\mathbf{3}"
  },
  	"𝟒": {
  	math: "\\mathbf{4}"
  },
  	"𝟓": {
  	math: "\\mathbf{5}"
  },
  	"𝟔": {
  	math: "\\mathbf{6}"
  },
  	"𝟕": {
  	math: "\\mathbf{7}"
  },
  	"𝟖": {
  	math: "\\mathbf{8}"
  },
  	"𝟗": {
  	math: "\\mathbf{9}"
  },
  	"𝟘": {
  	math: "\\mathbb{0}"
  },
  	"𝟙": {
  	math: "\\mathbb{1}"
  },
  	"𝟚": {
  	math: "\\mathbb{2}"
  },
  	"𝟛": {
  	math: "\\mathbb{3}"
  },
  	"𝟜": {
  	math: "\\mathbb{4}"
  },
  	"𝟝": {
  	math: "\\mathbb{5}"
  },
  	"𝟞": {
  	math: "\\mathbb{6}"
  },
  	"𝟟": {
  	math: "\\mathbb{7}"
  },
  	"𝟠": {
  	math: "\\mathbb{8}"
  },
  	"𝟡": {
  	math: "\\mathbb{9}"
  },
  	"𝟢": {
  	math: "\\mathsf{0}"
  },
  	"𝟣": {
  	math: "\\mathsf{1}"
  },
  	"𝟤": {
  	math: "\\mathsf{2}"
  },
  	"𝟥": {
  	math: "\\mathsf{3}"
  },
  	"𝟦": {
  	math: "\\mathsf{4}"
  },
  	"𝟧": {
  	math: "\\mathsf{5}"
  },
  	"𝟨": {
  	math: "\\mathsf{6}"
  },
  	"𝟩": {
  	math: "\\mathsf{7}"
  },
  	"𝟪": {
  	math: "\\mathsf{8}"
  },
  	"𝟫": {
  	math: "\\mathsf{9}"
  },
  	"𝟬": {
  	math: "\\mathsfbf{0}"
  },
  	"𝟭": {
  	math: "\\mathsfbf{1}"
  },
  	"𝟮": {
  	math: "\\mathsfbf{2}"
  },
  	"𝟯": {
  	math: "\\mathsfbf{3}"
  },
  	"𝟰": {
  	math: "\\mathsfbf{4}"
  },
  	"𝟱": {
  	math: "\\mathsfbf{5}"
  },
  	"𝟲": {
  	math: "\\mathsfbf{6}"
  },
  	"𝟳": {
  	math: "\\mathsfbf{7}"
  },
  	"𝟴": {
  	math: "\\mathsfbf{8}"
  },
  	"𝟵": {
  	math: "\\mathsfbf{9}"
  },
  	"𝟶": {
  	math: "\\mathtt{0}"
  },
  	"𝟷": {
  	math: "\\mathtt{1}"
  },
  	"𝟸": {
  	math: "\\mathtt{2}"
  },
  	"𝟹": {
  	math: "\\mathtt{3}"
  },
  	"𝟺": {
  	math: "\\mathtt{4}"
  },
  	"𝟻": {
  	math: "\\mathtt{5}"
  },
  	"𝟼": {
  	math: "\\mathtt{6}"
  },
  	"𝟽": {
  	math: "\\mathtt{7}"
  },
  	"𝟾": {
  	math: "\\mathtt{8}"
  },
  	"𝟿": {
  	math: "\\mathtt{9}"
  }
  };

  var $$2 = {
  	math: "\\$",
  	text: "\\$"
  };
  var _$2 = {
  	math: "\\_",
  	text: "\\_"
  };
  var require$$2 = {
  	"#": {
  	math: "\\#",
  	text: "\\#"
  },
  	$: $$2,
  	"%": {
  	math: "\\%",
  	text: "\\%"
  },
  	"&": {
  	math: "\\&",
  	text: "\\&"
  },
  	"/​": {
  	text: "\\slash",
  	commandspacer: true
  },
  	"<": {
  	math: "<"
  },
  	">": {
  	math: ">"
  },
  	"\\": {
  	math: "\\backslash",
  	text: "\\textbackslash",
  	commandspacer: true
  },
  	"^": {
  	math: "\\sphat",
  	text: "\\^"
  },
  	_: _$2,
  	"{": {
  	math: "\\lbrace",
  	text: "\\{"
  },
  	"}": {
  	math: "\\rbrace",
  	text: "\\}"
  },
  	"~": {
  	math: "\\sptilde",
  	text: "\\textasciitilde",
  	commandspacer: true
  },
  	" ": {
  	math: "~",
  	space: true,
  	text: "~"
  },
  	" ": {
  	text: " ",
  	space: true
  },
  	" ": {
  	math: "\\quad",
  	space: true
  },
  	" ": {
  	text: "\\hspace{0.6em}",
  	space: true
  },
  	" ": {
  	math: "\\quad",
  	space: true,
  	text: "\\hspace{1em}"
  },
  	" ": {
  	text: "\\;",
  	space: true
  },
  	" ": {
  	text: "\\hspace{0.25em}",
  	space: true
  },
  	" ": {
  	text: "\\hspace{0.166em}",
  	space: true
  },
  	" ": {
  	text: "\\hphantom{0}",
  	space: true
  },
  	" ": {
  	text: "\\hphantom{,}",
  	space: true
  },
  	" ": {
  	text: "\\,",
  	space: true
  },
  	" ": {
  	math: "\\mkern1mu",
  	space: true
  },
  	"​": {
  	text: "\\mbox",
  	commandspacer: true,
  	space: true
  },
  	" ": {
  	text: " ",
  	space: true
  },
  	" ": {
  	math: "\\:",
  	space: true,
  	text: "\\:"
  }
  };

  var require$$3 = {
  	"\\#": "#",
  	"\\$": "$",
  	"\\%": "%",
  	"\\&": "&",
  	"\\slash": "/​",
  	"\\textless": "<",
  	"\\textgreater": ">",
  	"\\LaTeX": "LaTeX",
  	"\\textbackslash": "\\",
  	"\\backslash": "\\",
  	"\\": "\\",
  	"\\^": "^",
  	"\\sphat": "^",
  	"\\_": "_",
  	"\\t{ia}": "i︠a︡",
  	"{\\~ w}": "w̃",
  	"\\{": "{",
  	"\\lbrace": "{",
  	"\\textbar": "|",
  	"\\}": "}",
  	"\\rbrace": "}",
  	"\\textasciitilde": "~",
  	"\\sptilde": "~",
  	"\\textexclamdown": "¡",
  	"\\textcent": "¢",
  	"\\cent": "¢",
  	"\\textsterling": "£",
  	"\\pounds": "£",
  	"\\textcurrency": "¤",
  	"\\textyen": "¥",
  	"\\yen": "¥",
  	"\\textbrokenbar": "¦",
  	"\\textsection": "§",
  	"\\textasciidieresis": "¨",
  	"\\spddot": "¨",
  	"\\textcopyright": "©",
  	"\\textordfeminine": "ª",
  	"\\guillemotleft": "«",
  	"\\lnot": "¬",
  	"\\neg": "¬",
  	"\\-": "­",
  	"\\textregistered": "®",
  	"\\circledR": "®",
  	"\\textasciimacron": "¯",
  	"\\textdegree": "°",
  	"^\\circ": "°",
  	"\\pm": "±",
  	"^{2}": "²",
  	"^{3}": "³",
  	"\\textasciiacute": "´",
  	"\\textmu": "µ",
  	"\\textparagraph": "¶",
  	"^{1}": "¹",
  	"\\textordmasculine": "º",
  	"\\guillemotright": "»",
  	"\\frac{1}{4}": "¼",
  	"\\textonequarter": "¼",
  	"\\frac{1}{2}": "½",
  	"\\textonehalf": "½",
  	"\\frac{3}{4}": "¾",
  	"\\textthreequarters": "¾",
  	"\\textquestiondown": "¿",
  	"\\`A": "À",
  	"\\'A": "Á",
  	"\\^A": "Â",
  	"\\~A": "Ã",
  	"\\\"A": "Ä",
  	"\\AA": "Å",
  	"\\r{A}": "Å",
  	"{\\r A}": "Å",
  	"\\AE": "Æ",
  	"\\c{C}": "Ç",
  	"\\`E": "È",
  	"\\'E": "É",
  	"\\^E": "Ê",
  	"\\\"E": "Ë",
  	"\\`I": "Ì",
  	"\\'I": "Í",
  	"\\^I": "Î",
  	"\\\"I": "Ï",
  	"\\DH": "Ð",
  	"\\~N": "Ñ",
  	"\\`O": "Ò",
  	"\\'O": "Ó",
  	"\\^O": "Ô",
  	"\\~O": "Õ",
  	"\\\"O": "Ö",
  	"\\texttimes": "×",
  	"\\times": "×",
  	"\\O": "Ø",
  	"\\`U": "Ù",
  	"\\'U": "Ú",
  	"\\^U": "Û",
  	"\\\"U": "Ü",
  	"\\'Y": "Ý",
  	"\\TH": "Þ",
  	"\\ss": "ß",
  	"\\`a": "à",
  	"\\'a": "á",
  	"\\^a": "â",
  	"\\~a": "ã",
  	"\\\"a": "ä",
  	"\\aa": "å",
  	"\\r{a}": "å",
  	"{\\r a}": "å",
  	"\\ae": "æ",
  	"\\c{c}": "ç",
  	"\\`e": "è",
  	"\\'e": "é",
  	"\\^e": "ê",
  	"\\\"e": "ë",
  	"\\`i": "ì",
  	"\\`\\i": "ì",
  	"\\'i": "í",
  	"\\'\\i": "í",
  	"\\^i": "î",
  	"\\^\\i": "î",
  	"\\\"i": "ï",
  	"\\\"\\i": "ï",
  	"\\dh": "ð",
  	"\\eth": "ð",
  	"\\~n": "ñ",
  	"\\`o": "ò",
  	"\\'o": "ó",
  	"\\^o": "ô",
  	"\\~o": "õ",
  	"\\\"o": "ö",
  	"\\div": "÷",
  	"\\o": "ø",
  	"\\`u": "ù",
  	"\\'u": "ú",
  	"\\^u": "û",
  	"\\\"u": "ü",
  	"\\'y": "ý",
  	"\\th": "þ",
  	"\\\"y": "ÿ",
  	"\\=A": "Ā",
  	"\\=a": "ā",
  	"\\u{A}": "Ă",
  	"\\u{a}": "ă",
  	"\\k{A}": "Ą",
  	"\\k{a}": "ą",
  	"\\'C": "Ć",
  	"\\'c": "ć",
  	"\\^C": "Ĉ",
  	"\\^c": "ĉ",
  	"\\.C": "Ċ",
  	"\\.c": "ċ",
  	"\\v{C}": "Č",
  	"\\v{c}": "č",
  	"\\v{D}": "Ď",
  	"\\v{d}": "ď",
  	"\\DJ": "Đ",
  	"\\dj": "đ",
  	"\\=E": "Ē",
  	"\\=e": "ē",
  	"\\u{E}": "Ĕ",
  	"\\u{e}": "ĕ",
  	"\\.E": "Ė",
  	"\\.e": "ė",
  	"\\k{E}": "Ę",
  	"\\k{e}": "ę",
  	"\\v{E}": "Ě",
  	"\\v{e}": "ě",
  	"\\^G": "Ĝ",
  	"\\^g": "ĝ",
  	"\\u{G}": "Ğ",
  	"\\u{g}": "ğ",
  	"\\.G": "Ġ",
  	"\\.g": "ġ",
  	"\\c{G}": "Ģ",
  	"\\c{g}": "ģ",
  	"\\^H": "Ĥ",
  	"\\^h": "ĥ",
  	"{\\fontencoding{LELA}\\selectfont\\char40}": "Ħ",
  	"\\Elzxh": "ħ",
  	"\\~I": "Ĩ",
  	"\\~i": "ĩ",
  	"\\=I": "Ī",
  	"\\=i": "ī",
  	"\\u{I}": "Ĭ",
  	"{\\u \\i}": "ĭ",
  	"\\k{I}": "Į",
  	"\\k{i}": "į",
  	"\\.I": "İ",
  	"\\i": "ı",
  	"\\imath": "ı",
  	"\\^J": "Ĵ",
  	"\\^\\j": "ĵ",
  	"\\c{K}": "Ķ",
  	"\\c{k}": "ķ",
  	"{\\fontencoding{LELA}\\selectfont\\char91}": "ĸ",
  	"\\'L": "Ĺ",
  	"\\'l": "ĺ",
  	"\\c{L}": "Ļ",
  	"\\c{l}": "ļ",
  	"\\v{L}": "Ľ",
  	"\\v{l}": "ľ",
  	"{\\fontencoding{LELA}\\selectfont\\char201}": "Ŀ",
  	"{\\fontencoding{LELA}\\selectfont\\char202}": "ŀ",
  	"\\L": "Ł",
  	"\\l": "ł",
  	"\\'N": "Ń",
  	"\\'n": "ń",
  	"\\c{N}": "Ņ",
  	"\\c{n}": "ņ",
  	"\\v{N}": "Ň",
  	"\\v{n}": "ň",
  	"\\NG": "Ŋ",
  	"\\ng": "ŋ",
  	"\\=O": "Ō",
  	"\\=o": "ō",
  	"\\u{O}": "Ŏ",
  	"\\u{o}": "ŏ",
  	"\\H{O}": "Ő",
  	"\\H{o}": "ő",
  	"\\OE": "Œ",
  	"\\oe": "œ",
  	"\\'R": "Ŕ",
  	"\\'r": "ŕ",
  	"\\c{R}": "Ŗ",
  	"\\c{r}": "ŗ",
  	"\\v{R}": "Ř",
  	"\\v{r}": "ř",
  	"\\'S": "Ś",
  	"\\'s": "ś",
  	"\\^S": "Ŝ",
  	"\\^s": "ŝ",
  	"\\c{S}": "Ş",
  	"\\c{s}": "ş",
  	"\\v{S}": "Š",
  	"\\v{s}": "š",
  	"\\c{T}": "Ţ",
  	"\\c{t}": "ţ",
  	"\\v{T}": "Ť",
  	"\\v{t}": "ť",
  	"{\\fontencoding{LELA}\\selectfont\\char47}": "Ŧ",
  	"{\\fontencoding{LELA}\\selectfont\\char63}": "ŧ",
  	"\\~U": "Ũ",
  	"\\~u": "ũ",
  	"\\=U": "Ū",
  	"\\=u": "ū",
  	"\\u{U}": "Ŭ",
  	"\\u{u}": "ŭ",
  	"\\r{U}": "Ů",
  	"{\\r U}": "Ů",
  	"\\r{u}": "ů",
  	"\\ocirc{u}": "ů",
  	"{\\r u}": "ů",
  	"\\H{U}": "Ű",
  	"\\H{u}": "ű",
  	"\\k{U}": "Ų",
  	"\\k{u}": "ų",
  	"\\^W": "Ŵ",
  	"\\^w": "ŵ",
  	"\\^Y": "Ŷ",
  	"\\^y": "ŷ",
  	"\\\"Y": "Ÿ",
  	"\\'Z": "Ź",
  	"\\'z": "ź",
  	"\\.Z": "Ż",
  	"\\.z": "ż",
  	"\\v{Z}": "Ž",
  	"\\v{z}": "ž",
  	"\\texthvlig": "ƕ",
  	"\\textnrleg": "ƞ",
  	"\\textesh": "ƪ",
  	"\\Zbar": "Ƶ",
  	"{\\fontencoding{LELA}\\selectfont\\char195}": "ƺ",
  	"\\textdoublepipe": "ǂ",
  	"\\v{A}": "Ǎ",
  	"\\v{a}": "ǎ",
  	"\\v{I}": "Ǐ",
  	"\\v{i}": "ǐ",
  	"\\v{O}": "Ǒ",
  	"\\v{o}": "ǒ",
  	"\\v{U}": "Ǔ",
  	"\\v{u}": "ǔ",
  	"\\v{G}": "Ǧ",
  	"\\v{g}": "ǧ",
  	"\\v{K}": "Ǩ",
  	"\\v{k}": "ǩ",
  	"\\k{O}": "Ǫ",
  	"\\k{o}": "ǫ",
  	"\\v{j}": "ǰ",
  	"\\'G": "Ǵ",
  	"\\'g": "ǵ",
  	"\\c{E}": "Ȩ",
  	"\\c{e}": "ȩ",
  	"\\jmath": "ȷ",
  	"\\Elztrna": "ɐ",
  	"\\Elztrnsa": "ɒ",
  	"\\Elzopeno": "ɔ",
  	"\\Elzrtld": "ɖ",
  	"{\\fontencoding{LEIP}\\selectfont\\char61}": "ɘ",
  	"\\Elzschwa": "ə",
  	"\\varepsilon": "ɛ",
  	"\\Elzpgamma": "ɣ",
  	"\\Elzpbgam": "ɤ",
  	"\\Elztrnh": "ɥ",
  	"\\Elzbtdl": "ɬ",
  	"\\Elzrtll": "ɭ",
  	"\\Elztrnm": "ɯ",
  	"\\Elztrnmlr": "ɰ",
  	"\\Elzltlmr": "ɱ",
  	"\\Elzltln": "ɲ",
  	"\\Elzrtln": "ɳ",
  	"\\Elzclomeg": "ɷ",
  	"\\textphi": "ɸ",
  	"\\Elztrnr": "ɹ",
  	"\\Elztrnrl": "ɺ",
  	"\\Elzrttrnr": "ɻ",
  	"\\Elzrl": "ɼ",
  	"\\Elzrtlr": "ɽ",
  	"\\Elzfhr": "ɾ",
  	"{\\fontencoding{LEIP}\\selectfont\\char202}": "ɿ",
  	"\\Elzrtls": "ʂ",
  	"\\Elzesh": "ʃ",
  	"\\Elztrnt": "ʇ",
  	"\\Elzrtlt": "ʈ",
  	"\\Elzpupsil": "ʊ",
  	"\\Elzpscrv": "ʋ",
  	"\\Elzinvv": "ʌ",
  	"\\Elzinvw": "ʍ",
  	"\\Elztrny": "ʎ",
  	"\\Elzrtlz": "ʐ",
  	"\\Elzyogh": "ʒ",
  	"\\Elzglst": "ʔ",
  	"\\Elzreglst": "ʕ",
  	"\\Elzinglst": "ʖ",
  	"\\textturnk": "ʞ",
  	"\\Elzdyogh": "ʤ",
  	"\\Elztesh": "ʧ",
  	"\\textsuperscript{h}": "ʰ",
  	"^{h}": "ʰ",
  	"\\textsuperscript{j}": "ʲ",
  	"^{j}": "ʲ",
  	"\\textsuperscript{r}": "ʳ",
  	"^{r}": "ʳ",
  	"\\textsuperscript{w}": "ʷ",
  	"^{w}": "ʷ",
  	"\\textsuperscript{y}": "ʸ",
  	"^{y}": "ʸ",
  	"\\lasp": "ʿ",
  	"\\textasciicircum": "ˆ",
  	"\\textasciicaron": "ˇ",
  	"\\Elzverts": "ˈ",
  	"\\Elzverti": "ˌ",
  	"\\Elzlmrk": "ː",
  	"\\Elzhlmrk": "ˑ",
  	"\\Elzsbrhr": "˒",
  	"\\Elzsblhr": "˓",
  	"\\Elzrais": "˔",
  	"\\Elzlow": "˕",
  	"\\textasciibreve": "˘",
  	"\\textperiodcentered": "˙",
  	"\\texttildelow": "˜",
  	"\\textsuperscript{l}": "ˡ",
  	"^{l}": "ˡ",
  	"\\textsuperscript{s}": "ˢ",
  	"^{s}": "ˢ",
  	"\\textsuperscript{x}": "ˣ",
  	"^{x}": "ˣ",
  	"\\tone{55}": "˥",
  	"\\tone{44}": "˦",
  	"\\tone{33}": "˧",
  	"\\tone{22}": "˨",
  	"\\tone{11}": "˩",
  	"\\`": "̀",
  	"\\grave": "̀",
  	"\\textgravemacron": "̀̄",
  	"\\textgravedot": "̀̇",
  	"\\'": "́",
  	"\\acute": "́",
  	"\\textacutemacron": "́̄",
  	"\\textacutewedge": "́̌",
  	"\\hat": "̂",
  	"\\textcircumdot": "̂̇",
  	"\\~": "̃",
  	"\\tilde": "̃",
  	"\\texttildedot": "̃̇",
  	"\\=": "̄",
  	"\\bar": "̄",
  	"\\overline": "̅",
  	"\\u": "̆",
  	"\\breve": "̆",
  	"\\textbrevemacron": "̆̄",
  	"\\.": "̇",
  	"\\dot": "̇",
  	"\\textdotacute": "̇́",
  	"\\\"": "̈",
  	"\\ddot": "̈",
  	"\\ovhook": "̉",
  	"\\r": "̊",
  	"\\mathring": "̊",
  	"\\textringmacron": "̊̄",
  	"\\H": "̋",
  	"\\check": "̌",
  	"\\v": "̌",
  	"\\textvbaraccent": "̍",
  	"\\textdoublevbaraccent": "̎",
  	"\\textdoublegrave": "̏",
  	"\\textdotbreve": "̐",
  	"{\\fontencoding{LECO}\\selectfont\\char177}": "̑",
  	"\\oturnedcomma": "̒",
  	"\\ocommatopright": "̕",
  	"\\textsubgrave": "̖",
  	"\\textadvancing": "̘",
  	"\\textretracting": "̙",
  	"\\droang": "̚",
  	"\\textcorner": "̚",
  	"\\textsublhalfring": "̜",
  	"\\textraising": "̝",
  	"\\textlowering": "̞",
  	"\\textsubplus": "̟",
  	"\\Elzpalh": "̡",
  	"\\Elzrh": "̢",
  	"\\d": "̣",
  	"\\textsubumlaut": "̤",
  	"\\textsubring": "̥",
  	"\\c": "̧",
  	"\\k": "̨",
  	"\\textsyllabic": "̩",
  	"\\Elzsbbrg": "̪",
  	"\\textsubbridge": "̪",
  	"{\\fontencoding{LECO}\\selectfont\\char203}": "̫",
  	"\\textsubwedge": "̬",
  	"\\textsubarch": "̯",
  	"\\utilde": "̰",
  	"\\textsubtilde": "̰",
  	"\\textsubbar": "̱",
  	"\\underbar": "̱",
  	"\\underline": "̲",
  	"\\textsuperimposetilde": "̴",
  	"\\Elzxl": "̵",
  	"\\Elzbar": "̶",
  	"{\\fontencoding{LECO}\\selectfont\\char215}": "̷",
  	"\\not": "̸",
  	"\\textsubrhalfring": "̹",
  	"\\textinvsubbridge": "̺",
  	"\\textsubsquare": "̻",
  	"\\textseagull": "̼",
  	"\\textovercross": "̽",
  	"{\\fontencoding{LECO}\\selectfont\\char225}": "͡",
  	"\\'H": "Ή",
  	"{\\'{}I}": "Ί",
  	"{\\'{}O}": "Ό",
  	"\\mathrm{'Y}": "Ύ",
  	"\\mathrm{'\\Omega}": "Ώ",
  	"\\acute{\\ddot{\\iota}}": "ΐ",
  	"\\Gamma": "Γ",
  	"\\varGamma": "Γ",
  	"\\Delta": "Δ",
  	"\\Theta": "Θ",
  	"\\Lambda": "Λ",
  	"\\Xi": "Ξ",
  	"\\Pi": "Π",
  	"\\Sigma": "Σ",
  	"\\Upsilon": "Υ",
  	"\\Phi": "Φ",
  	"\\Psi": "Ψ",
  	"\\Omega": "Ω",
  	"\\mathrm{\\ddot{I}}": "Ϊ",
  	"\\mathrm{\\ddot{Y}}": "Ϋ",
  	"{\\'$\\alpha$}": "ά",
  	"\\acute{\\epsilon}": "έ",
  	"\\acute{\\eta}": "ή",
  	"\\acute{\\iota}": "ί",
  	"\\acute{\\ddot{\\upsilon}}": "ΰ",
  	"\\alpha": "α",
  	"\\beta": "β",
  	"\\gamma": "γ",
  	"\\delta": "δ",
  	"\\zeta": "ζ",
  	"\\eta": "η",
  	"\\texttheta": "θ",
  	"\\theta": "θ",
  	"\\iota": "ι",
  	"\\kappa": "κ",
  	"\\lambda": "λ",
  	"\\nu": "ν",
  	"\\xi": "ξ",
  	"\\pi": "π",
  	"\\rho": "ρ",
  	"\\varsigma": "ς",
  	"\\sigma": "σ",
  	"\\tau": "τ",
  	"\\upsilon": "υ",
  	"\\varphi": "φ",
  	"\\chi": "χ",
  	"\\psi": "ψ",
  	"\\omega": "ω",
  	"\\ddot{\\iota}": "ϊ",
  	"\\ddot{\\upsilon}": "ϋ",
  	"\\acute{\\upsilon}": "ύ",
  	"\\acute{\\omega}": "ώ",
  	"\\Pisymbol{ppi022}{87}": "ϐ",
  	"\\varbeta": "ϐ",
  	"\\textvartheta": "ϑ",
  	"\\vartheta": "ϑ",
  	"\\phi": "ϕ",
  	"\\varpi": "ϖ",
  	"\\Qoppa": "Ϙ",
  	"\\qoppa": "ϙ",
  	"\\Stigma": "Ϛ",
  	"\\stigma": "ϛ",
  	"\\Digamma": "Ϝ",
  	"\\digamma": "ϝ",
  	"\\Koppa": "Ϟ",
  	"\\koppa": "ϟ",
  	"\\Sampi": "Ϡ",
  	"\\sampi": "ϡ",
  	"\\varkappa": "ϰ",
  	"\\varrho": "ϱ",
  	"\\textTheta": "ϴ",
  	"\\upvarTheta": "ϴ",
  	"\\epsilon": "ϵ",
  	"\\backepsilon": "϶",
  	"\\cyrchar\\CYRYO": "Ё",
  	"\\cyrchar\\CYRDJE": "Ђ",
  	"\\cyrchar{\\'\\CYRG}": "Ѓ",
  	"\\cyrchar\\CYRIE": "Є",
  	"\\cyrchar\\CYRDZE": "Ѕ",
  	"\\cyrchar\\CYRII": "І",
  	"\\cyrchar\\CYRYI": "Ї",
  	"\\cyrchar\\CYRJE": "Ј",
  	"\\cyrchar\\CYRLJE": "Љ",
  	"\\cyrchar\\CYRNJE": "Њ",
  	"\\cyrchar\\CYRTSHE": "Ћ",
  	"\\cyrchar{\\'\\CYRK}": "Ќ",
  	"\\cyrchar\\CYRUSHRT": "Ў",
  	"\\cyrchar\\CYRDZHE": "Џ",
  	"\\cyrchar\\CYRA": "А",
  	"\\cyrchar\\CYRB": "Б",
  	"\\cyrchar\\CYRV": "В",
  	"\\cyrchar\\CYRG": "Г",
  	"\\cyrchar\\CYRD": "Д",
  	"\\cyrchar\\CYRE": "Е",
  	"\\cyrchar\\CYRZH": "Ж",
  	"\\cyrchar\\CYRZ": "З",
  	"\\cyrchar\\CYRI": "И",
  	"\\cyrchar\\CYRISHRT": "Й",
  	"\\cyrchar\\CYRK": "К",
  	"\\cyrchar\\CYRL": "Л",
  	"\\cyrchar\\CYRM": "М",
  	"\\cyrchar\\CYRN": "Н",
  	"\\cyrchar\\CYRO": "О",
  	"\\cyrchar\\CYRP": "П",
  	"\\cyrchar\\CYRR": "Р",
  	"\\cyrchar\\CYRS": "С",
  	"\\cyrchar\\CYRT": "Т",
  	"\\cyrchar\\CYRU": "У",
  	"\\cyrchar\\CYRF": "Ф",
  	"\\cyrchar\\CYRH": "Х",
  	"\\cyrchar\\CYRC": "Ц",
  	"\\cyrchar\\CYRCH": "Ч",
  	"\\cyrchar\\CYRSH": "Ш",
  	"\\cyrchar\\CYRSHCH": "Щ",
  	"\\cyrchar\\CYRHRDSN": "Ъ",
  	"\\bud": "Ъ",
  	"\\cdprime": "Ъ",
  	"\\cyrchar\\CYRERY": "Ы",
  	"\\cyrchar\\CYRSFTSN": "Ь",
  	"\\cprime": "Ь",
  	"\\cyrchar\\CYREREV": "Э",
  	"\\cyrchar\\CYRYU": "Ю",
  	"\\cyrchar\\CYRYA": "Я",
  	"\\cyrchar\\cyra": "а",
  	"\\cyrchar\\cyrb": "б",
  	"\\cyrchar\\cyrv": "в",
  	"\\cyrchar\\cyrg": "г",
  	"\\cyrchar\\cyrd": "д",
  	"\\cyrchar\\cyre": "е",
  	"\\cyrchar\\cyrzh": "ж",
  	"\\cyrchar\\cyrz": "з",
  	"\\cyrchar\\cyri": "и",
  	"\\cyrchar\\cyrishrt": "й",
  	"\\cyrchar\\cyrk": "к",
  	"\\cyrchar\\cyrl": "л",
  	"\\cyrchar\\cyrm": "м",
  	"\\cyrchar\\cyrn": "н",
  	"\\cyrchar\\cyro": "о",
  	"\\cyrchar\\cyrp": "п",
  	"\\cyrchar\\cyrr": "р",
  	"\\cyrchar\\cyrs": "с",
  	"\\cyrchar\\cyrt": "т",
  	"\\cyrchar\\cyru": "у",
  	"\\cyrchar\\cyrf": "ф",
  	"\\cyrchar\\cyrh": "х",
  	"\\cyrchar\\cyrc": "ц",
  	"\\cyrchar\\cyrch": "ч",
  	"\\cyrchar\\cyrsh": "ш",
  	"\\cyrchar\\cyrshch": "щ",
  	"\\cyrchar\\cyrhrdsn": "ъ",
  	"\\cyrchar\\cyrery": "ы",
  	"\\cyrchar\\cyrsftsn": "ь",
  	"\\cyrchar\\cyrerev": "э",
  	"\\cyrchar\\cyryu": "ю",
  	"\\cyrchar\\cyrya": "я",
  	"\\cyrchar\\cyryo": "ё",
  	"\\cyrchar\\cyrdje": "ђ",
  	"\\cyrchar{\\'\\cyrg}": "ѓ",
  	"\\cyrchar\\cyrie": "є",
  	"\\cyrchar\\cyrdze": "ѕ",
  	"\\cyrchar\\cyrii": "і",
  	"\\cyrchar\\cyryi": "ї",
  	"\\cyrchar\\cyrje": "ј",
  	"\\cyrchar\\cyrlje": "љ",
  	"\\cyrchar\\cyrnje": "њ",
  	"\\cyrchar\\cyrtshe": "ћ",
  	"\\cyrchar{\\'\\cyrk}": "ќ",
  	"\\cyrchar\\cyrushrt": "ў",
  	"\\cyrchar\\cyrdzhe": "џ",
  	"\\cyrchar\\CYROMEGA": "Ѡ",
  	"\\cyrchar\\cyromega": "ѡ",
  	"\\cyrchar\\CYRYAT": "Ѣ",
  	"\\cyrchar\\CYRIOTE": "Ѥ",
  	"\\cyrchar\\cyriote": "ѥ",
  	"\\cyrchar\\CYRLYUS": "Ѧ",
  	"\\cyrchar\\cyrlyus": "ѧ",
  	"\\cyrchar\\CYRIOTLYUS": "Ѩ",
  	"\\cyrchar\\cyriotlyus": "ѩ",
  	"\\cyrchar\\CYRBYUS": "Ѫ",
  	"\\cyrchar\\CYRIOTBYUS": "Ѭ",
  	"\\cyrchar\\cyriotbyus": "ѭ",
  	"\\cyrchar\\CYRKSI": "Ѯ",
  	"\\cyrchar\\cyrksi": "ѯ",
  	"\\cyrchar\\CYRPSI": "Ѱ",
  	"\\cyrchar\\cyrpsi": "ѱ",
  	"\\cyrchar\\CYRFITA": "Ѳ",
  	"\\cyrchar\\CYRIZH": "Ѵ",
  	"\\cyrchar\\CYRUK": "Ѹ",
  	"\\cyrchar\\cyruk": "ѹ",
  	"\\cyrchar\\CYROMEGARND": "Ѻ",
  	"\\cyrchar\\cyromegarnd": "ѻ",
  	"\\cyrchar\\CYROMEGATITLO": "Ѽ",
  	"\\cyrchar\\cyromegatitlo": "ѽ",
  	"\\cyrchar\\CYROT": "Ѿ",
  	"\\cyrchar\\cyrot": "ѿ",
  	"\\cyrchar\\CYRKOPPA": "Ҁ",
  	"\\cyrchar\\cyrkoppa": "ҁ",
  	"\\cyrchar\\cyrthousands": "҂",
  	"\\cyrchar\\cyrhundredthousands": "҈",
  	"\\cyrchar\\cyrmillions": "҉",
  	"\\cyrchar\\CYRSEMISFTSN": "Ҍ",
  	"\\cyrchar\\cyrsemisftsn": "ҍ",
  	"\\cyrchar\\CYRRTICK": "Ҏ",
  	"\\cyrchar\\cyrrtick": "ҏ",
  	"\\cyrchar\\CYRGUP": "Ґ",
  	"\\cyrchar\\cyrgup": "ґ",
  	"\\cyrchar\\CYRGHCRS": "Ғ",
  	"\\cyrchar\\cyrghcrs": "ғ",
  	"\\cyrchar\\CYRGHK": "Ҕ",
  	"\\cyrchar\\cyrghk": "ҕ",
  	"\\cyrchar\\CYRZHDSC": "Җ",
  	"\\cyrchar\\cyrzhdsc": "җ",
  	"\\cyrchar\\CYRZDSC": "Ҙ",
  	"\\cyrchar\\cyrzdsc": "ҙ",
  	"\\cyrchar\\CYRKDSC": "Қ",
  	"\\cyrchar\\cyrkdsc": "қ",
  	"\\cyrchar\\CYRKVCRS": "Ҝ",
  	"\\cyrchar\\cyrkvcrs": "ҝ",
  	"\\cyrchar\\CYRKHCRS": "Ҟ",
  	"\\cyrchar\\cyrkhcrs": "ҟ",
  	"\\cyrchar\\CYRKBEAK": "Ҡ",
  	"\\cyrchar\\cyrkbeak": "ҡ",
  	"\\cyrchar\\CYRNDSC": "Ң",
  	"\\cyrchar\\cyrndsc": "ң",
  	"\\cyrchar\\CYRNG": "Ҥ",
  	"\\cyrchar\\cyrng": "ҥ",
  	"\\cyrchar\\CYRPHK": "Ҧ",
  	"\\cyrchar\\cyrphk": "ҧ",
  	"\\cyrchar\\CYRABHHA": "Ҩ",
  	"\\cyrchar\\cyrabhha": "ҩ",
  	"\\cyrchar\\CYRSDSC": "Ҫ",
  	"\\cyrchar\\cyrsdsc": "ҫ",
  	"\\cyrchar\\CYRTDSC": "Ҭ",
  	"\\cyrchar\\cyrtdsc": "ҭ",
  	"\\cyrchar\\CYRY": "Ү",
  	"\\cyrchar\\cyry": "ү",
  	"\\cyrchar\\CYRYHCRS": "Ұ",
  	"\\cyrchar\\cyryhcrs": "ұ",
  	"\\cyrchar\\CYRHDSC": "Ҳ",
  	"\\cyrchar\\cyrhdsc": "ҳ",
  	"\\cyrchar\\CYRTETSE": "Ҵ",
  	"\\cyrchar\\cyrtetse": "ҵ",
  	"\\cyrchar\\CYRCHRDSC": "Ҷ",
  	"\\cyrchar\\cyrchrdsc": "ҷ",
  	"\\cyrchar\\CYRCHVCRS": "Ҹ",
  	"\\cyrchar\\cyrchvcrs": "ҹ",
  	"\\cyrchar\\CYRSHHA": "Һ",
  	"\\cyrchar\\cyrshha": "һ",
  	"\\cyrchar\\CYRABHCH": "Ҽ",
  	"\\cyrchar\\cyrabhch": "ҽ",
  	"\\cyrchar\\CYRABHCHDSC": "Ҿ",
  	"\\cyrchar\\cyrabhchdsc": "ҿ",
  	"\\cyrchar\\CYRpalochka": "Ӏ",
  	"\\cyrchar\\CYRKHK": "Ӄ",
  	"\\cyrchar\\cyrkhk": "ӄ",
  	"\\cyrchar\\CYRNHK": "Ӈ",
  	"\\cyrchar\\cyrnhk": "ӈ",
  	"\\cyrchar\\CYRCHLDSC": "Ӌ",
  	"\\cyrchar\\cyrchldsc": "ӌ",
  	"\\cyrchar\\CYRAE": "Ӕ",
  	"\\cyrchar\\cyrae": "ӕ",
  	"\\cyrchar\\CYRSCHWA": "Ә",
  	"\\cyrchar\\cyrschwa": "ә",
  	"\\cyrchar\\CYRABHDZE": "Ӡ",
  	"\\cyrchar\\cyrabhdze": "ӡ",
  	"\\cyrchar\\CYROTLD": "Ө",
  	"\\cyrchar\\cyrotld": "ө",
  	"\\\\backslash": "ࡱ",
  	"\\textsuperscript{a}": "ᵃ",
  	"^{a}": "ᵃ",
  	"\\textsuperscript{b}": "ᵇ",
  	"^{b}": "ᵇ",
  	"\\textsuperscript{d}": "ᵈ",
  	"^{d}": "ᵈ",
  	"\\textsuperscript{e}": "ᵉ",
  	"^{e}": "ᵉ",
  	"\\textsuperscript{g}": "ᵍ",
  	"^{g}": "ᵍ",
  	"\\textsuperscript{k}": "ᵏ",
  	"^{k}": "ᵏ",
  	"\\textsuperscript{m}": "ᵐ",
  	"^{m}": "ᵐ",
  	"\\textsuperscript{o}": "ᵒ",
  	"^{o}": "ᵒ",
  	"\\textsuperscript{p}": "ᵖ",
  	"^{p}": "ᵖ",
  	"\\textsuperscript{t}": "ᵗ",
  	"^{t}": "ᵗ",
  	"\\textsuperscript{u}": "ᵘ",
  	"^{u}": "ᵘ",
  	"\\textsuperscript{v}": "ᵛ",
  	"^{v}": "ᵛ",
  	"\\textsuperscript{c}": "ᶜ",
  	"^{c}": "ᶜ",
  	"\\textsuperscript{f}": "ᶠ",
  	"^{f}": "ᶠ",
  	"\\textsuperscript{z}": "ᶻ",
  	"^{z}": "ᶻ",
  	"\\.B": "Ḃ",
  	"\\.b": "ḃ",
  	"\\d{B}": "Ḅ",
  	"\\d{b}": "ḅ",
  	"\\b{B}": "Ḇ",
  	"\\b{b}": "ḇ",
  	"\\.D": "Ḋ",
  	"\\.d": "ḋ",
  	"\\d{D}": "Ḍ",
  	"\\d{d}": "ḍ",
  	"\\b{D}": "Ḏ",
  	"\\b{d}": "ḏ",
  	"\\c{D}": "Ḑ",
  	"\\c{d}": "ḑ",
  	"\\c{\\u{E}}": "Ḝ",
  	"\\c{\\u{e}}": "ḝ",
  	"\\.F": "Ḟ",
  	"\\.f": "ḟ",
  	"\\=G": "Ḡ",
  	"\\=g": "ḡ",
  	"\\.H": "Ḣ",
  	"\\.h": "ḣ",
  	"\\d{H}": "Ḥ",
  	"\\d{h}": "ḥ",
  	"\\\"H": "Ḧ",
  	"\\\"h": "ḧ",
  	"\\c{H}": "Ḩ",
  	"\\c{h}": "ḩ",
  	"\\'K": "Ḱ",
  	"\\'k": "ḱ",
  	"\\d{K}": "Ḳ",
  	"\\d{k}": "ḳ",
  	"\\b{K}": "Ḵ",
  	"\\b{k}": "ḵ",
  	"\\d{L}": "Ḷ",
  	"\\d{l}": "ḷ",
  	"\\b{L}": "Ḻ",
  	"\\b{l}": "ḻ",
  	"\\'M": "Ḿ",
  	"\\'m": "ḿ",
  	"\\.M": "Ṁ",
  	"\\.m": "ṁ",
  	"\\d{M}": "Ṃ",
  	"\\d{m}": "ṃ",
  	"\\.N": "Ṅ",
  	"\\.n": "ṅ",
  	"\\d{N}": "Ṇ",
  	"\\d{n}": "ṇ",
  	"\\b{N}": "Ṉ",
  	"\\b{n}": "ṉ",
  	"\\'P": "Ṕ",
  	"\\'p": "ṕ",
  	"\\.P": "Ṗ",
  	"\\.p": "ṗ",
  	"\\.R": "Ṙ",
  	"\\.r": "ṙ",
  	"\\d{R}": "Ṛ",
  	"\\d{r}": "ṛ",
  	"\\b{R}": "Ṟ",
  	"\\b{r}": "ṟ",
  	"\\.S": "Ṡ",
  	"\\.s": "ṡ",
  	"\\d{S}": "Ṣ",
  	"\\d{s}": "ṣ",
  	"\\.T": "Ṫ",
  	"\\.t": "ṫ",
  	"\\d{T}": "Ṭ",
  	"\\d{t}": "ṭ",
  	"\\b{T}": "Ṯ",
  	"\\b{t}": "ṯ",
  	"\\~V": "Ṽ",
  	"\\~v": "ṽ",
  	"\\d{V}": "Ṿ",
  	"\\d{v}": "ṿ",
  	"\\`W": "Ẁ",
  	"\\`w": "ẁ",
  	"\\'W": "Ẃ",
  	"\\'w": "ẃ",
  	"\\\"W": "Ẅ",
  	"\\\"w": "ẅ",
  	"\\.W": "Ẇ",
  	"\\.w": "ẇ",
  	"\\d{W}": "Ẉ",
  	"\\d{w}": "ẉ",
  	"\\.X": "Ẋ",
  	"\\.x": "ẋ",
  	"\\\"X": "Ẍ",
  	"\\\"x": "ẍ",
  	"\\.Y": "Ẏ",
  	"\\.y": "ẏ",
  	"\\^Z": "Ẑ",
  	"\\^z": "ẑ",
  	"\\d{Z}": "Ẓ",
  	"\\d{z}": "ẓ",
  	"\\b{Z}": "Ẕ",
  	"\\b{z}": "ẕ",
  	"\\b{h}": "ẖ",
  	"\\\"t": "ẗ",
  	"\\r{w}": "ẘ",
  	"\\r{y}": "ẙ",
  	"\\d{A}": "Ạ",
  	"\\d{a}": "ạ",
  	"\\d{E}": "Ẹ",
  	"\\d{e}": "ẹ",
  	"\\~E": "Ẽ",
  	"\\~e": "ẽ",
  	"\\d{I}": "Ị",
  	"\\d{i}": "ị",
  	"\\d{O}": "Ọ",
  	"\\d{o}": "ọ",
  	"\\d{U}": "Ụ",
  	"\\d{u}": "ụ",
  	"\\`Y": "Ỳ",
  	"\\`y": "ỳ",
  	"\\d{Y}": "Ỵ",
  	"\\d{y}": "ỵ",
  	"\\~Y": "Ỹ",
  	"\\~y": "ỹ",
  	"\\hspace{0.6em}": " ",
  	"\\hspace{1em}": " ",
  	"\\quad": " ",
  	"\\;": " ",
  	"\\hspace{0.25em}": " ",
  	"\\hspace{0.166em}": " ",
  	"\\hphantom{0}": " ",
  	"\\hphantom{,}": " ",
  	"\\,": " ",
  	"\\mkern1mu": " ",
  	"\\mbox": "​",
  	"{\\aftergroup\\ignorespaces}": "‌",
  	"\\textendash": "–",
  	"\\textemdash": "—",
  	"\\rule{1em}{1pt}": "―",
  	"\\horizbar": "―",
  	"\\Vert": "‖",
  	"\\twolowline": "‗",
  	"\\textquoteleft": "‘",
  	"\\textquoteright": "’",
  	"\\Elzreapos": "‛",
  	"\\textquotedblleft": "“",
  	"\\textquotedblright": "”",
  	"\\quotedblbase": "‟",
  	"\\textdagger": "†",
  	"\\dagger": "†",
  	"\\textdaggerdbl": "‡",
  	"\\ddagger": "‡",
  	"\\textbullet": "•",
  	"\\enleadertwodots": "‥",
  	"\\ldots": "…",
  	"\\textperthousand": "‰",
  	"\\textpertenthousand": "‱",
  	"{'}": "′",
  	"{''}": "″",
  	"{'''}": "‴",
  	"\\backprime": "‵",
  	"\\backdprime": "‶",
  	"\\backtrprime": "‷",
  	"\\caretinsert": "‸",
  	"\\guilsinglleft": "‹",
  	"\\guilsinglright": "›",
  	"\\Exclam": "‼",
  	"\\hyphenbullet": "⁃",
  	"\\fracslash": "⁄",
  	"\\Question": "⁇",
  	"\\closure": "⁐",
  	"\\:": " ",
  	"\\nolinebreak": "⁠",
  	"^{0}": "⁰",
  	"\\textsuperscript{i}": "ⁱ",
  	"^{i}": "ⁱ",
  	"^{4}": "⁴",
  	"^{5}": "⁵",
  	"^{6}": "⁶",
  	"^{7}": "⁷",
  	"^{8}": "⁸",
  	"^{9}": "⁹",
  	"^{+}": "⁺",
  	"^{-}": "⁻",
  	"^{=}": "⁼",
  	"^{(}": "⁽",
  	"^{)}": "⁾",
  	"\\textsuperscript{n}": "ⁿ",
  	"^{n}": "ⁿ",
  	"_{0}": "₀",
  	"_{1}": "₁",
  	"_{2}": "₂",
  	"_{3}": "₃",
  	"_{4}": "₄",
  	"_{5}": "₅",
  	"_{6}": "₆",
  	"_{7}": "₇",
  	"_{8}": "₈",
  	"_{9}": "₉",
  	"_{+}": "₊",
  	"_{-}": "₋",
  	"_{=}": "₌",
  	"_{(}": "₍",
  	"_{)}": "₎",
  	"\\textsubscript{a}": "ₐ",
  	"_{a}": "ₐ",
  	"\\textsubscript{e}": "ₑ",
  	"_{e}": "ₑ",
  	"\\textsubscript{o}": "ₒ",
  	"_{o}": "ₒ",
  	"\\textsubscript{x}": "ₓ",
  	"_{x}": "ₓ",
  	"\\textsubscript{\\textschwa}": "ₔ",
  	"\\textsubscript{h}": "ₕ",
  	"_{h}": "ₕ",
  	"\\textsubscript{k}": "ₖ",
  	"_{k}": "ₖ",
  	"\\textsubscript{l}": "ₗ",
  	"_{l}": "ₗ",
  	"\\textsubscript{m}": "ₘ",
  	"_{m}": "ₘ",
  	"\\textsubscript{n}": "ₙ",
  	"_{n}": "ₙ",
  	"\\textsubscript{p}": "ₚ",
  	"_{p}": "ₚ",
  	"\\textsubscript{s}": "ₛ",
  	"_{s}": "ₛ",
  	"\\textsubscript{t}": "ₜ",
  	"_{t}": "ₜ",
  	"\\ensuremath{\\Elzpes}": "₧",
  	"\\texteuro": "€",
  	"\\euro": "€",
  	"\\lvec": "⃐",
  	"\\vertoverlay": "⃒",
  	"\\LVec": "⃖",
  	"\\vec": "⃗",
  	"\\dddot": "⃛",
  	"\\ddddot": "⃜",
  	"\\enclosecircle": "⃝",
  	"\\enclosesquare": "⃞",
  	"\\enclosediamond": "⃟",
  	"\\overleftrightarrow": "⃡",
  	"\\enclosetriangle": "⃤",
  	"\\annuity": "⃧",
  	"\\threeunderdot": "⃨",
  	"\\widebridgeabove": "⃩",
  	"\\underrightharpoondown": "⃬",
  	"\\underleftharpoondown": "⃭",
  	"\\underleftarrow": "⃮",
  	"\\underrightarrow": "⃯",
  	"\\asteraccent": "⃰",
  	"\\mathbb{C}": "ℂ",
  	"\\textcelsius": "℃",
  	"\\Euler": "ℇ",
  	"\\mathscr{g}": "ℊ",
  	"\\mathscr{H}": "ℋ",
  	"\\mathfrak{H}": "ℌ",
  	"\\mathbb{H}": "ℍ",
  	"\\Planckconst": "ℎ",
  	"\\hslash": "ℏ",
  	"\\mathscr{I}": "ℐ",
  	"\\mathfrak{I}": "ℑ",
  	"\\mathscr{L}": "ℒ",
  	"\\mathscr{l}": "ℓ",
  	"\\mathbb{N}": "ℕ",
  	"\\cyrchar\\textnumero": "№",
  	"\\textcircledP": "℗",
  	"\\wp": "℘",
  	"\\mathbb{P}": "ℙ",
  	"\\mathbb{Q}": "ℚ",
  	"\\mathscr{R}": "ℛ",
  	"\\mathfrak{R}": "ℜ",
  	"\\mathbb{R}": "ℝ",
  	"\\Elzxrat": "℞",
  	"\\textservicemark": "℠",
  	"\\texttrademark": "™",
  	"\\mathbb{Z}": "ℤ",
  	"\\mho": "℧",
  	"\\mathfrak{Z}": "ℨ",
  	"\\textriota": "℩",
  	"\\Angstroem": "Å",
  	"\\mathscr{B}": "ℬ",
  	"\\mathfrak{C}": "ℭ",
  	"\\textestimated": "℮",
  	"\\mathscr{e}": "ℯ",
  	"\\mathscr{E}": "ℰ",
  	"\\mathscr{F}": "ℱ",
  	"\\Finv": "Ⅎ",
  	"\\mathscr{M}": "ℳ",
  	"\\mathscr{o}": "ℴ",
  	"\\aleph": "ℵ",
  	"\\beth": "ℶ",
  	"\\gimel": "ℷ",
  	"\\daleth": "ℸ",
  	"\\mathbb{\\pi}": "ℼ",
  	"\\mathbb{\\gamma}": "ℽ",
  	"\\mathbb{\\Gamma}": "ℾ",
  	"\\mathbb{\\Pi}": "ℿ",
  	"\\mathbb{\\Sigma}": "⅀",
  	"\\Game": "⅁",
  	"\\sansLturned": "⅂",
  	"\\sansLmirrored": "⅃",
  	"\\Yup": "⅄",
  	"\\CapitalDifferentialD": "ⅅ",
  	"\\DifferentialD": "ⅆ",
  	"\\ExponetialE": "ⅇ",
  	"\\ComplexI": "ⅈ",
  	"\\ComplexJ": "ⅉ",
  	"\\PropertyLine": "⅊",
  	"\\invamp": "⅋",
  	"\\frac{1}{7}": "⅐",
  	"\\textfrac{1}{7}": "⅐",
  	"\\frac{1}{9}": "⅑",
  	"\\textfrac{1}{9}": "⅑",
  	"\\frac{1}{10}": "⅒",
  	"\\textfrac{1}{10}": "⅒",
  	"\\frac{1}{3}": "⅓",
  	"\\textfrac{1}{3}": "⅓",
  	"\\frac{2}{3}": "⅔",
  	"\\textfrac{2}{3}": "⅔",
  	"\\frac{1}{5}": "⅕",
  	"\\textfrac{1}{5}": "⅕",
  	"\\frac{2}{5}": "⅖",
  	"\\textfrac{2}{5}": "⅖",
  	"\\frac{3}{5}": "⅗",
  	"\\textfrac{3}{5}": "⅗",
  	"\\frac{4}{5}": "⅘",
  	"\\textfrac{4}{5}": "⅘",
  	"\\frac{1}{6}": "⅙",
  	"\\textfrac{1}{6}": "⅙",
  	"\\frac{5}{6}": "⅚",
  	"\\textfrac{5}{6}": "⅚",
  	"\\frac{1}{8}": "⅛",
  	"\\textfrac{1}{8}": "⅛",
  	"\\frac{3}{8}": "⅜",
  	"\\textfrac{3}{8}": "⅜",
  	"\\frac{5}{8}": "⅝",
  	"\\textfrac{5}{8}": "⅝",
  	"\\frac{7}{8}": "⅞",
  	"\\textfrac{7}{8}": "⅞",
  	"\\frac{1}": "⅟",
  	"\\textfrac{1}": "⅟",
  	"\\frac{0}{3}": "↉",
  	"\\textfrac{0}{3}": "↉",
  	"\\leftarrow": "←",
  	"\\uparrow": "↑",
  	"\\textrightarrow": "→",
  	"\\rightarrow": "→",
  	"\\to": "→",
  	"\\downarrow": "↓",
  	"\\leftrightarrow": "↔",
  	"\\updownarrow": "↕",
  	"\\nwarrow": "↖",
  	"\\nearrow": "↗",
  	"\\searrow": "↘",
  	"\\swarrow": "↙",
  	"\\nleftarrow": "↚",
  	"\\nrightarrow": "↛",
  	"\\arrowwaveleft": "↜",
  	"\\arrowwaveright": "↝",
  	"\\twoheadleftarrow": "↞",
  	"\\twoheaduparrow": "↟",
  	"\\twoheadrightarrow": "↠",
  	"\\twoheaddownarrow": "↡",
  	"\\leftarrowtail": "↢",
  	"\\rightarrowtail": "↣",
  	"\\mapsfrom": "↤",
  	"\\MapsUp": "↥",
  	"\\mapsto": "↦",
  	"\\MapsDown": "↧",
  	"\\updownarrowbar": "↨",
  	"\\hookleftarrow": "↩",
  	"\\hookrightarrow": "↪",
  	"\\looparrowleft": "↫",
  	"\\looparrowright": "↬",
  	"\\leftrightsquigarrow": "↭",
  	"\\nleftrightarrow": "↮",
  	"\\lightning": "↯",
  	"\\Lsh": "↰",
  	"\\Rsh": "↱",
  	"\\dlsh": "↲",
  	"\\reflectbox{\\carriagereturn}": "↳",
  	"\\linefeed": "↴",
  	"\\carriagereturn": "↵",
  	"\\curvearrowleft": "↶",
  	"\\curvearrowright": "↷",
  	"\\barovernorthwestarrow": "↸",
  	"\\barleftarrowrightarrowba": "↹",
  	"\\circlearrowleft": "↺",
  	"\\circlearrowright": "↻",
  	"\\leftharpoonup": "↼",
  	"\\leftharpoondown": "↽",
  	"\\upharpoonright": "↾",
  	"\\upharpoonleft": "↿",
  	"\\rightharpoonup": "⇀",
  	"\\rightharpoondown": "⇁",
  	"\\downharpoonright": "⇂",
  	"\\downharpoonleft": "⇃",
  	"\\rightleftarrows": "⇄",
  	"\\dblarrowupdown": "⇅",
  	"\\leftrightarrows": "⇆",
  	"\\leftleftarrows": "⇇",
  	"\\upuparrows": "⇈",
  	"\\rightrightarrows": "⇉",
  	"\\downdownarrows": "⇊",
  	"\\leftrightharpoons": "⇋",
  	"\\rightleftharpoons": "⇌",
  	"\\nLeftarrow": "⇍",
  	"\\nLeftrightarrow": "⇎",
  	"\\nRightarrow": "⇏",
  	"\\Leftarrow": "⇐",
  	"\\Uparrow": "⇑",
  	"\\Rightarrow": "⇒",
  	"\\Downarrow": "⇓",
  	"\\Leftrightarrow": "⇔",
  	"\\Updownarrow": "⇕",
  	"\\Nwarrow": "⇖",
  	"\\Nearrow": "⇗",
  	"\\Searrow": "⇘",
  	"\\Swarrow": "⇙",
  	"\\Lleftarrow": "⇚",
  	"\\Rrightarrow": "⇛",
  	"\\leftsquigarrow": "⇜",
  	"\\rightsquigarrow": "⇝",
  	"\\nHuparrow": "⇞",
  	"\\nHdownarrow": "⇟",
  	"\\dashleftarrow": "⇠",
  	"\\updasharrow": "⇡",
  	"\\dashrightarrow": "⇢",
  	"\\downdasharrow": "⇣",
  	"\\LeftArrowBar": "⇤",
  	"\\RightArrowBar": "⇥",
  	"\\leftwhitearrow": "⇦",
  	"\\upwhitearrow": "⇧",
  	"\\rightwhitearrow": "⇨",
  	"\\downwhitearrow": "⇩",
  	"\\whitearrowupfrombar": "⇪",
  	"\\circleonrightarrow": "⇴",
  	"\\DownArrowUpArrow": "⇵",
  	"\\rightthreearrows": "⇶",
  	"\\nvleftarrow": "⇷",
  	"\\pfun": "⇸",
  	"\\nvleftrightarrow": "⇹",
  	"\\nVleftarrow": "⇺",
  	"\\ffun": "⇻",
  	"\\nVleftrightarrow": "⇼",
  	"\\leftarrowtriangle": "⇽",
  	"\\rightarrowtriangle": "⇾",
  	"\\leftrightarrowtriangle": "⇿",
  	"\\forall": "∀",
  	"\\complement": "∁",
  	"\\partial": "∂",
  	"\\exists": "∃",
  	"\\nexists": "∄",
  	"\\varnothing": "∅",
  	"\\increment": "∆",
  	"\\nabla": "∇",
  	"\\in": "∈",
  	"\\not\\in": "∉",
  	"\\smallin": "∊",
  	"\\ni": "∋",
  	"\\not\\ni": "∌",
  	"\\smallni": "∍",
  	"\\QED": "∎",
  	"\\prod": "∏",
  	"\\coprod": "∐",
  	"\\sum": "∑",
  	"\\mp": "∓",
  	"\\dotplus": "∔",
  	"\\setminus": "∖",
  	"{_\\ast}": "∗",
  	"\\circ": "∘",
  	"\\bullet": "∙",
  	"\\surd": "√",
  	"\\sqrt[3]": "∛",
  	"\\sqrt[4]": "∜",
  	"\\propto": "∝",
  	"\\infty": "∞",
  	"\\rightangle": "∟",
  	"\\angle": "∠",
  	"\\measuredangle": "∡",
  	"\\sphericalangle": "∢",
  	"\\mid": "∣",
  	"\\nmid": "∤",
  	"\\parallel": "∥",
  	"\\nparallel": "∦",
  	"\\wedge": "∧",
  	"\\vee": "∨",
  	"\\cap": "∩",
  	"\\cup": "∪",
  	"\\int": "∫",
  	"{\\int\\!\\int}": "∬",
  	"{\\int\\!\\int\\!\\int}": "∭",
  	"\\oint": "∮",
  	"\\surfintegral": "∯",
  	"\\volintegral": "∰",
  	"\\clwintegral": "∱",
  	"\\lcirclerightint": "∲",
  	"\\rcirclerightint": "∳",
  	"\\therefore": "∴",
  	"\\because": "∵",
  	"\\Colon": "∷",
  	"\\dotdiv": "∸",
  	"\\eqcolon": "∹",
  	"\\mathbin{{:}\\!\\!{-}\\!\\!{:}}": "∺",
  	"\\homothetic": "∻",
  	"\\sim": "∼",
  	"\\backsim": "∽",
  	"\\lazysinv": "∾",
  	"\\AC": "∿",
  	"\\wr": "≀",
  	"\\not\\sim": "≁",
  	"\\texteqsim": "≂",
  	"\\NotEqualTilde": "≂̸",
  	"\\simeq": "≃",
  	"\\not\\simeq": "≄",
  	"\\cong": "≅",
  	"\\approxnotequal": "≆",
  	"\\not\\cong": "≇",
  	"\\approx": "≈",
  	"\\not\\approx": "≉",
  	"\\approxeq": "≊",
  	"\\tildetrpl": "≋",
  	"\\not\\apid": "≋̸",
  	"\\allequal": "≌",
  	"\\asymp": "≍",
  	"\\Bumpeq": "≎",
  	"\\NotHumpDownHump": "≎̸",
  	"\\bumpeq": "≏",
  	"\\NotHumpEqual": "≏̸",
  	"\\doteq": "≐",
  	"\\not\\doteq": "≐̸",
  	"\\doteqdot": "≑",
  	"\\fallingdotseq": "≒",
  	"\\risingdotseq": "≓",
  	"\\coloneq": "≔",
  	"\\eqcirc": "≖",
  	"\\circeq": "≗",
  	"\\arceq": "≘",
  	"\\estimates": "≙",
  	"\\starequal": "≛",
  	"\\triangleq": "≜",
  	"\\eqdef": "≝",
  	"\\measeq": "≞",
  	"\\neq": "≠",
  	"\\equiv": "≡",
  	"\\not\\equiv": "≢",
  	"\\Equiv": "≣",
  	"\\leq": "≤",
  	"\\le": "≤",
  	"\\geq": "≥",
  	"\\leqq": "≦",
  	"\\geqq": "≧",
  	"\\lneqq": "≨",
  	"\\lvertneqq": "≨︀",
  	"\\gneqq": "≩",
  	"\\gvertneqq": "≩︀",
  	"\\ll": "≪",
  	"\\NotLessLess": "≪̸",
  	"\\gg": "≫",
  	"\\NotGreaterGreater": "≫̸",
  	"\\between": "≬",
  	"{\\not\\kern-0.3em\\times}": "≭",
  	"\\not<": "≮",
  	"\\not>": "≯",
  	"\\not\\leq": "≰",
  	"\\not\\geq": "≱",
  	"\\lessequivlnt": "≲",
  	"\\greaterequivlnt": "≳",
  	"\\lessgtr": "≶",
  	"\\gtrless": "≷",
  	"\\notlessgreater": "≸",
  	"\\notgreaterless": "≹",
  	"\\prec": "≺",
  	"\\succ": "≻",
  	"\\preccurlyeq": "≼",
  	"\\succcurlyeq": "≽",
  	"\\NotPrecedesTilde": "≾̸",
  	"\\NotSucceedsTilde": "≿̸",
  	"\\not\\prec": "⊀",
  	"\\not\\succ": "⊁",
  	"\\subset": "⊂",
  	"\\supset": "⊃",
  	"\\not\\subset": "⊄",
  	"\\not\\supset": "⊅",
  	"\\subseteq": "⊆",
  	"\\supseteq": "⊇",
  	"\\not\\subseteq": "⊈",
  	"\\not\\supseteq": "⊉",
  	"\\subsetneq": "⊊",
  	"\\varsubsetneqq": "⊊︀",
  	"\\supsetneq": "⊋",
  	"\\varsupsetneq": "⊋︀",
  	"\\cupleftarrow": "⊌",
  	"\\cupdot": "⊍",
  	"\\uplus": "⊎",
  	"\\sqsubset": "⊏",
  	"\\NotSquareSubset": "⊏̸",
  	"\\sqsupset": "⊐",
  	"\\NotSquareSuperset": "⊐̸",
  	"\\sqsubseteq": "⊑",
  	"\\sqsupseteq": "⊒",
  	"\\sqcap": "⊓",
  	"\\sqcup": "⊔",
  	"\\oplus": "⊕",
  	"\\ominus": "⊖",
  	"\\otimes": "⊗",
  	"\\oslash": "⊘",
  	"\\odot": "⊙",
  	"\\circledcirc": "⊚",
  	"\\circledast": "⊛",
  	"\\circledequal": "⊜",
  	"\\circleddash": "⊝",
  	"\\boxplus": "⊞",
  	"\\boxminus": "⊟",
  	"\\boxtimes": "⊠",
  	"\\boxdot": "⊡",
  	"\\vdash": "⊢",
  	"\\dashv": "⊣",
  	"\\top": "⊤",
  	"\\assert": "⊦",
  	"\\truestate": "⊧",
  	"\\forcesextra": "⊨",
  	"\\Vdash": "⊩",
  	"\\Vvdash": "⊪",
  	"\\VDash": "⊫",
  	"\\nvdash": "⊬",
  	"\\nvDash": "⊭",
  	"\\nVdash": "⊮",
  	"\\nVDash": "⊯",
  	"\\prurel": "⊰",
  	"\\scurel": "⊱",
  	"\\vartriangleleft": "⊲",
  	"\\vartriangleright": "⊳",
  	"\\trianglelefteq": "⊴",
  	"\\trianglerighteq": "⊵",
  	"\\original": "⊶",
  	"\\image": "⊷",
  	"\\multimap": "⊸",
  	"\\hermitconjmatrix": "⊹",
  	"\\intercal": "⊺",
  	"\\veebar": "⊻",
  	"\\barvee": "⊽",
  	"\\rightanglearc": "⊾",
  	"\\varlrtriangle": "⊿",
  	"\\bigcap": "⋂",
  	"\\bigcup": "⋃",
  	"\\diamond": "⋄",
  	"\\cdot": "⋅",
  	"\\star": "⋆",
  	"\\divideontimes": "⋇",
  	"\\bowtie": "⋈",
  	"\\ltimes": "⋉",
  	"\\rtimes": "⋊",
  	"\\leftthreetimes": "⋋",
  	"\\rightthreetimes": "⋌",
  	"\\backsimeq": "⋍",
  	"\\curlyvee": "⋎",
  	"\\curlywedge": "⋏",
  	"\\Subset": "⋐",
  	"\\Supset": "⋑",
  	"\\Cap": "⋒",
  	"\\Cup": "⋓",
  	"\\pitchfork": "⋔",
  	"\\hash": "⋕",
  	"\\lessdot": "⋖",
  	"\\gtrdot": "⋗",
  	"\\verymuchless": "⋘",
  	"\\verymuchgreater": "⋙",
  	"\\lesseqgtr": "⋚",
  	"\\gtreqless": "⋛",
  	"\\eqless": "⋜",
  	"\\eqgtr": "⋝",
  	"\\curlyeqprec": "⋞",
  	"\\curlyeqsucc": "⋟",
  	"\\npreceq": "⋠",
  	"\\nsucceq": "⋡",
  	"\\not\\sqsubseteq": "⋢",
  	"\\not\\sqsupseteq": "⋣",
  	"\\sqsubsetneq": "⋤",
  	"\\Elzsqspne": "⋥",
  	"\\lnsim": "⋦",
  	"\\gnsim": "⋧",
  	"\\precedesnotsimilar": "⋨",
  	"\\succnsim": "⋩",
  	"\\ntriangleleft": "⋪",
  	"\\ntriangleright": "⋫",
  	"\\ntrianglelefteq": "⋬",
  	"\\ntrianglerighteq": "⋭",
  	"\\vdots": "⋮",
  	"\\cdots": "⋯",
  	"\\upslopeellipsis": "⋰",
  	"\\downslopeellipsis": "⋱",
  	"\\disin": "⋲",
  	"\\varisins": "⋳",
  	"\\isins": "⋴",
  	"\\isindot": "⋵",
  	"\\barin": "⋶",
  	"\\isinobar": "⋷",
  	"\\isinvb": "⋸",
  	"\\isinE": "⋹",
  	"\\nisd": "⋺",
  	"\\varnis": "⋻",
  	"\\nis": "⋼",
  	"\\varniobar": "⋽",
  	"\\niobar": "⋾",
  	"\\bagmember": "⋿",
  	"\\diameter": "⌀",
  	"\\house": "⌂",
  	"\\barwedge": "⌅",
  	"\\varbarwedge": "⌅",
  	"\\perspcorrespond": "⌆",
  	"\\lceil": "⌈",
  	"\\rceil": "⌉",
  	"\\lfloor": "⌊",
  	"\\rfloor": "⌋",
  	"\\invneg": "⌐",
  	"\\wasylozenge": "⌑",
  	"\\profline": "⌒",
  	"\\profsurf": "⌓",
  	"\\recorder": "⌕",
  	"{\\mathchar\"2208}": "⌖",
  	"\\viewdata": "⌗",
  	"\\turnednot": "⌙",
  	"\\ulcorner": "⌜",
  	"\\urcorner": "⌝",
  	"\\llcorner": "⌞",
  	"\\lrcorner": "⌟",
  	"\\inttop": "⌠",
  	"\\intbottom": "⌡",
  	"\\frown": "⌢",
  	"\\smile": "⌣",
  	"\\varhexagonlrbonds": "⌬",
  	"\\conictaper": "⌲",
  	"\\topbot": "⌶",
  	"\\APLinv": "⌹",
  	"\\notslash": "⌿",
  	"\\notbackslash": "⍀",
  	"\\APLleftarrowbox": "⍇",
  	"\\APLrightarrowbox": "⍈",
  	"\\invdiameter": "⍉",
  	"\\APLuparrowbox": "⍐",
  	"\\APLboxupcaret": "⍓",
  	"\\APLdownarrowbox": "⍗",
  	"\\APLcomment": "⍝",
  	"\\APLinput": "⍞",
  	"\\APLlog": "⍟",
  	"\\APLboxquestion": "⍰",
  	"\\rangledownzigzagarrow": "⍼",
  	"\\hexagon": "⎔",
  	"\\lparenuend": "⎛",
  	"\\lparenextender": "⎜",
  	"\\lparenlend": "⎝",
  	"\\rparenuend": "⎞",
  	"\\rparenextender": "⎟",
  	"\\rparenlend": "⎠",
  	"\\lbrackuend": "⎡",
  	"\\lbrackextender": "⎢",
  	"\\Elzdlcorn": "⎣",
  	"\\rbrackuend": "⎤",
  	"\\rbrackextender": "⎥",
  	"\\rbracklend": "⎦",
  	"\\lbraceuend": "⎧",
  	"\\lbracemid": "⎨",
  	"\\lbracelend": "⎩",
  	"\\vbraceextender": "⎪",
  	"\\rbraceuend": "⎫",
  	"\\rbracemid": "⎬",
  	"\\rbracelend": "⎭",
  	"\\intextender": "⎮",
  	"\\harrowextender": "⎯",
  	"\\lmoustache": "⎰",
  	"\\rmoustache": "⎱",
  	"\\sumtop": "⎲",
  	"\\sumbottom": "⎳",
  	"\\overbracket": "⎴",
  	"\\underbracket": "⎵",
  	"\\bbrktbrk": "⎶",
  	"\\sqrtbottom": "⎷",
  	"\\lvboxline": "⎸",
  	"\\rvboxline": "⎹",
  	"\\varcarriagereturn": "⏎",
  	"\\overparen": "⏜",
  	"\\underparen": "⏝",
  	"\\overbrace": "⏞",
  	"\\underbrace": "⏟",
  	"\\obrbrak": "⏠",
  	"\\ubrbrak": "⏡",
  	"\\trapezium": "⏢",
  	"\\benzenr": "⏣",
  	"\\strns": "⏤",
  	"\\fltns": "⏥",
  	"\\accurrent": "⏦",
  	"\\elinters": "⏧",
  	"\\textvisiblespace": "␣",
  	"\\ding{172}": "①",
  	"\\ding{173}": "②",
  	"\\ding{174}": "③",
  	"\\ding{175}": "④",
  	"\\ding{176}": "⑤",
  	"\\ding{177}": "⑥",
  	"\\ding{178}": "⑦",
  	"\\ding{179}": "⑧",
  	"\\ding{180}": "⑨",
  	"\\ding{181}": "⑩",
  	"\\circledS": "Ⓢ",
  	"\\Elzdshfnc": "┆",
  	"\\Elzsqfnw": "┙",
  	"\\diagup": "╱",
  	"\\blockuphalf": "▀",
  	"\\blocklowhalf": "▄",
  	"\\blockfull": "█",
  	"\\blocklefthalf": "▌",
  	"\\blockrighthalf": "▐",
  	"\\blockqtrshaded": "░",
  	"\\blockhalfshaded": "▒",
  	"\\blockthreeqtrshaded": "▓",
  	"\\ding{110}": "■",
  	"\\mdlgblksquare": "■",
  	"\\square": "□",
  	"\\Box": "□",
  	"\\squoval": "▢",
  	"\\blackinwhitesquare": "▣",
  	"\\squarehfill": "▤",
  	"\\squarevfill": "▥",
  	"\\squarehvfill": "▦",
  	"\\squarenwsefill": "▧",
  	"\\squareneswfill": "▨",
  	"\\squarecrossfill": "▩",
  	"\\smwhtsquare": "▫",
  	"\\hrectangleblack": "▬",
  	"\\fbox{~~}": "▭",
  	"\\vrectangleblack": "▮",
  	"\\Elzvrecto": "▯",
  	"\\parallelogramblack": "▰",
  	"\\ding{115}": "▲",
  	"\\bigblacktriangleup": "▲",
  	"\\bigtriangleup": "△",
  	"\\blacktriangle": "▴",
  	"\\vartriangle": "▵",
  	"\\RHD": "▶",
  	"\\rhd": "▷",
  	"\\blacktriangleright": "▸",
  	"\\triangleright": "▹",
  	"\\blackpointerright": "►",
  	"\\whitepointerright": "▻",
  	"\\ding{116}": "▼",
  	"\\bigblacktriangledown": "▼",
  	"\\bigtriangledown": "▽",
  	"\\blacktriangledown": "▾",
  	"\\triangledown": "▿",
  	"\\LHD": "◀",
  	"\\lhd": "◁",
  	"\\blacktriangleleft": "◂",
  	"\\triangleleft": "◃",
  	"\\blackpointerleft": "◄",
  	"\\whitepointerleft": "◅",
  	"\\ding{117}": "◆",
  	"\\Diamondblack": "◆",
  	"\\Diamond": "◇",
  	"\\blackinwhitediamond": "◈",
  	"\\fisheye": "◉",
  	"\\lozenge": "◊",
  	"\\dottedcircle": "◌",
  	"\\circlevertfill": "◍",
  	"\\bullseye": "◎",
  	"\\ding{108}": "●",
  	"\\CIRCLE": "●",
  	"\\Elzcirfl": "◐",
  	"\\Elzcirfr": "◑",
  	"\\Elzcirfb": "◒",
  	"\\circletophalfblack": "◓",
  	"\\circleurquadblack": "◔",
  	"\\blackcircleulquadwhite": "◕",
  	"\\LEFTCIRCLE": "◖",
  	"\\ding{119}": "◗",
  	"\\RIGHTCIRCLE": "◗",
  	"\\Elzrvbull": "◘",
  	"\\inversewhitecircle": "◙",
  	"\\invwhiteupperhalfcircle": "◚",
  	"\\invwhitelowerhalfcircle": "◛",
  	"\\ularc": "◜",
  	"\\urarc": "◝",
  	"\\lrarc": "◞",
  	"\\llarc": "◟",
  	"\\topsemicircle": "◠",
  	"\\botsemicircle": "◡",
  	"\\lrblacktriangle": "◢",
  	"\\llblacktriangle": "◣",
  	"\\ulblacktriangle": "◤",
  	"\\urblacktriangle": "◥",
  	"\\smwhtcircle": "◦",
  	"\\Elzsqfl": "◧",
  	"\\Elzsqfr": "◨",
  	"\\squareulblack": "◩",
  	"\\Elzsqfse": "◪",
  	"\\boxbar": "◫",
  	"\\trianglecdot": "◬",
  	"\\triangleleftblack": "◭",
  	"\\trianglerightblack": "◮",
  	"\\bigcirc": "◯",
  	"\\squareulquad": "◰",
  	"\\squarellquad": "◱",
  	"\\squarelrquad": "◲",
  	"\\squareurquad": "◳",
  	"\\circleulquad": "◴",
  	"\\circlellquad": "◵",
  	"\\circlelrquad": "◶",
  	"\\circleurquad": "◷",
  	"\\ultriangle": "◸",
  	"\\urtriangle": "◹",
  	"\\lltriangle": "◺",
  	"\\mdsmwhtsquare": "◽",
  	"\\mdsmblksquare": "◾",
  	"\\lrtriangle": "◿",
  	"\\ding{72}": "★",
  	"\\bigstar": "★",
  	"\\ding{73}": "☆",
  	"\\bigwhitestar": "☆",
  	"\\Sun": "☉",
  	"\\ding{37}": "☎",
  	"\\Square": "☐",
  	"\\CheckedBox": "☑",
  	"\\XBox": "☒",
  	"\\steaming": "☕",
  	"\\ding{42}": "☛",
  	"\\ding{43}": "☞",
  	"\\pointright": "☞",
  	"\\skull": "☠",
  	"\\danger": "☡",
  	"\\radiation": "☢",
  	"\\biohazard": "☣",
  	"\\yinyang": "☯",
  	"\\frownie": "☹",
  	"\\smiley": "☺",
  	"\\blacksmiley": "☻",
  	"\\sun": "☼",
  	"\\rightmoon": "☽",
  	"\\leftmoon": "☾",
  	"\\mercury": "☿",
  	"\\venus": "♀",
  	"\\female": "♀",
  	"\\earth": "♁",
  	"\\male": "♂",
  	"\\jupiter": "♃",
  	"\\saturn": "♄",
  	"\\uranus": "♅",
  	"\\neptune": "♆",
  	"\\pluto": "♇",
  	"\\aries": "♈",
  	"\\taurus": "♉",
  	"\\gemini": "♊",
  	"\\cancer": "♋",
  	"\\leo": "♌",
  	"\\virgo": "♍",
  	"\\libra": "♎",
  	"\\scorpio": "♏",
  	"\\sagittarius": "♐",
  	"\\capricornus": "♑",
  	"\\aquarius": "♒",
  	"\\pisces": "♓",
  	"\\ding{171}": "♠",
  	"\\spadesuit": "♠",
  	"\\heartsuit": "♡",
  	"\\ding{168}": "♣",
  	"\\clubsuit": "♣",
  	"\\varspadesuit": "♤",
  	"\\ding{170}": "♥",
  	"\\varheartsuit": "♥",
  	"\\ding{169}": "♦",
  	"\\vardiamondsuit": "♦",
  	"\\varclubsuit": "♧",
  	"\\quarternote": "♩",
  	"\\eighthnote": "♪",
  	"\\twonotes": "♫",
  	"\\sixteenthnote": "♬",
  	"\\flat": "♭",
  	"\\natural": "♮",
  	"\\sharp": "♯",
  	"\\recycle": "♻",
  	"\\acidfree": "♾",
  	"\\dicei": "⚀",
  	"\\diceii": "⚁",
  	"\\diceiii": "⚂",
  	"\\diceiv": "⚃",
  	"\\dicev": "⚄",
  	"\\dicevi": "⚅",
  	"\\circledrightdot": "⚆",
  	"\\circledtwodots": "⚇",
  	"\\blackcircledrightdot": "⚈",
  	"\\blackcircledtwodots": "⚉",
  	"\\anchor": "⚓",
  	"\\swords": "⚔",
  	"\\warning": "⚠",
  	"\\Hermaphrodite": "⚥",
  	"\\medcirc": "⚪",
  	"\\medbullet": "⚫",
  	"\\mdsmwhtcircle": "⚬",
  	"\\neuter": "⚲",
  	"\\ding{33}": "✁",
  	"\\ding{34}": "✂",
  	"\\ding{35}": "✃",
  	"\\ding{36}": "✄",
  	"\\ding{38}": "✆",
  	"\\ding{39}": "✇",
  	"\\ding{40}": "✈",
  	"\\ding{41}": "✉",
  	"\\ding{44}": "✌",
  	"\\ding{45}": "✍",
  	"\\ding{46}": "✎",
  	"\\pencil": "✎",
  	"\\ding{47}": "✏",
  	"\\ding{48}": "✐",
  	"\\ding{49}": "✑",
  	"\\ding{50}": "✒",
  	"\\ding{51}": "✓",
  	"\\checkmark": "✓",
  	"\\ding{52}": "✔",
  	"\\ding{53}": "✕",
  	"\\ding{54}": "✖",
  	"\\ding{55}": "✗",
  	"\\ballotx": "✗",
  	"\\ding{56}": "✘",
  	"\\ding{57}": "✙",
  	"\\ding{58}": "✚",
  	"\\ding{59}": "✛",
  	"\\ding{60}": "✜",
  	"\\ding{61}": "✝",
  	"\\ding{62}": "✞",
  	"\\ding{63}": "✟",
  	"\\ding{64}": "✠",
  	"\\maltese": "✠",
  	"\\ding{65}": "✡",
  	"\\ding{66}": "✢",
  	"\\ding{67}": "✣",
  	"\\ding{68}": "✤",
  	"\\ding{69}": "✥",
  	"\\ding{70}": "✦",
  	"\\ding{71}": "✧",
  	"\\ding{74}": "✪",
  	"\\circledstar": "✪",
  	"\\ding{75}": "✫",
  	"\\ding{76}": "✬",
  	"\\ding{77}": "✭",
  	"\\ding{78}": "✮",
  	"\\ding{79}": "✯",
  	"\\ding{80}": "✰",
  	"\\ding{81}": "✱",
  	"\\ding{82}": "✲",
  	"\\ding{83}": "✳",
  	"\\ding{84}": "✴",
  	"\\ding{85}": "✵",
  	"\\ding{86}": "✶",
  	"\\varstar": "✶",
  	"\\ding{87}": "✷",
  	"\\ding{88}": "✸",
  	"\\ding{89}": "✹",
  	"\\ding{90}": "✺",
  	"\\ding{91}": "✻",
  	"\\ding{92}": "✼",
  	"\\ding{93}": "✽",
  	"\\dingasterisk": "✽",
  	"\\ding{94}": "✾",
  	"\\ding{95}": "✿",
  	"\\ding{96}": "❀",
  	"\\ding{97}": "❁",
  	"\\ding{98}": "❂",
  	"\\ding{99}": "❃",
  	"\\ding{100}": "❄",
  	"\\ding{101}": "❅",
  	"\\ding{102}": "❆",
  	"\\ding{103}": "❇",
  	"\\ding{104}": "❈",
  	"\\ding{105}": "❉",
  	"\\ding{106}": "❊",
  	"\\ding{107}": "❋",
  	"\\ding{109}": "❍",
  	"\\ding{111}": "❏",
  	"\\ding{112}": "❐",
  	"\\ding{113}": "❑",
  	"\\ding{114}": "❒",
  	"\\ding{118}": "❖",
  	"\\ding{120}": "❘",
  	"\\ding{121}": "❙",
  	"\\ding{122}": "❚",
  	"\\ding{123}": "❛",
  	"\\ding{124}": "❜",
  	"\\ding{125}": "❝",
  	"\\ding{126}": "❞",
  	"\\ding{161}": "❡",
  	"\\ding{162}": "❢",
  	"\\ding{163}": "❣",
  	"\\ding{164}": "❤",
  	"\\ding{165}": "❥",
  	"\\ding{166}": "❦",
  	"\\ding{167}": "❧",
  	"\\ding{182}": "❶",
  	"\\ding{183}": "❷",
  	"\\ding{184}": "❸",
  	"\\ding{185}": "❹",
  	"\\ding{186}": "❺",
  	"\\ding{187}": "❻",
  	"\\ding{188}": "❼",
  	"\\ding{189}": "❽",
  	"\\ding{190}": "❾",
  	"\\ding{191}": "❿",
  	"\\ding{192}": "➀",
  	"\\ding{193}": "➁",
  	"\\ding{194}": "➂",
  	"\\ding{195}": "➃",
  	"\\ding{196}": "➄",
  	"\\ding{197}": "➅",
  	"\\ding{198}": "➆",
  	"\\ding{199}": "➇",
  	"\\ding{200}": "➈",
  	"\\ding{201}": "➉",
  	"\\ding{202}": "➊",
  	"\\ding{203}": "➋",
  	"\\ding{204}": "➌",
  	"\\ding{205}": "➍",
  	"\\ding{206}": "➎",
  	"\\ding{207}": "➏",
  	"\\ding{208}": "➐",
  	"\\ding{209}": "➑",
  	"\\ding{210}": "➒",
  	"\\ding{211}": "➓",
  	"\\ding{212}": "➔",
  	"\\ding{216}": "➘",
  	"\\ding{217}": "➙",
  	"\\ding{218}": "➚",
  	"\\ding{219}": "➛",
  	"\\draftingarrow": "➛",
  	"\\ding{220}": "➜",
  	"\\ding{221}": "➝",
  	"\\ding{222}": "➞",
  	"\\ding{223}": "➟",
  	"\\ding{224}": "➠",
  	"\\ding{225}": "➡",
  	"\\ding{226}": "➢",
  	"\\arrowbullet": "➢",
  	"\\ding{227}": "➣",
  	"\\ding{228}": "➤",
  	"\\ding{229}": "➥",
  	"\\ding{230}": "➦",
  	"\\ding{231}": "➧",
  	"\\ding{232}": "➨",
  	"\\ding{233}": "➩",
  	"\\ding{234}": "➪",
  	"\\ding{235}": "➫",
  	"\\ding{236}": "➬",
  	"\\ding{237}": "➭",
  	"\\ding{238}": "➮",
  	"\\ding{239}": "➯",
  	"\\ding{241}": "➱",
  	"\\ding{242}": "➲",
  	"\\ding{243}": "➳",
  	"\\ding{244}": "➴",
  	"\\ding{245}": "➵",
  	"\\ding{246}": "➶",
  	"\\ding{247}": "➷",
  	"\\ding{248}": "➸",
  	"\\ding{249}": "➹",
  	"\\ding{250}": "➺",
  	"\\ding{251}": "➻",
  	"\\ding{252}": "➼",
  	"\\ding{253}": "➽",
  	"\\ding{254}": "➾",
  	"\\threedangle": "⟀",
  	"\\whiteinwhitetriangle": "⟁",
  	"\\perp": "⟂",
  	"\\subsetcirc": "⟃",
  	"\\supsetcirc": "⟄",
  	"\\Lbag": "⟅",
  	"\\Rbag": "⟆",
  	"\\veedot": "⟇",
  	"\\bsolhsub": "⟈",
  	"\\suphsol": "⟉",
  	"\\longdivision": "⟌",
  	"\\Diamonddot": "⟐",
  	"\\wedgedot": "⟑",
  	"\\upin": "⟒",
  	"\\pullback": "⟓",
  	"\\pushout": "⟔",
  	"\\leftouterjoin": "⟕",
  	"\\rightouterjoin": "⟖",
  	"\\fullouterjoin": "⟗",
  	"\\bigbot": "⟘",
  	"\\bigtop": "⟙",
  	"\\DashVDash": "⟚",
  	"\\dashVdash": "⟛",
  	"\\multimapinv": "⟜",
  	"\\vlongdash": "⟝",
  	"\\longdashv": "⟞",
  	"\\cirbot": "⟟",
  	"\\lozengeminus": "⟠",
  	"\\concavediamond": "⟡",
  	"\\concavediamondtickleft": "⟢",
  	"\\concavediamondtickright": "⟣",
  	"\\whitesquaretickleft": "⟤",
  	"\\whitesquaretickright": "⟥",
  	"\\llbracket": "⟦",
  	"\\rrbracket": "⟧",
  	"\\langle": "⟨",
  	"\\rangle": "⟩",
  	"\\lang": "⟪",
  	"\\rang": "⟫",
  	"\\Lbrbrak": "⟬",
  	"\\Rbrbrak": "⟭",
  	"\\lgroup": "⟮",
  	"\\rgroup": "⟯",
  	"\\UUparrow": "⟰",
  	"\\DDownarrow": "⟱",
  	"\\acwgapcirclearrow": "⟲",
  	"\\cwgapcirclearrow": "⟳",
  	"\\rightarrowonoplus": "⟴",
  	"\\longleftarrow": "⟵",
  	"\\longrightarrow": "⟶",
  	"\\longleftrightarrow": "⟷",
  	"\\Longleftarrow": "⟸",
  	"\\Longrightarrow": "⟹",
  	"\\Longleftrightarrow": "⟺",
  	"\\longmapsfrom": "⟻",
  	"\\longmapsto": "⟼",
  	"\\Longmapsfrom": "⟽",
  	"\\Longmapsto": "⟾",
  	"\\sim\\joinrel\\leadsto": "⟿",
  	"\\psur": "⤀",
  	"\\nVtwoheadrightarrow": "⤁",
  	"\\nvLeftarrow": "⤂",
  	"\\nvRightarrow": "⤃",
  	"\\nvLeftrightarrow": "⤄",
  	"\\Mapsfrom": "⤆",
  	"\\Mapsto": "⤇",
  	"\\downarrowbarred": "⤈",
  	"\\uparrowbarred": "⤉",
  	"\\Uuparrow": "⤊",
  	"\\Ddownarrow": "⤋",
  	"\\leftbkarrow": "⤌",
  	"\\rightbkarrow": "⤍",
  	"\\leftdbkarrow": "⤎",
  	"\\dbkarow": "⤏",
  	"\\drbkarow": "⤐",
  	"\\rightdotarrow": "⤑",
  	"\\UpArrowBar": "⤒",
  	"\\DownArrowBar": "⤓",
  	"\\pinj": "⤔",
  	"\\finj": "⤕",
  	"\\bij": "⤖",
  	"\\nvtwoheadrightarrowtail": "⤗",
  	"\\nVtwoheadrightarrowtail": "⤘",
  	"\\lefttail": "⤙",
  	"\\righttail": "⤚",
  	"\\leftdbltail": "⤛",
  	"\\rightdbltail": "⤜",
  	"\\diamondleftarrow": "⤝",
  	"\\rightarrowdiamond": "⤞",
  	"\\diamondleftarrowbar": "⤟",
  	"\\barrightarrowdiamond": "⤠",
  	"\\nwsearrow": "⤡",
  	"\\neswarrow": "⤢",
  	"\\rdiagovfdiag": "⤫",
  	"\\fdiagovrdiag": "⤬",
  	"\\seovnearrow": "⤭",
  	"\\neovsearrow": "⤮",
  	"\\fdiagovnearrow": "⤯",
  	"\\rdiagovsearrow": "⤰",
  	"\\neovnwarrow": "⤱",
  	"\\nwovnearrow": "⤲",
  	"\\uprightcurvearrow": "⤴",
  	"\\downrightcurvedarrow": "⤵",
  	"\\cwrightarcarrow": "⤸",
  	"\\acwleftarcarrow": "⤹",
  	"\\acwoverarcarrow": "⤺",
  	"\\acwunderarcarrow": "⤻",
  	"\\curvearrowrightminus": "⤼",
  	"\\curvearrowleftplus": "⤽",
  	"\\cwundercurvearrow": "⤾",
  	"\\ccwundercurvearrow": "⤿",
  	"\\Elolarr": "⥀",
  	"\\Elorarr": "⥁",
  	"\\ElzRlarr": "⥂",
  	"\\leftarrowshortrightarrow": "⥃",
  	"\\ElzrLarr": "⥄",
  	"\\rightarrowplus": "⥅",
  	"\\leftarrowplus": "⥆",
  	"\\Elzrarrx": "⥇",
  	"\\leftrightarrowcircle": "⥈",
  	"\\twoheaduparrowcircle": "⥉",
  	"\\leftrightharpoon": "⥊",
  	"\\rightleftharpoon": "⥋",
  	"\\updownharpoonrightleft": "⥌",
  	"\\updownharpoonleftright": "⥍",
  	"\\LeftRightVector": "⥎",
  	"\\RightUpDownVector": "⥏",
  	"\\DownLeftRightVector": "⥐",
  	"\\LeftUpDownVector": "⥑",
  	"\\LeftVectorBar": "⥒",
  	"\\RightVectorBar": "⥓",
  	"\\RightUpVectorBar": "⥔",
  	"\\RightDownVectorBar": "⥕",
  	"\\DownLeftVectorBar": "⥖",
  	"\\DownRightVectorBar": "⥗",
  	"\\LeftUpVectorBar": "⥘",
  	"\\LeftDownVectorBar": "⥙",
  	"\\LeftTeeVector": "⥚",
  	"\\RightTeeVector": "⥛",
  	"\\RightUpTeeVector": "⥜",
  	"\\RightDownTeeVector": "⥝",
  	"\\DownLeftTeeVector": "⥞",
  	"\\DownRightTeeVector": "⥟",
  	"\\LeftUpTeeVector": "⥠",
  	"\\LeftDownTeeVector": "⥡",
  	"\\leftleftharpoons": "⥢",
  	"\\upupharpoons": "⥣",
  	"\\rightrightharpoons": "⥤",
  	"\\downdownharpoons": "⥥",
  	"\\leftrightharpoonsup": "⥦",
  	"\\leftrightharpoonsdown": "⥧",
  	"\\rightleftharpoonsup": "⥨",
  	"\\rightleftharpoonsdown": "⥩",
  	"\\leftbarharpoon": "⥪",
  	"\\barleftharpoon": "⥫",
  	"\\rightbarharpoon": "⥬",
  	"\\barrightharpoon": "⥭",
  	"\\UpEquilibrium": "⥮",
  	"\\ReverseUpEquilibrium": "⥯",
  	"\\RoundImplies": "⥰",
  	"\\equalrightarrow": "⥱",
  	"\\similarrightarrow": "⥲",
  	"\\leftarrowsimilar": "⥳",
  	"\\rightarrowsimilar": "⥴",
  	"\\rightarrowapprox": "⥵",
  	"\\ltlarr": "⥶",
  	"\\leftarrowless": "⥷",
  	"\\gtrarr": "⥸",
  	"\\subrarr": "⥹",
  	"\\leftarrowsubset": "⥺",
  	"\\suplarr": "⥻",
  	"\\upfishtail": "⥾",
  	"\\downfishtail": "⥿",
  	"\\Elztfnc": "⦀",
  	"\\spot": "⦁",
  	"\\typecolon": "⦂",
  	"\\lBrace": "⦃",
  	"\\rBrace": "⦄",
  	"\\Elroang": "⦆",
  	"\\limg": "⦇",
  	"\\rimg": "⦈",
  	"\\lblot": "⦉",
  	"\\rblot": "⦊",
  	"\\lbrackubar": "⦋",
  	"\\rbrackubar": "⦌",
  	"\\lbrackultick": "⦍",
  	"\\rbracklrtick": "⦎",
  	"\\lbracklltick": "⦏",
  	"\\rbrackurtick": "⦐",
  	"\\langledot": "⦑",
  	"\\rangledot": "⦒",
  	"<\\kern-0.58em(": "⦓",
  	"\\Lparengtr": "⦕",
  	"\\Rparenless": "⦖",
  	"\\lblkbrbrak": "⦗",
  	"\\rblkbrbrak": "⦘",
  	"\\Elzddfnc": "⦙",
  	"\\vzigzag": "⦚",
  	"\\measuredangleleft": "⦛",
  	"\\Angle": "⦜",
  	"\\rightanglemdot": "⦝",
  	"\\angles": "⦞",
  	"\\angdnr": "⦟",
  	"\\Elzlpargt": "⦠",
  	"\\sphericalangleup": "⦡",
  	"\\turnangle": "⦢",
  	"\\revangle": "⦣",
  	"\\angleubar": "⦤",
  	"\\revangleubar": "⦥",
  	"\\wideangledown": "⦦",
  	"\\wideangleup": "⦧",
  	"\\measanglerutone": "⦨",
  	"\\measanglelutonw": "⦩",
  	"\\measanglerdtose": "⦪",
  	"\\measangleldtosw": "⦫",
  	"\\measangleurtone": "⦬",
  	"\\measangleultonw": "⦭",
  	"\\measangledrtose": "⦮",
  	"\\measangledltosw": "⦯",
  	"\\revemptyset": "⦰",
  	"\\emptysetobar": "⦱",
  	"\\emptysetocirc": "⦲",
  	"\\emptysetoarr": "⦳",
  	"\\emptysetoarrl": "⦴",
  	"\\circledparallel": "⦷",
  	"\\circledbslash": "⦸",
  	"\\operp": "⦹",
  	"\\obot": "⦺",
  	"\\olcross": "⦻",
  	"\\odotslashdot": "⦼",
  	"\\uparrowoncircle": "⦽",
  	"\\circledwhitebullet": "⦾",
  	"\\circledbullet": "⦿",
  	"\\circledless": "⧀",
  	"\\circledgtr": "⧁",
  	"\\cirscir": "⧂",
  	"\\cirE": "⧃",
  	"\\boxslash": "⧄",
  	"\\boxbslash": "⧅",
  	"\\boxast": "⧆",
  	"\\boxcircle": "⧇",
  	"\\boxbox": "⧈",
  	"\\boxonbox": "⧉",
  	"\\ElzLap": "⧊",
  	"\\Elzdefas": "⧋",
  	"\\triangles": "⧌",
  	"\\triangleserifs": "⧍",
  	"\\rtriltri": "⧎",
  	"\\LeftTriangleBar": "⧏",
  	"\\NotLeftTriangleBar": "⧏̸",
  	"\\RightTriangleBar": "⧐",
  	"\\NotRightTriangleBar": "⧐̸",
  	"\\lfbowtie": "⧑",
  	"\\rfbowtie": "⧒",
  	"\\fbowtie": "⧓",
  	"\\lftimes": "⧔",
  	"\\rftimes": "⧕",
  	"\\hourglass": "⧖",
  	"\\blackhourglass": "⧗",
  	"\\lvzigzag": "⧘",
  	"\\rvzigzag": "⧙",
  	"\\Lvzigzag": "⧚",
  	"\\Rvzigzag": "⧛",
  	"\\tieinfty": "⧝",
  	"\\nvinfty": "⧞",
  	"\\multimapboth": "⧟",
  	"\\laplac": "⧠",
  	"\\lrtriangleeq": "⧡",
  	"\\shuffle": "⧢",
  	"\\eparsl": "⧣",
  	"\\smeparsl": "⧤",
  	"\\eqvparsl": "⧥",
  	"\\gleichstark": "⧦",
  	"\\thermod": "⧧",
  	"\\downtriangleleftblack": "⧨",
  	"\\downtrianglerightblack": "⧩",
  	"\\blackdiamonddownarrow": "⧪",
  	"\\blacklozenge": "⧫",
  	"\\circledownarrow": "⧬",
  	"\\blackcircledownarrow": "⧭",
  	"\\errbarsquare": "⧮",
  	"\\errbarblacksquare": "⧯",
  	"\\errbardiamond": "⧰",
  	"\\errbarblackdiamond": "⧱",
  	"\\errbarcircle": "⧲",
  	"\\errbarblackcircle": "⧳",
  	"\\RuleDelayed": "⧴",
  	"\\dsol": "⧶",
  	"\\rsolbar": "⧷",
  	"\\xsol": "⧸",
  	"\\zhide": "⧹",
  	"\\doubleplus": "⧺",
  	"\\tripleplus": "⧻",
  	"\\lcurvyangle": "⧼",
  	"\\rcurvyangle": "⧽",
  	"\\tplus": "⧾",
  	"\\tminus": "⧿",
  	"\\bigodot": "⨀",
  	"\\bigoplus": "⨁",
  	"\\bigotimes": "⨂",
  	"\\bigcupdot": "⨃",
  	"\\Elxuplus": "⨄",
  	"\\ElzThr": "⨅",
  	"\\Elxsqcup": "⨆",
  	"\\ElzInf": "⨇",
  	"\\ElzSup": "⨈",
  	"\\varprod": "⨉",
  	"\\modtwosum": "⨊",
  	"\\sumint": "⨋",
  	"\\iiiint": "⨌",
  	"\\ElzCint": "⨍",
  	"\\intBar": "⨎",
  	"\\clockoint": "⨏",
  	"\\awint": "⨑",
  	"\\rppolint": "⨒",
  	"\\scpolint": "⨓",
  	"\\npolint": "⨔",
  	"\\pointint": "⨕",
  	"\\sqrint": "⨖",
  	"\\intlarhk": "⨗",
  	"\\intx": "⨘",
  	"\\intcap": "⨙",
  	"\\intcup": "⨚",
  	"\\upint": "⨛",
  	"\\lowint": "⨜",
  	"\\Join": "⨝",
  	"\\bigtriangleleft": "⨞",
  	"\\zcmp": "⨟",
  	"\\zpipe": "⨠",
  	"\\zproject": "⨡",
  	"\\ringplus": "⨢",
  	"\\plushat": "⨣",
  	"\\simplus": "⨤",
  	"\\plussim": "⨦",
  	"\\plussubtwo": "⨧",
  	"\\plustrif": "⨨",
  	"\\commaminus": "⨩",
  	"\\minusfdots": "⨫",
  	"\\minusrdots": "⨬",
  	"\\ElzTimes": "⨯",
  	"\\dottimes": "⨰",
  	"\\timesbar": "⨱",
  	"\\btimes": "⨲",
  	"\\smashtimes": "⨳",
  	"\\otimeshat": "⨶",
  	"\\Otimes": "⨷",
  	"\\odiv": "⨸",
  	"\\triangleplus": "⨹",
  	"\\triangleminus": "⨺",
  	"\\triangletimes": "⨻",
  	"\\intprodr": "⨽",
  	"\\fcmp": "⨾",
  	"\\amalg": "⨿",
  	"\\capdot": "⩀",
  	"\\uminus": "⩁",
  	"\\barcup": "⩂",
  	"\\barcap": "⩃",
  	"\\capwedge": "⩄",
  	"\\cupvee": "⩅",
  	"\\cupovercap": "⩆",
  	"\\capovercup": "⩇",
  	"\\cupbarcap": "⩈",
  	"\\capbarcup": "⩉",
  	"\\twocups": "⩊",
  	"\\twocaps": "⩋",
  	"\\closedvarcup": "⩌",
  	"\\closedvarcap": "⩍",
  	"\\Sqcap": "⩎",
  	"\\Sqcup": "⩏",
  	"\\closedvarcupsmashprod": "⩐",
  	"\\wedgeodot": "⩑",
  	"\\veeodot": "⩒",
  	"\\ElzAnd": "⩓",
  	"\\ElzOr": "⩔",
  	"\\ElOr": "⩖",
  	"\\bigslopedvee": "⩗",
  	"\\bigslopedwedge": "⩘",
  	"\\veeonwedge": "⩙",
  	"\\wedgemidvert": "⩚",
  	"\\veemidvert": "⩛",
  	"\\midbarwedge": "⩜",
  	"\\midbarvee": "⩝",
  	"\\Elzminhat": "⩟",
  	"\\wedgedoublebar": "⩠",
  	"\\varveebar": "⩡",
  	"\\doublebarvee": "⩢",
  	"\\dsub": "⩤",
  	"\\rsub": "⩥",
  	"\\eqdot": "⩦",
  	"\\dotequiv": "⩧",
  	"\\equivVert": "⩨",
  	"\\equivVvert": "⩩",
  	"\\dotsim": "⩪",
  	"\\simrdots": "⩫",
  	"\\simminussim": "⩬",
  	"\\congdot": "⩭",
  	"\\stackrel{*}{=}": "⩮",
  	"\\hatapprox": "⩯",
  	"\\approxeqq": "⩰",
  	"\\eqqplus": "⩱",
  	"\\pluseqq": "⩲",
  	"\\eqqsim": "⩳",
  	"\\Coloneqq": "⩴",
  	"\\Equal": "⩵",
  	"\\Same": "⩶",
  	"\\ddotseq": "⩷",
  	"\\equivDD": "⩸",
  	"\\ltcir": "⩹",
  	"\\gtcir": "⩺",
  	"\\ltquest": "⩻",
  	"\\gtquest": "⩼",
  	"\\leqslant": "⩽",
  	"\\nleqslant": "⩽̸",
  	"\\geqslant": "⩾",
  	"\\ngeqslant": "⩾̸",
  	"\\lesdot": "⩿",
  	"\\gesdot": "⪀",
  	"\\lesdoto": "⪁",
  	"\\gesdoto": "⪂",
  	"\\lesdotor": "⪃",
  	"\\gesdotol": "⪄",
  	"\\lessapprox": "⪅",
  	"\\gtrapprox": "⪆",
  	"\\lneq": "⪇",
  	"\\gneq": "⪈",
  	"\\lnapprox": "⪉",
  	"\\gnapprox": "⪊",
  	"\\lesseqqgtr": "⪋",
  	"\\gtreqqless": "⪌",
  	"\\lsime": "⪍",
  	"\\gsime": "⪎",
  	"\\lsimg": "⪏",
  	"\\gsiml": "⪐",
  	"\\lgE": "⪑",
  	"\\glE": "⪒",
  	"\\lesges": "⪓",
  	"\\gesles": "⪔",
  	"\\eqslantless": "⪕",
  	"\\eqslantgtr": "⪖",
  	"\\elsdot": "⪗",
  	"\\egsdot": "⪘",
  	"\\eqqless": "⪙",
  	"\\eqqgtr": "⪚",
  	"\\eqqslantless": "⪛",
  	"\\eqqslantgtr": "⪜",
  	"\\Pisymbol{ppi020}{117}": "⪝",
  	"\\Pisymbol{ppi020}{105}": "⪞",
  	"\\simlE": "⪟",
  	"\\simgE": "⪠",
  	"\\NestedLessLess": "⪡",
  	"\\NotNestedLessLess": "⪡̸",
  	"\\NestedGreaterGreater": "⪢",
  	"\\NotNestedGreaterGreater": "⪢̸",
  	"\\partialmeetcontraction": "⪣",
  	"\\glj": "⪤",
  	"\\gla": "⪥",
  	"\\leftslice": "⪦",
  	"\\rightslice": "⪧",
  	"\\lescc": "⪨",
  	"\\gescc": "⪩",
  	"\\smt": "⪪",
  	"\\lat": "⪫",
  	"\\smte": "⪬",
  	"\\late": "⪭",
  	"\\bumpeqq": "⪮",
  	"\\preceq": "⪯",
  	"\\not\\preceq": "⪯̸",
  	"\\succeq": "⪰",
  	"\\not\\succeq": "⪰̸",
  	"\\precneq": "⪱",
  	"\\succneq": "⪲",
  	"\\preceqq": "⪳",
  	"\\succeqq": "⪴",
  	"\\precneqq": "⪵",
  	"\\succneqq": "⪶",
  	"\\precapprox": "⪷",
  	"\\succapprox": "⪸",
  	"\\precnapprox": "⪹",
  	"\\succnapprox": "⪺",
  	"\\llcurly": "⪻",
  	"\\ggcurly": "⪼",
  	"\\subsetdot": "⪽",
  	"\\supsetdot": "⪾",
  	"\\subsetplus": "⪿",
  	"\\supsetplus": "⫀",
  	"\\submult": "⫁",
  	"\\supmult": "⫂",
  	"\\subedot": "⫃",
  	"\\supedot": "⫄",
  	"\\subseteqq": "⫅",
  	"\\nsubseteqq": "⫅̸",
  	"\\supseteqq": "⫆",
  	"\\nsupseteqq": "⫆̸",
  	"\\subsim": "⫇",
  	"\\supsim": "⫈",
  	"\\subsetapprox": "⫉",
  	"\\supsetapprox": "⫊",
  	"\\subsetneqq": "⫋",
  	"\\supsetneqq": "⫌",
  	"\\lsqhook": "⫍",
  	"\\rsqhook": "⫎",
  	"\\csub": "⫏",
  	"\\csup": "⫐",
  	"\\csube": "⫑",
  	"\\csupe": "⫒",
  	"\\subsup": "⫓",
  	"\\supsub": "⫔",
  	"\\subsub": "⫕",
  	"\\supsup": "⫖",
  	"\\suphsub": "⫗",
  	"\\supdsub": "⫘",
  	"\\forkv": "⫙",
  	"\\topfork": "⫚",
  	"\\mlcp": "⫛",
  	"\\forks": "⫝̸",
  	"\\forksnot": "⫝",
  	"\\shortlefttack": "⫞",
  	"\\shortdowntack": "⫟",
  	"\\shortuptack": "⫠",
  	"\\perps": "⫡",
  	"\\vDdash": "⫢",
  	"\\dashV": "⫣",
  	"\\Dashv": "⫤",
  	"\\DashV": "⫥",
  	"\\varVdash": "⫦",
  	"\\Barv": "⫧",
  	"\\vBar": "⫨",
  	"\\vBarv": "⫩",
  	"\\Top": "⫪",
  	"\\Not": "⫬",
  	"\\bNot": "⫭",
  	"\\revnmid": "⫮",
  	"\\cirmid": "⫯",
  	"\\midcir": "⫰",
  	"\\topcir": "⫱",
  	"\\nhpar": "⫲",
  	"\\parsim": "⫳",
  	"\\interleave": "⫴",
  	"\\nhVvert": "⫵",
  	"\\Elztdcol": "⫶",
  	"\\lllnest": "⫷",
  	"\\gggnest": "⫸",
  	"\\leqqslant": "⫹",
  	"\\geqqslant": "⫺",
  	"\\trslash": "⫻",
  	"\\biginterleave": "⫼",
  	"{{/}\\!\\!{/}}": "⫽",
  	"{\\rlap{\\textbackslash}{{/}\\!\\!{/}}}": "⫽⃥",
  	"\\talloblong": "⫾",
  	"\\bigtalloblong": "⫿",
  	"\\squaretopblack": "⬒",
  	"\\squarebotblack": "⬓",
  	"\\squareurblack": "⬔",
  	"\\squarellblack": "⬕",
  	"\\diamondleftblack": "⬖",
  	"\\diamondrightblack": "⬗",
  	"\\diamondtopblack": "⬘",
  	"\\diamondbotblack": "⬙",
  	"\\dottedsquare": "⬚",
  	"\\blacksquare": "⬛",
  	"\\vysmblksquare": "⬝",
  	"\\vysmwhtsquare": "⬞",
  	"\\pentagonblack": "⬟",
  	"\\pentagon": "⬠",
  	"\\varhexagon": "⬡",
  	"\\varhexagonblack": "⬢",
  	"\\hexagonblack": "⬣",
  	"\\lgblkcircle": "⬤",
  	"\\mdblkdiamond": "⬥",
  	"\\mdwhtdiamond": "⬦",
  	"\\mdblklozenge": "⬧",
  	"\\mdwhtlozenge": "⬨",
  	"\\smblkdiamond": "⬩",
  	"\\smblklozenge": "⬪",
  	"\\smwhtlozenge": "⬫",
  	"\\blkhorzoval": "⬬",
  	"\\whthorzoval": "⬭",
  	"\\blkvertoval": "⬮",
  	"\\whtvertoval": "⬯",
  	"\\circleonleftarrow": "⬰",
  	"\\leftthreearrows": "⬱",
  	"\\leftarrowonoplus": "⬲",
  	"\\longleftsquigarrow": "⬳",
  	"\\nvtwoheadleftarrow": "⬴",
  	"\\nVtwoheadleftarrow": "⬵",
  	"\\twoheadmapsfrom": "⬶",
  	"\\twoheadleftdbkarrow": "⬷",
  	"\\leftdotarrow": "⬸",
  	"\\nvleftarrowtail": "⬹",
  	"\\nVleftarrowtail": "⬺",
  	"\\twoheadleftarrowtail": "⬻",
  	"\\nvtwoheadleftarrowtail": "⬼",
  	"\\nVtwoheadleftarrowtail": "⬽",
  	"\\leftarrowx": "⬾",
  	"\\leftcurvedarrow": "⬿",
  	"\\equalleftarrow": "⭀",
  	"\\bsimilarleftarrow": "⭁",
  	"\\leftarrowbackapprox": "⭂",
  	"\\rightarrowgtr": "⭃",
  	"\\rightarrowsupset": "⭄",
  	"\\LLeftarrow": "⭅",
  	"\\RRightarrow": "⭆",
  	"\\bsimilarrightarrow": "⭇",
  	"\\rightarrowbackapprox": "⭈",
  	"\\similarleftarrow": "⭉",
  	"\\leftarrowapprox": "⭊",
  	"\\leftarrowbsimilar": "⭋",
  	"\\rightarrowbsimilar": "⭌",
  	"\\medwhitestar": "⭐",
  	"\\medblackstar": "⭑",
  	"\\smwhitestar": "⭒",
  	"\\rightpentagonblack": "⭓",
  	"\\rightpentagon": "⭔",
  	"\\postalmark": "〒",
  	"\\lbrbrak": "〔",
  	"\\rbrbrak": "〕",
  	"\\openbracketleft": "〚",
  	"\\openbracketright": "〛",
  	"\\hzigzag": "〰",
  	"\\dbend": "�",
  	"\\mathbf{A}": "𝐀",
  	"\\mathbf{B}": "𝐁",
  	"\\mathbf{C}": "𝐂",
  	"\\mathbf{D}": "𝐃",
  	"\\mathbf{E}": "𝐄",
  	"\\mathbf{F}": "𝐅",
  	"\\mathbf{G}": "𝐆",
  	"\\mathbf{H}": "𝐇",
  	"\\mathbf{I}": "𝐈",
  	"\\mathbf{J}": "𝐉",
  	"\\mathbf{K}": "𝐊",
  	"\\mathbf{L}": "𝐋",
  	"\\mathbf{M}": "𝐌",
  	"\\mathbf{N}": "𝐍",
  	"\\mathbf{O}": "𝐎",
  	"\\mathbf{P}": "𝐏",
  	"\\mathbf{Q}": "𝐐",
  	"\\mathbf{R}": "𝐑",
  	"\\mathbf{S}": "𝐒",
  	"\\mathbf{T}": "𝐓",
  	"\\mathbf{U}": "𝐔",
  	"\\mathbf{V}": "𝐕",
  	"\\mathbf{W}": "𝐖",
  	"\\mathbf{X}": "𝐗",
  	"\\mathbf{Y}": "𝐘",
  	"\\mathbf{Z}": "𝐙",
  	"\\mathbf{a}": "𝐚",
  	"\\mathbf{b}": "𝐛",
  	"\\mathbf{c}": "𝐜",
  	"\\mathbf{d}": "𝐝",
  	"\\mathbf{e}": "𝐞",
  	"\\mathbf{f}": "𝐟",
  	"\\mathbf{g}": "𝐠",
  	"\\mathbf{h}": "𝐡",
  	"\\mathbf{i}": "𝐢",
  	"\\mathbf{j}": "𝐣",
  	"\\mathbf{k}": "𝐤",
  	"\\mathbf{l}": "𝐥",
  	"\\mathbf{m}": "𝐦",
  	"\\mathbf{n}": "𝐧",
  	"\\mathbf{o}": "𝐨",
  	"\\mathbf{p}": "𝐩",
  	"\\mathbf{q}": "𝐪",
  	"\\mathbf{r}": "𝐫",
  	"\\mathbf{s}": "𝐬",
  	"\\mathbf{t}": "𝐭",
  	"\\mathbf{u}": "𝐮",
  	"\\mathbf{v}": "𝐯",
  	"\\mathbf{w}": "𝐰",
  	"\\mathbf{x}": "𝐱",
  	"\\mathbf{y}": "𝐲",
  	"\\mathbf{z}": "𝐳",
  	"\\mathsl{A}": "𝐴",
  	"\\mathsl{B}": "𝐵",
  	"\\mathsl{C}": "𝐶",
  	"\\mathsl{D}": "𝐷",
  	"\\mathsl{E}": "𝐸",
  	"\\mathsl{F}": "𝐹",
  	"\\mathsl{G}": "𝐺",
  	"\\mathsl{H}": "𝐻",
  	"\\mathsl{I}": "𝐼",
  	"\\mathsl{J}": "𝐽",
  	"\\mathsl{K}": "𝐾",
  	"\\mathsl{L}": "𝐿",
  	"\\mathsl{M}": "𝑀",
  	"\\mathsl{N}": "𝑁",
  	"\\mathsl{O}": "𝑂",
  	"\\mathsl{P}": "𝑃",
  	"\\mathsl{Q}": "𝑄",
  	"\\mathsl{R}": "𝑅",
  	"\\mathsl{S}": "𝑆",
  	"\\mathsl{T}": "𝑇",
  	"\\mathsl{U}": "𝑈",
  	"\\mathsl{V}": "𝑉",
  	"\\mathsl{W}": "𝑊",
  	"\\mathsl{X}": "𝑋",
  	"\\mathsl{Y}": "𝑌",
  	"\\mathsl{Z}": "𝑍",
  	"\\mathsl{a}": "𝑎",
  	"\\mathsl{b}": "𝑏",
  	"\\mathsl{c}": "𝑐",
  	"\\mathsl{d}": "𝑑",
  	"\\mathsl{e}": "𝑒",
  	"\\mathsl{f}": "𝑓",
  	"\\mathsl{g}": "𝑔",
  	"\\mathsl{i}": "𝑖",
  	"\\mathsl{j}": "𝑗",
  	"\\mathsl{k}": "𝑘",
  	"\\mathsl{l}": "𝑙",
  	"\\mathsl{m}": "𝑚",
  	"\\mathsl{n}": "𝑛",
  	"\\mathsl{o}": "𝑜",
  	"\\mathsl{p}": "𝑝",
  	"\\mathsl{q}": "𝑞",
  	"\\mathsl{r}": "𝑟",
  	"\\mathsl{s}": "𝑠",
  	"\\mathsl{t}": "𝑡",
  	"\\mathsl{u}": "𝑢",
  	"\\mathsl{v}": "𝑣",
  	"\\mathsl{w}": "𝑤",
  	"\\mathsl{x}": "𝑥",
  	"\\mathsl{y}": "𝑦",
  	"\\mathsl{z}": "𝑧",
  	"\\mathbit{A}": "𝑨",
  	"\\mathbit{B}": "𝑩",
  	"\\mathbit{C}": "𝑪",
  	"\\mathbit{D}": "𝑫",
  	"\\mathbit{E}": "𝑬",
  	"\\mathbit{F}": "𝑭",
  	"\\mathbit{G}": "𝑮",
  	"\\mathbit{H}": "𝑯",
  	"\\mathbit{I}": "𝑰",
  	"\\mathbit{J}": "𝑱",
  	"\\mathbit{K}": "𝑲",
  	"\\mathbit{L}": "𝑳",
  	"\\mathbit{M}": "𝑴",
  	"\\mathbit{N}": "𝑵",
  	"\\mathbit{O}": "𝑶",
  	"\\mathbit{P}": "𝑷",
  	"\\mathbit{Q}": "𝑸",
  	"\\mathbit{R}": "𝑹",
  	"\\mathbit{S}": "𝑺",
  	"\\mathbit{T}": "𝑻",
  	"\\mathbit{U}": "𝑼",
  	"\\mathbit{V}": "𝑽",
  	"\\mathbit{W}": "𝑾",
  	"\\mathbit{X}": "𝑿",
  	"\\mathbit{Y}": "𝒀",
  	"\\mathbit{Z}": "𝒁",
  	"\\mathbit{a}": "𝒂",
  	"\\mathbit{b}": "𝒃",
  	"\\mathbit{c}": "𝒄",
  	"\\mathbit{d}": "𝒅",
  	"\\mathbit{e}": "𝒆",
  	"\\mathbit{f}": "𝒇",
  	"\\mathbit{g}": "𝒈",
  	"\\mathbit{h}": "𝒉",
  	"\\mathbit{i}": "𝒊",
  	"\\mathbit{j}": "𝒋",
  	"\\mathbit{k}": "𝒌",
  	"\\mathbit{l}": "𝒍",
  	"\\mathbit{m}": "𝒎",
  	"\\mathbit{n}": "𝒏",
  	"\\mathbit{o}": "𝒐",
  	"\\mathbit{p}": "𝒑",
  	"\\mathbit{q}": "𝒒",
  	"\\mathbit{r}": "𝒓",
  	"\\mathbit{s}": "𝒔",
  	"\\mathbit{t}": "𝒕",
  	"\\mathbit{u}": "𝒖",
  	"\\mathbit{v}": "𝒗",
  	"\\mathbit{w}": "𝒘",
  	"\\mathbit{x}": "𝒙",
  	"\\mathbit{y}": "𝒚",
  	"\\mathbit{z}": "𝒛",
  	"\\mathscr{A}": "𝒜",
  	"\\mathscr{C}": "𝒞",
  	"\\mathscr{D}": "𝒟",
  	"\\mathscr{G}": "𝒢",
  	"\\mathscr{J}": "𝒥",
  	"\\mathscr{K}": "𝒦",
  	"\\mathscr{N}": "𝒩",
  	"\\mathscr{O}": "𝒪",
  	"\\mathscr{P}": "𝒫",
  	"\\mathscr{Q}": "𝒬",
  	"\\mathscr{S}": "𝒮",
  	"\\mathscr{T}": "𝒯",
  	"\\mathscr{U}": "𝒰",
  	"\\mathscr{V}": "𝒱",
  	"\\mathscr{W}": "𝒲",
  	"\\mathscr{X}": "𝒳",
  	"\\mathscr{Y}": "𝒴",
  	"\\mathscr{Z}": "𝒵",
  	"\\mathscr{a}": "𝒶",
  	"\\mathscr{b}": "𝒷",
  	"\\mathscr{c}": "𝒸",
  	"\\mathscr{d}": "𝒹",
  	"\\mathscr{f}": "𝒻",
  	"\\mathscr{h}": "𝒽",
  	"\\mathscr{i}": "𝒾",
  	"\\mathscr{j}": "𝒿",
  	"\\mathscr{k}": "𝓀",
  	"\\mathscr{m}": "𝓂",
  	"\\mathscr{n}": "𝓃",
  	"\\mathscr{p}": "𝓅",
  	"\\mathscr{q}": "𝓆",
  	"\\mathscr{r}": "𝓇",
  	"\\mathscr{s}": "𝓈",
  	"\\mathscr{t}": "𝓉",
  	"\\mathscr{u}": "𝓊",
  	"\\mathscr{v}": "𝓋",
  	"\\mathscr{w}": "𝓌",
  	"\\mathscr{x}": "𝓍",
  	"\\mathscr{y}": "𝓎",
  	"\\mathscr{z}": "𝓏",
  	"\\mathmit{A}": "𝓐",
  	"\\mathmit{B}": "𝓑",
  	"\\mathmit{C}": "𝓒",
  	"\\mathmit{D}": "𝓓",
  	"\\mathmit{E}": "𝓔",
  	"\\mathmit{F}": "𝓕",
  	"\\mathmit{G}": "𝓖",
  	"\\mathmit{H}": "𝓗",
  	"\\mathmit{I}": "𝓘",
  	"\\mathmit{J}": "𝓙",
  	"\\mathmit{K}": "𝓚",
  	"\\mathmit{L}": "𝓛",
  	"\\mathmit{M}": "𝓜",
  	"\\mathmit{N}": "𝓝",
  	"\\mathmit{O}": "𝓞",
  	"\\mathmit{P}": "𝓟",
  	"\\mathmit{Q}": "𝓠",
  	"\\mathmit{R}": "𝓡",
  	"\\mathmit{S}": "𝓢",
  	"\\mathmit{T}": "𝓣",
  	"\\mathmit{U}": "𝓤",
  	"\\mathmit{V}": "𝓥",
  	"\\mathmit{W}": "𝓦",
  	"\\mathmit{X}": "𝓧",
  	"\\mathmit{Y}": "𝓨",
  	"\\mathmit{Z}": "𝓩",
  	"\\mathmit{a}": "𝓪",
  	"\\mathmit{b}": "𝓫",
  	"\\mathmit{c}": "𝓬",
  	"\\mathmit{d}": "𝓭",
  	"\\mathmit{e}": "𝓮",
  	"\\mathmit{f}": "𝓯",
  	"\\mathmit{g}": "𝓰",
  	"\\mathmit{h}": "𝓱",
  	"\\mathmit{i}": "𝓲",
  	"\\mathmit{j}": "𝓳",
  	"\\mathmit{k}": "𝓴",
  	"\\mathmit{l}": "𝓵",
  	"\\mathmit{m}": "𝓶",
  	"\\mathmit{n}": "𝓷",
  	"\\mathmit{o}": "𝓸",
  	"\\mathmit{p}": "𝓹",
  	"\\mathmit{q}": "𝓺",
  	"\\mathmit{r}": "𝓻",
  	"\\mathmit{s}": "𝓼",
  	"\\mathmit{t}": "𝓽",
  	"\\mathmit{u}": "𝓾",
  	"\\mathmit{v}": "𝓿",
  	"\\mathmit{w}": "𝔀",
  	"\\mathmit{x}": "𝔁",
  	"\\mathmit{y}": "𝔂",
  	"\\mathmit{z}": "𝔃",
  	"\\mathfrak{A}": "𝔄",
  	"\\mathfrak{B}": "𝔅",
  	"\\mathfrak{D}": "𝔇",
  	"\\mathfrak{E}": "𝔈",
  	"\\mathfrak{F}": "𝔉",
  	"\\mathfrak{G}": "𝔊",
  	"\\mathfrak{J}": "𝔍",
  	"\\mathfrak{K}": "𝔎",
  	"\\mathfrak{L}": "𝔏",
  	"\\mathfrak{M}": "𝔐",
  	"\\mathfrak{N}": "𝔑",
  	"\\mathfrak{O}": "𝔒",
  	"\\mathfrak{P}": "𝔓",
  	"\\mathfrak{Q}": "𝔔",
  	"\\mathfrak{S}": "𝔖",
  	"\\mathfrak{T}": "𝔗",
  	"\\mathfrak{U}": "𝔘",
  	"\\mathfrak{V}": "𝔙",
  	"\\mathfrak{W}": "𝔚",
  	"\\mathfrak{X}": "𝔛",
  	"\\mathfrak{Y}": "𝔜",
  	"\\mathfrak{a}": "𝔞",
  	"\\mathfrak{b}": "𝔟",
  	"\\mathfrak{c}": "𝔠",
  	"\\mathfrak{d}": "𝔡",
  	"\\mathfrak{e}": "𝔢",
  	"\\mathfrak{f}": "𝔣",
  	"\\mathfrak{g}": "𝔤",
  	"\\mathfrak{h}": "𝔥",
  	"\\mathfrak{i}": "𝔦",
  	"\\mathfrak{j}": "𝔧",
  	"\\mathfrak{k}": "𝔨",
  	"\\mathfrak{l}": "𝔩",
  	"\\mathfrak{m}": "𝔪",
  	"\\mathfrak{n}": "𝔫",
  	"\\mathfrak{o}": "𝔬",
  	"\\mathfrak{p}": "𝔭",
  	"\\mathfrak{q}": "𝔮",
  	"\\mathfrak{r}": "𝔯",
  	"\\mathfrak{s}": "𝔰",
  	"\\mathfrak{t}": "𝔱",
  	"\\mathfrak{u}": "𝔲",
  	"\\mathfrak{v}": "𝔳",
  	"\\mathfrak{w}": "𝔴",
  	"\\mathfrak{x}": "𝔵",
  	"\\mathfrak{y}": "𝔶",
  	"\\mathfrak{z}": "𝔷",
  	"\\mathbb{A}": "𝔸",
  	"\\mathbb{B}": "𝔹",
  	"\\mathbb{D}": "𝔻",
  	"\\mathbb{E}": "𝔼",
  	"\\mathbb{F}": "𝔽",
  	"\\mathbb{G}": "𝔾",
  	"\\mathbb{I}": "𝕀",
  	"\\mathbb{J}": "𝕁",
  	"\\mathbb{K}": "𝕂",
  	"\\mathbb{L}": "𝕃",
  	"\\mathbb{M}": "𝕄",
  	"\\mathbb{O}": "𝕆",
  	"\\mathbb{S}": "𝕊",
  	"\\mathbb{T}": "𝕋",
  	"\\mathbb{U}": "𝕌",
  	"\\mathbb{V}": "𝕍",
  	"\\mathbb{W}": "𝕎",
  	"\\mathbb{X}": "𝕏",
  	"\\mathbb{Y}": "𝕐",
  	"\\mathbb{a}": "𝕒",
  	"\\mathbb{b}": "𝕓",
  	"\\mathbb{c}": "𝕔",
  	"\\mathbb{d}": "𝕕",
  	"\\mathbb{e}": "𝕖",
  	"\\mathbb{f}": "𝕗",
  	"\\mathbb{g}": "𝕘",
  	"\\mathbb{h}": "𝕙",
  	"\\mathbb{i}": "𝕚",
  	"\\mathbb{j}": "𝕛",
  	"\\mathbb{k}": "𝕜",
  	"\\mathbb{l}": "𝕝",
  	"\\mathbb{m}": "𝕞",
  	"\\mathbb{n}": "𝕟",
  	"\\mathbb{o}": "𝕠",
  	"\\mathbb{p}": "𝕡",
  	"\\mathbb{q}": "𝕢",
  	"\\mathbb{r}": "𝕣",
  	"\\mathbb{s}": "𝕤",
  	"\\mathbb{t}": "𝕥",
  	"\\mathbb{u}": "𝕦",
  	"\\mathbb{v}": "𝕧",
  	"\\mathbb{w}": "𝕨",
  	"\\mathbb{x}": "𝕩",
  	"\\mathbb{y}": "𝕪",
  	"\\mathbb{z}": "𝕫",
  	"\\mathslbb{A}": "𝕬",
  	"\\mathslbb{B}": "𝕭",
  	"\\mathslbb{C}": "𝕮",
  	"\\mathslbb{D}": "𝕯",
  	"\\mathslbb{E}": "𝕰",
  	"\\mathslbb{F}": "𝕱",
  	"\\mathslbb{G}": "𝕲",
  	"\\mathslbb{H}": "𝕳",
  	"\\mathslbb{I}": "𝕴",
  	"\\mathslbb{J}": "𝕵",
  	"\\mathslbb{K}": "𝕶",
  	"\\mathslbb{L}": "𝕷",
  	"\\mathslbb{M}": "𝕸",
  	"\\mathslbb{N}": "𝕹",
  	"\\mathslbb{O}": "𝕺",
  	"\\mathslbb{P}": "𝕻",
  	"\\mathslbb{Q}": "𝕼",
  	"\\mathslbb{R}": "𝕽",
  	"\\mathslbb{S}": "𝕾",
  	"\\mathslbb{T}": "𝕿",
  	"\\mathslbb{U}": "𝖀",
  	"\\mathslbb{V}": "𝖁",
  	"\\mathslbb{W}": "𝖂",
  	"\\mathslbb{X}": "𝖃",
  	"\\mathslbb{Y}": "𝖄",
  	"\\mathslbb{Z}": "𝖅",
  	"\\mathslbb{a}": "𝖆",
  	"\\mathslbb{b}": "𝖇",
  	"\\mathslbb{c}": "𝖈",
  	"\\mathslbb{d}": "𝖉",
  	"\\mathslbb{e}": "𝖊",
  	"\\mathslbb{f}": "𝖋",
  	"\\mathslbb{g}": "𝖌",
  	"\\mathslbb{h}": "𝖍",
  	"\\mathslbb{i}": "𝖎",
  	"\\mathslbb{j}": "𝖏",
  	"\\mathslbb{k}": "𝖐",
  	"\\mathslbb{l}": "𝖑",
  	"\\mathslbb{m}": "𝖒",
  	"\\mathslbb{n}": "𝖓",
  	"\\mathslbb{o}": "𝖔",
  	"\\mathslbb{p}": "𝖕",
  	"\\mathslbb{q}": "𝖖",
  	"\\mathslbb{r}": "𝖗",
  	"\\mathslbb{s}": "𝖘",
  	"\\mathslbb{t}": "𝖙",
  	"\\mathslbb{u}": "𝖚",
  	"\\mathslbb{v}": "𝖛",
  	"\\mathslbb{w}": "𝖜",
  	"\\mathslbb{x}": "𝖝",
  	"\\mathslbb{y}": "𝖞",
  	"\\mathslbb{z}": "𝖟",
  	"\\mathsf{A}": "𝖠",
  	"\\mathsf{B}": "𝖡",
  	"\\mathsf{C}": "𝖢",
  	"\\mathsf{D}": "𝖣",
  	"\\mathsf{E}": "𝖤",
  	"\\mathsf{F}": "𝖥",
  	"\\mathsf{G}": "𝖦",
  	"\\mathsf{H}": "𝖧",
  	"\\mathsf{I}": "𝖨",
  	"\\mathsf{J}": "𝖩",
  	"\\mathsf{K}": "𝖪",
  	"\\mathsf{L}": "𝖫",
  	"\\mathsf{M}": "𝖬",
  	"\\mathsf{N}": "𝖭",
  	"\\mathsf{O}": "𝖮",
  	"\\mathsf{P}": "𝖯",
  	"\\mathsf{Q}": "𝖰",
  	"\\mathsf{R}": "𝖱",
  	"\\mathsf{S}": "𝖲",
  	"\\mathsf{T}": "𝖳",
  	"\\mathsf{U}": "𝖴",
  	"\\mathsf{V}": "𝖵",
  	"\\mathsf{W}": "𝖶",
  	"\\mathsf{X}": "𝖷",
  	"\\mathsf{Y}": "𝖸",
  	"\\mathsf{Z}": "𝖹",
  	"\\mathsf{a}": "𝖺",
  	"\\mathsf{b}": "𝖻",
  	"\\mathsf{c}": "𝖼",
  	"\\mathsf{d}": "𝖽",
  	"\\mathsf{e}": "𝖾",
  	"\\mathsf{f}": "𝖿",
  	"\\mathsf{g}": "𝗀",
  	"\\mathsf{h}": "𝗁",
  	"\\mathsf{i}": "𝗂",
  	"\\mathsf{j}": "𝗃",
  	"\\mathsf{k}": "𝗄",
  	"\\mathsf{l}": "𝗅",
  	"\\mathsf{m}": "𝗆",
  	"\\mathsf{n}": "𝗇",
  	"\\mathsf{o}": "𝗈",
  	"\\mathsf{p}": "𝗉",
  	"\\mathsf{q}": "𝗊",
  	"\\mathsf{r}": "𝗋",
  	"\\mathsf{s}": "𝗌",
  	"\\mathsf{t}": "𝗍",
  	"\\mathsf{u}": "𝗎",
  	"\\mathsf{v}": "𝗏",
  	"\\mathsf{w}": "𝗐",
  	"\\mathsf{x}": "𝗑",
  	"\\mathsf{y}": "𝗒",
  	"\\mathsf{z}": "𝗓",
  	"\\mathsfbf{A}": "𝗔",
  	"\\mathsfbf{B}": "𝗕",
  	"\\mathsfbf{C}": "𝗖",
  	"\\mathsfbf{D}": "𝗗",
  	"\\mathsfbf{E}": "𝗘",
  	"\\mathsfbf{F}": "𝗙",
  	"\\mathsfbf{G}": "𝗚",
  	"\\mathsfbf{H}": "𝗛",
  	"\\mathsfbf{I}": "𝗜",
  	"\\mathsfbf{J}": "𝗝",
  	"\\mathsfbf{K}": "𝗞",
  	"\\mathsfbf{L}": "𝗟",
  	"\\mathsfbf{M}": "𝗠",
  	"\\mathsfbf{N}": "𝗡",
  	"\\mathsfbf{O}": "𝗢",
  	"\\mathsfbf{P}": "𝗣",
  	"\\mathsfbf{Q}": "𝗤",
  	"\\mathsfbf{R}": "𝗥",
  	"\\mathsfbf{S}": "𝗦",
  	"\\mathsfbf{T}": "𝗧",
  	"\\mathsfbf{U}": "𝗨",
  	"\\mathsfbf{V}": "𝗩",
  	"\\mathsfbf{W}": "𝗪",
  	"\\mathsfbf{X}": "𝗫",
  	"\\mathsfbf{Y}": "𝗬",
  	"\\mathsfbf{Z}": "𝗭",
  	"\\mathsfbf{a}": "𝗮",
  	"\\mathsfbf{b}": "𝗯",
  	"\\mathsfbf{c}": "𝗰",
  	"\\mathsfbf{d}": "𝗱",
  	"\\mathsfbf{e}": "𝗲",
  	"\\mathsfbf{f}": "𝗳",
  	"\\mathsfbf{g}": "𝗴",
  	"\\mathsfbf{h}": "𝗵",
  	"\\mathsfbf{i}": "𝗶",
  	"\\mathsfbf{j}": "𝗷",
  	"\\mathsfbf{k}": "𝗸",
  	"\\mathsfbf{l}": "𝗹",
  	"\\mathsfbf{m}": "𝗺",
  	"\\mathsfbf{n}": "𝗻",
  	"\\mathsfbf{o}": "𝗼",
  	"\\mathsfbf{p}": "𝗽",
  	"\\mathsfbf{q}": "𝗾",
  	"\\mathsfbf{r}": "𝗿",
  	"\\mathsfbf{s}": "𝘀",
  	"\\mathsfbf{t}": "𝘁",
  	"\\mathsfbf{u}": "𝘂",
  	"\\mathsfbf{v}": "𝘃",
  	"\\mathsfbf{w}": "𝘄",
  	"\\mathsfbf{x}": "𝘅",
  	"\\mathsfbf{y}": "𝘆",
  	"\\mathsfbf{z}": "𝘇",
  	"\\mathsfsl{A}": "𝘈",
  	"\\mathsfsl{B}": "𝘉",
  	"\\mathsfsl{C}": "𝘊",
  	"\\mathsfsl{D}": "𝘋",
  	"\\mathsfsl{E}": "𝘌",
  	"\\mathsfsl{F}": "𝘍",
  	"\\mathsfsl{G}": "𝘎",
  	"\\mathsfsl{H}": "𝘏",
  	"\\mathsfsl{I}": "𝘐",
  	"\\mathsfsl{J}": "𝘑",
  	"\\mathsfsl{K}": "𝘒",
  	"\\mathsfsl{L}": "𝘓",
  	"\\mathsfsl{M}": "𝘔",
  	"\\mathsfsl{N}": "𝘕",
  	"\\mathsfsl{O}": "𝘖",
  	"\\mathsfsl{P}": "𝘗",
  	"\\mathsfsl{Q}": "𝘘",
  	"\\mathsfsl{R}": "𝘙",
  	"\\mathsfsl{S}": "𝘚",
  	"\\mathsfsl{T}": "𝘛",
  	"\\mathsfsl{U}": "𝘜",
  	"\\mathsfsl{V}": "𝘝",
  	"\\mathsfsl{W}": "𝘞",
  	"\\mathsfsl{X}": "𝘟",
  	"\\mathsfsl{Y}": "𝘠",
  	"\\mathsfsl{Z}": "𝘡",
  	"\\mathsfsl{a}": "𝘢",
  	"\\mathsfsl{b}": "𝘣",
  	"\\mathsfsl{c}": "𝘤",
  	"\\mathsfsl{d}": "𝘥",
  	"\\mathsfsl{e}": "𝘦",
  	"\\mathsfsl{f}": "𝘧",
  	"\\mathsfsl{g}": "𝘨",
  	"\\mathsfsl{h}": "𝘩",
  	"\\mathsfsl{i}": "𝘪",
  	"\\mathsfsl{j}": "𝘫",
  	"\\mathsfsl{k}": "𝘬",
  	"\\mathsfsl{l}": "𝘭",
  	"\\mathsfsl{m}": "𝘮",
  	"\\mathsfsl{n}": "𝘯",
  	"\\mathsfsl{o}": "𝘰",
  	"\\mathsfsl{p}": "𝘱",
  	"\\mathsfsl{q}": "𝘲",
  	"\\mathsfsl{r}": "𝘳",
  	"\\mathsfsl{s}": "𝘴",
  	"\\mathsfsl{t}": "𝘵",
  	"\\mathsfsl{u}": "𝘶",
  	"\\mathsfsl{v}": "𝘷",
  	"\\mathsfsl{w}": "𝘸",
  	"\\mathsfsl{x}": "𝘹",
  	"\\mathsfsl{y}": "𝘺",
  	"\\mathsfsl{z}": "𝘻",
  	"\\mathsfbfsl{A}": "𝘼",
  	"\\mathsfbfsl{B}": "𝘽",
  	"\\mathsfbfsl{C}": "𝘾",
  	"\\mathsfbfsl{D}": "𝘿",
  	"\\mathsfbfsl{E}": "𝙀",
  	"\\mathsfbfsl{F}": "𝙁",
  	"\\mathsfbfsl{G}": "𝙂",
  	"\\mathsfbfsl{H}": "𝙃",
  	"\\mathsfbfsl{I}": "𝙄",
  	"\\mathsfbfsl{J}": "𝙅",
  	"\\mathsfbfsl{K}": "𝙆",
  	"\\mathsfbfsl{L}": "𝙇",
  	"\\mathsfbfsl{M}": "𝙈",
  	"\\mathsfbfsl{N}": "𝙉",
  	"\\mathsfbfsl{O}": "𝙊",
  	"\\mathsfbfsl{P}": "𝙋",
  	"\\mathsfbfsl{Q}": "𝙌",
  	"\\mathsfbfsl{R}": "𝙍",
  	"\\mathsfbfsl{S}": "𝙎",
  	"\\mathsfbfsl{T}": "𝙏",
  	"\\mathsfbfsl{U}": "𝙐",
  	"\\mathsfbfsl{V}": "𝙑",
  	"\\mathsfbfsl{W}": "𝙒",
  	"\\mathsfbfsl{X}": "𝙓",
  	"\\mathsfbfsl{Y}": "𝙔",
  	"\\mathsfbfsl{Z}": "𝙕",
  	"\\mathsfbfsl{a}": "𝙖",
  	"\\mathsfbfsl{b}": "𝙗",
  	"\\mathsfbfsl{c}": "𝙘",
  	"\\mathsfbfsl{d}": "𝙙",
  	"\\mathsfbfsl{e}": "𝙚",
  	"\\mathsfbfsl{f}": "𝙛",
  	"\\mathsfbfsl{g}": "𝙜",
  	"\\mathsfbfsl{h}": "𝙝",
  	"\\mathsfbfsl{i}": "𝙞",
  	"\\mathsfbfsl{j}": "𝙟",
  	"\\mathsfbfsl{k}": "𝙠",
  	"\\mathsfbfsl{l}": "𝙡",
  	"\\mathsfbfsl{m}": "𝙢",
  	"\\mathsfbfsl{n}": "𝙣",
  	"\\mathsfbfsl{o}": "𝙤",
  	"\\mathsfbfsl{p}": "𝙥",
  	"\\mathsfbfsl{q}": "𝙦",
  	"\\mathsfbfsl{r}": "𝙧",
  	"\\mathsfbfsl{s}": "𝙨",
  	"\\mathsfbfsl{t}": "𝙩",
  	"\\mathsfbfsl{u}": "𝙪",
  	"\\mathsfbfsl{v}": "𝙫",
  	"\\mathsfbfsl{w}": "𝙬",
  	"\\mathsfbfsl{x}": "𝙭",
  	"\\mathsfbfsl{y}": "𝙮",
  	"\\mathsfbfsl{z}": "𝙯",
  	"\\mathtt{A}": "𝙰",
  	"\\mathtt{B}": "𝙱",
  	"\\mathtt{C}": "𝙲",
  	"\\mathtt{D}": "𝙳",
  	"\\mathtt{E}": "𝙴",
  	"\\mathtt{F}": "𝙵",
  	"\\mathtt{G}": "𝙶",
  	"\\mathtt{H}": "𝙷",
  	"\\mathtt{I}": "𝙸",
  	"\\mathtt{J}": "𝙹",
  	"\\mathtt{K}": "𝙺",
  	"\\mathtt{L}": "𝙻",
  	"\\mathtt{M}": "𝙼",
  	"\\mathtt{N}": "𝙽",
  	"\\mathtt{O}": "𝙾",
  	"\\mathtt{P}": "𝙿",
  	"\\mathtt{Q}": "𝚀",
  	"\\mathtt{R}": "𝚁",
  	"\\mathtt{S}": "𝚂",
  	"\\mathtt{T}": "𝚃",
  	"\\mathtt{U}": "𝚄",
  	"\\mathtt{V}": "𝚅",
  	"\\mathtt{W}": "𝚆",
  	"\\mathtt{X}": "𝚇",
  	"\\mathtt{Y}": "𝚈",
  	"\\mathtt{Z}": "𝚉",
  	"\\mathtt{a}": "𝚊",
  	"\\mathtt{b}": "𝚋",
  	"\\mathtt{c}": "𝚌",
  	"\\mathtt{d}": "𝚍",
  	"\\mathtt{e}": "𝚎",
  	"\\mathtt{f}": "𝚏",
  	"\\mathtt{g}": "𝚐",
  	"\\mathtt{h}": "𝚑",
  	"\\mathtt{i}": "𝚒",
  	"\\mathtt{j}": "𝚓",
  	"\\mathtt{k}": "𝚔",
  	"\\mathtt{l}": "𝚕",
  	"\\mathtt{m}": "𝚖",
  	"\\mathtt{n}": "𝚗",
  	"\\mathtt{o}": "𝚘",
  	"\\mathtt{p}": "𝚙",
  	"\\mathtt{q}": "𝚚",
  	"\\mathtt{r}": "𝚛",
  	"\\mathtt{s}": "𝚜",
  	"\\mathtt{t}": "𝚝",
  	"\\mathtt{u}": "𝚞",
  	"\\mathtt{v}": "𝚟",
  	"\\mathtt{w}": "𝚠",
  	"\\mathtt{x}": "𝚡",
  	"\\mathtt{y}": "𝚢",
  	"\\mathtt{z}": "𝚣",
  	"\\mathbf{\\Gamma}": "𝚪",
  	"\\mathbf{\\Delta}": "𝚫",
  	"\\mathbf{\\Theta}": "𝚯",
  	"\\mathbf{\\Lambda}": "𝚲",
  	"\\mathbf{\\Xi}": "𝚵",
  	"\\mathbf{\\Pi}": "𝚷",
  	"\\mathbf{\\vartheta}": "𝚹",
  	"\\mathbf{\\Sigma}": "𝚺",
  	"\\mathbf{\\Upsilon}": "𝚼",
  	"\\mathbf{\\Phi}": "𝚽",
  	"\\mathbf{\\Psi}": "𝚿",
  	"\\mathbf{\\Omega}": "𝛀",
  	"\\mathbf{\\nabla}": "𝛁",
  	"\\mathbf{\\alpha}": "𝛂",
  	"\\mathbf{\\beta}": "𝛃",
  	"\\mathbf{\\gamma}": "𝛄",
  	"\\mathbf{\\delta}": "𝛅",
  	"\\mathbf{\\epsilon}": "𝛆",
  	"\\mathbf{\\zeta}": "𝛇",
  	"\\mathbf{\\eta}": "𝛈",
  	"\\mathbf{\\theta}": "𝛉",
  	"\\mathbf{\\lambda}": "𝛌",
  	"\\mathbf{\\xi}": "𝛏",
  	"\\mathbf{\\pi}": "𝛑",
  	"\\mathbf{\\varsigma}": "𝛓",
  	"\\mathbf{\\sigma}": "𝛔",
  	"\\mathbf{\\upsilon}": "𝛖",
  	"\\mathbf{\\phi}": "𝛗",
  	"\\mathbf{\\psi}": "𝛙",
  	"\\mathbf{\\omega}": "𝛚",
  	"\\mathbf{\\varkappa}": "𝛞",
  	"\\mathbf{\\varrho}": "𝛠",
  	"\\mathbf{\\varpi}": "𝛡",
  	"\\mathsl{\\Gamma}": "𝛤",
  	"\\mathsl{\\Delta}": "𝛥",
  	"\\mathsl{\\Lambda}": "𝛬",
  	"\\mathsl{\\Xi}": "𝛯",
  	"\\mathsl{\\Pi}": "𝛱",
  	"\\mathsl{\\Theta}": "𝛳",
  	"\\mathsl{\\Sigma}": "𝛴",
  	"\\mathsl{\\Upsilon}": "𝛶",
  	"\\mathsl{\\Phi}": "𝛷",
  	"\\mathsl{\\Psi}": "𝛹",
  	"\\mathsl{\\Omega}": "𝛺",
  	"\\mathsl{\\nabla}": "𝛻",
  	"\\mathsl{\\gamma}": "𝛾",
  	"\\mathsl{\\delta}": "𝛿",
  	"\\mathsl{\\theta}": "𝜃",
  	"\\mathsl{\\lambda}": "𝜆",
  	"\\mu": "𝜇",
  	"\\mathsl{\\xi}": "𝜉",
  	"\\mathsl{\\pi}": "𝜋",
  	"\\mathsl{\\varsigma}": "𝜍",
  	"\\mathsl{\\sigma}": "𝜎",
  	"\\mathsl{\\upsilon}": "𝜐",
  	"\\mathsl{\\varphi}": "𝜑",
  	"\\mathsl{\\psi}": "𝜓",
  	"\\mathsl{\\omega}": "𝜔",
  	"\\mathsl{\\vartheta}": "𝜗",
  	"\\mathsl{\\varkappa}": "𝜘",
  	"\\mathsl{\\phi}": "𝜙",
  	"\\mathsl{\\varrho}": "𝜚",
  	"\\mathsl{\\varpi}": "𝜛",
  	"\\mathbit{\\Gamma}": "𝜞",
  	"\\mathbit{\\Delta}": "𝜟",
  	"\\mathbit{\\Theta}": "𝜣",
  	"\\mathbit{\\Lambda}": "𝜦",
  	"\\mathbit{\\Xi}": "𝜩",
  	"\\mathbit{\\Pi}": "𝜫",
  	"\\mathbit{\\Sigma}": "𝜮",
  	"\\mathbit{\\Upsilon}": "𝜰",
  	"\\mathbit{\\Phi}": "𝜱",
  	"\\mathbit{\\Psi}": "𝜳",
  	"\\mathbit{\\Omega}": "𝜴",
  	"\\mathbit{\\nabla}": "𝜵",
  	"\\mathbit{\\alpha}": "𝜶",
  	"\\mathbit{\\beta}": "𝜷",
  	"\\mathbit{\\gamma}": "𝜸",
  	"\\mathbit{\\delta}": "𝜹",
  	"\\mathbit{\\epsilon}": "𝜺",
  	"\\mathbit{\\zeta}": "𝜻",
  	"\\mathbit{\\eta}": "𝜼",
  	"\\mathbit{\\theta}": "𝜽",
  	"\\mathbit{\\imath}": "𝜾",
  	"\\mathbit{\\kappa}": "𝜿",
  	"\\mathbit{\\lambda}": "𝝀",
  	"\\mathbit{\\xi}": "𝝃",
  	"\\mathbit{\\pi}": "𝝅",
  	"\\mathbit{\\rho}": "𝝆",
  	"\\mathbit{\\varsigma}": "𝝇",
  	"\\mathbit{\\sigma}": "𝝈",
  	"\\mathbit{\\tau}": "𝝉",
  	"\\mathbit{\\upsilon}": "𝝊",
  	"\\mathbit{\\varphi}": "𝝋",
  	"\\mathbit{\\chi}": "𝝌",
  	"\\mathbit{\\psi}": "𝝍",
  	"\\mathbit{\\omega}": "𝝎",
  	"\\mathbit{\\vartheta}": "𝝑",
  	"\\mathbit{\\varkappa}": "𝝒",
  	"\\mathbit{\\phi}": "𝝓",
  	"\\mathbit{\\varrho}": "𝝔",
  	"\\mathbit{\\varpi}": "𝝕",
  	"\\mathsfbf{\\Gamma}": "𝝘",
  	"\\mathsfbf{\\Delta}": "𝝙",
  	"\\mathsfbf{\\Theta}": "𝝝",
  	"\\mathsfbf{\\Lambda}": "𝝠",
  	"\\mathsfbf{\\Xi}": "𝝣",
  	"\\mathsfbf{\\Pi}": "𝝥",
  	"\\mathsfbf{\\Sigma}": "𝝨",
  	"\\mathsfbf{\\Upsilon}": "𝝪",
  	"\\mathsfbf{\\Phi}": "𝝫",
  	"\\mathsfbf{\\Psi}": "𝝭",
  	"\\mathsfbf{\\Omega}": "𝝮",
  	"\\mathsfbf{\\nabla}": "𝝯",
  	"\\mathsfbf{\\alpha}": "𝝰",
  	"\\mathsfbf{\\beta}": "𝝱",
  	"\\mathsfbf{\\gamma}": "𝝲",
  	"\\mathsfbf{\\delta}": "𝝳",
  	"\\mathsfbf{\\varepsilon}": "𝝴",
  	"\\mathsfbf{\\zeta}": "𝝵",
  	"\\mathsfbf{\\eta}": "𝝶",
  	"\\mathsfbf{\\theta}": "𝝷",
  	"\\mathsfbf{\\imath}": "𝝸",
  	"\\mathsfbf{\\kappa}": "𝝹",
  	"\\mathsfbf{\\lambda}": "𝝺",
  	"\\mathsfbf{\\xi}": "𝝽",
  	"\\mathsfbf{\\pi}": "𝝿",
  	"\\mathsfbf{\\rho}": "𝞀",
  	"\\mathsfbf{\\varsigma}": "𝞁",
  	"\\mathsfbf{\\sigma}": "𝞂",
  	"\\mathsfbf{\\tau}": "𝞃",
  	"\\mathsfbf{\\upsilon}": "𝞄",
  	"\\mathsfbf{\\varphi}": "𝞅",
  	"\\mathsfbf{\\chi}": "𝞆",
  	"\\mathsfbf{\\psi}": "𝞇",
  	"\\mathsfbf{\\omega}": "𝞈",
  	"\\mathsfbf{\\vartheta}": "𝞋",
  	"\\mathsfbf{\\varkappa}": "𝞌",
  	"\\mathsfbf{\\phi}": "𝞍",
  	"\\mathsfbf{\\varrho}": "𝞎",
  	"\\mathsfbf{\\varpi}": "𝞏",
  	"\\mathsfbfsl{\\Gamma}": "𝞒",
  	"\\mathsfbfsl{\\Delta}": "𝞓",
  	"\\mathsfbfsl{\\Theta}": "𝞗",
  	"\\mathsfbfsl{\\Lambda}": "𝞚",
  	"\\mathsfbfsl{\\Xi}": "𝞝",
  	"\\mathsfbfsl{\\Pi}": "𝞟",
  	"\\mathsfbfsl{\\Sigma}": "𝞢",
  	"\\mathsfbfsl{\\Upsilon}": "𝞤",
  	"\\mathsfbfsl{\\Phi}": "𝞥",
  	"\\mathsfbfsl{\\Psi}": "𝞧",
  	"\\mathsfbfsl{\\Omega}": "𝞨",
  	"\\mathsfbfsl{\\nabla}": "𝞩",
  	"\\mathsfbfsl{\\alpha}": "𝞪",
  	"\\mathsfbfsl{\\beta}": "𝞫",
  	"\\mathsfbfsl{\\gamma}": "𝞬",
  	"\\mathsfbfsl{\\delta}": "𝞭",
  	"\\mathsfbfsl{\\varepsilon}": "𝞮",
  	"\\mathsfbfsl{\\zeta}": "𝞯",
  	"\\mathsfbfsl{\\eta}": "𝞰",
  	"\\mathsfbfsl{\\theta}": "𝞱",
  	"\\mathsfbfsl{\\imath}": "𝞲",
  	"\\mathsfbfsl{\\kappa}": "𝞳",
  	"\\mathsfbfsl{\\lambda}": "𝞴",
  	"\\mathsfbfsl{\\xi}": "𝞷",
  	"\\mathsfbfsl{\\pi}": "𝞹",
  	"\\mathsfbfsl{\\rho}": "𝞺",
  	"\\mathsfbfsl{\\varsigma}": "𝞻",
  	"\\mathsfbfsl{\\sigma}": "𝞼",
  	"\\mathsfbfsl{\\tau}": "𝞽",
  	"\\mathsfbfsl{\\upsilon}": "𝞾",
  	"\\mathsfbfsl{\\varphi}": "𝞿",
  	"\\mathsfbfsl{\\chi}": "𝟀",
  	"\\mathsfbfsl{\\psi}": "𝟁",
  	"\\mathsfbfsl{\\omega}": "𝟂",
  	"\\mathsfbfsl{\\vartheta}": "𝟅",
  	"\\mathsfbfsl{\\varkappa}": "𝟆",
  	"\\mathsfbfsl{\\phi}": "𝟇",
  	"\\mathsfbfsl{\\varrho}": "𝟈",
  	"\\mathsfbfsl{\\varpi}": "𝟉",
  	"\\mbfDigamma": "𝟊",
  	"\\mbfdigamma": "𝟋",
  	"\\mathbf{0}": "𝟎",
  	"\\mathbf{1}": "𝟏",
  	"\\mathbf{2}": "𝟐",
  	"\\mathbf{3}": "𝟑",
  	"\\mathbf{4}": "𝟒",
  	"\\mathbf{5}": "𝟓",
  	"\\mathbf{6}": "𝟔",
  	"\\mathbf{7}": "𝟕",
  	"\\mathbf{8}": "𝟖",
  	"\\mathbf{9}": "𝟗",
  	"\\mathbb{0}": "𝟘",
  	"\\mathbb{1}": "𝟙",
  	"\\mathbb{2}": "𝟚",
  	"\\mathbb{3}": "𝟛",
  	"\\mathbb{4}": "𝟜",
  	"\\mathbb{5}": "𝟝",
  	"\\mathbb{6}": "𝟞",
  	"\\mathbb{7}": "𝟟",
  	"\\mathbb{8}": "𝟠",
  	"\\mathbb{9}": "𝟡",
  	"\\mathsf{0}": "𝟢",
  	"\\mathsf{1}": "𝟣",
  	"\\mathsf{2}": "𝟤",
  	"\\mathsf{3}": "𝟥",
  	"\\mathsf{4}": "𝟦",
  	"\\mathsf{5}": "𝟧",
  	"\\mathsf{6}": "𝟨",
  	"\\mathsf{7}": "𝟩",
  	"\\mathsf{8}": "𝟪",
  	"\\mathsf{9}": "𝟫",
  	"\\mathsfbf{0}": "𝟬",
  	"\\mathsfbf{1}": "𝟭",
  	"\\mathsfbf{2}": "𝟮",
  	"\\mathsfbf{3}": "𝟯",
  	"\\mathsfbf{4}": "𝟰",
  	"\\mathsfbf{5}": "𝟱",
  	"\\mathsfbf{6}": "𝟲",
  	"\\mathsfbf{7}": "𝟳",
  	"\\mathsfbf{8}": "𝟴",
  	"\\mathsfbf{9}": "𝟵",
  	"\\mathtt{0}": "𝟶",
  	"\\mathtt{1}": "𝟷",
  	"\\mathtt{2}": "𝟸",
  	"\\mathtt{3}": "𝟹",
  	"\\mathtt{4}": "𝟺",
  	"\\mathtt{5}": "𝟻",
  	"\\mathtt{6}": "𝟼",
  	"\\mathtt{7}": "𝟽",
  	"\\mathtt{8}": "𝟾",
  	"\\mathtt{9}": "𝟿"
  };

  var commands = [
  	"acute",
  	"bar",
  	"breve",
  	"c",
  	"d",
  	"ddot",
  	"dot",
  	"grave",
  	"hat",
  	"k",
  	"mathring",
  	"overline",
  	"r",
  	"textacutemacron",
  	"textacutewedge",
  	"textadvancing",
  	"textbrevemacron",
  	"textcircumdot",
  	"textcorner",
  	"textdotacute",
  	"textdotbreve",
  	"textdoublegrave",
  	"textdoublevbaraccent",
  	"textgravedot",
  	"textgravemacron",
  	"textinvsubbridge",
  	"textlowering",
  	"textovercross",
  	"textraising",
  	"textretracting",
  	"textringmacron",
  	"textseagull",
  	"textsubarch",
  	"textsubbar",
  	"textsubbridge",
  	"textsubgrave",
  	"textsublhalfring",
  	"textsubplus",
  	"textsubrhalfring",
  	"textsubring",
  	"textsubsquare",
  	"textsubtilde",
  	"textsubumlaut",
  	"textsubwedge",
  	"textsuperimposetilde",
  	"textsyllabic",
  	"texttildedot",
  	"textvbaraccent",
  	"tilde",
  	"u",
  	"underbar",
  	"v"
  ];
  var tolatex = {
  	"̀": {
  		command: "`",
  		mode: "text"
  	},
  	"̀̄": {
  		command: "textgravemacron",
  		mode: "text"
  	},
  	"̀̇": {
  		command: "textgravedot",
  		mode: "text"
  	},
  	"́": {
  		command: "'",
  		mode: "text"
  	},
  	"́̄": {
  		command: "textacutemacron",
  		mode: "text"
  	},
  	"́̇": {
  		command: "textdotacute",
  		mode: "text"
  	},
  	"́̌": {
  		command: "textacutewedge",
  		mode: "text"
  	},
  	"̂": {
  		command: "^",
  		mode: "text"
  	},
  	"̂̇": {
  		command: "textcircumdot",
  		mode: "text"
  	},
  	"̃": {
  		command: "~",
  		mode: "text"
  	},
  	"̃̇": {
  		command: "texttildedot",
  		mode: "text"
  	},
  	"̄": {
  		command: "=",
  		mode: "text"
  	},
  	"̄̀": {
  		command: "textgravemacron",
  		mode: "text"
  	},
  	"̄́": {
  		command: "textacutemacron",
  		mode: "text"
  	},
  	"̄̆": {
  		command: "textbrevemacron",
  		mode: "text"
  	},
  	"̄̊": {
  		command: "textringmacron",
  		mode: "text"
  	},
  	"̅": {
  		command: "overline",
  		mode: "math"
  	},
  	"̆": {
  		command: "u",
  		mode: "text"
  	},
  	"̆̄": {
  		command: "textbrevemacron",
  		mode: "text"
  	},
  	"̆̇": {
  		command: "textdotbreve",
  		mode: "text"
  	},
  	"̇": {
  		command: ".",
  		mode: "text"
  	},
  	"̇̀": {
  		command: "textgravedot",
  		mode: "text"
  	},
  	"̇́": {
  		command: "textdotacute",
  		mode: "text"
  	},
  	"̇̂": {
  		command: "textcircumdot",
  		mode: "text"
  	},
  	"̇̃": {
  		command: "texttildedot",
  		mode: "text"
  	},
  	"̇̆": {
  		command: "textdotbreve",
  		mode: "text"
  	},
  	"̈": {
  		command: "\"",
  		mode: "text"
  	},
  	"̊": {
  		command: "r",
  		mode: "text"
  	},
  	"̊̄": {
  		command: "textringmacron",
  		mode: "text"
  	},
  	"̋": {
  		command: "H",
  		mode: "text"
  	},
  	"̌": {
  		command: "v",
  		mode: "text"
  	},
  	"̌́": {
  		command: "textacutewedge",
  		mode: "text"
  	},
  	"̍": {
  		command: "textvbaraccent",
  		mode: "text"
  	},
  	"̎": {
  		command: "textdoublevbaraccent",
  		mode: "text"
  	},
  	"̏": {
  		command: "textdoublegrave",
  		mode: "text"
  	},
  	"̐": {
  		command: "textdotbreve",
  		mode: "text"
  	},
  	"̖": {
  		command: "textsubgrave",
  		mode: "text"
  	},
  	"̘": {
  		command: "textadvancing",
  		mode: "text"
  	},
  	"̙": {
  		command: "textretracting",
  		mode: "text"
  	},
  	"̚": {
  		command: "textcorner",
  		mode: "text"
  	},
  	"̜": {
  		command: "textsublhalfring",
  		mode: "text"
  	},
  	"̝": {
  		command: "textraising",
  		mode: "text"
  	},
  	"̞": {
  		command: "textlowering",
  		mode: "text"
  	},
  	"̟": {
  		command: "textsubplus",
  		mode: "text"
  	},
  	"̣": {
  		command: "d",
  		mode: "text"
  	},
  	"̤": {
  		command: "textsubumlaut",
  		mode: "text"
  	},
  	"̥": {
  		command: "textsubring",
  		mode: "text"
  	},
  	"̧": {
  		command: "c",
  		mode: "text"
  	},
  	"̨": {
  		command: "k",
  		mode: "text"
  	},
  	"̩": {
  		command: "textsyllabic",
  		mode: "text"
  	},
  	"̪": {
  		command: "textsubbridge",
  		mode: "text"
  	},
  	"̬": {
  		command: "textsubwedge",
  		mode: "text"
  	},
  	"̯": {
  		command: "textsubarch",
  		mode: "text"
  	},
  	"̰": {
  		command: "textsubtilde",
  		mode: "text"
  	},
  	"̱": {
  		command: "textsubbar",
  		mode: "text"
  	},
  	"̴": {
  		command: "textsuperimposetilde",
  		mode: "text"
  	},
  	"̹": {
  		command: "textsubrhalfring",
  		mode: "text"
  	},
  	"̺": {
  		command: "textinvsubbridge",
  		mode: "text"
  	},
  	"̻": {
  		command: "textsubsquare",
  		mode: "text"
  	},
  	"̼": {
  		command: "textseagull",
  		mode: "text"
  	},
  	"̽": {
  		command: "textovercross",
  		mode: "text"
  	}
  };
  var tounicode = {
  	"\"": "̈",
  	"'": "́",
  	".": "̇",
  	"=": "̄",
  	H: "̋",
  	"^": "̂",
  	"`": "̀",
  	acute: "́",
  	bar: "̄",
  	breve: "̆",
  	c: "̧",
  	d: "̣",
  	ddot: "̈",
  	dot: "̇",
  	grave: "̀",
  	hat: "̂",
  	k: "̨",
  	mathring: "̊",
  	overline: "̅",
  	r: "̊",
  	textacutemacron: "̄́",
  	textacutewedge: "̌́",
  	textadvancing: "̘",
  	textbrevemacron: "̄̆",
  	textcircumdot: "̇̂",
  	textcorner: "̚",
  	textdotacute: "́̇",
  	textdotbreve: "̐",
  	textdoublegrave: "̏",
  	textdoublevbaraccent: "̎",
  	textgravedot: "̇̀",
  	textgravemacron: "̀̄",
  	textinvsubbridge: "̺",
  	textlowering: "̞",
  	textovercross: "̽",
  	textraising: "̝",
  	textretracting: "̙",
  	textringmacron: "̄̊",
  	textseagull: "̼",
  	textsubarch: "̯",
  	textsubbar: "̱",
  	textsubbridge: "̪",
  	textsubgrave: "̖",
  	textsublhalfring: "̜",
  	textsubplus: "̟",
  	textsubrhalfring: "̹",
  	textsubring: "̥",
  	textsubsquare: "̻",
  	textsubtilde: "̰",
  	textsubumlaut: "̤",
  	textsubwedge: "̬",
  	textsuperimposetilde: "̴",
  	textsyllabic: "̩",
  	texttildedot: "̇̃",
  	textvbaraccent: "̍",
  	tilde: "̃",
  	u: "̆",
  	underbar: "̱",
  	v: "̌",
  	"~": "̃"
  };
  var require$$4 = {
  	commands: commands,
  	tolatex: tolatex,
  	tounicode: tounicode
  };

  var unicode2latex = {
    ascii: require$$0,
    ascii_bibtex_creator: require$$1,
    unicode: require$$2,
    latex: require$$3,
    diacritics: require$$4,
  };

  var categories = [
      {
          'name': 'C',
          'alias': 'Other',
          'isBmpLast': true,
          'bmp': '\0-\x1F\x7F-\x9F\xAD\u0378\u0379\u0380-\u0383\u038B\u038D\u03A2\u0530\u0557\u0558\u058B\u058C\u0590\u05C8-\u05CF\u05EB-\u05EE\u05F5-\u0605\u061C\u061D\u06DD\u070E\u070F\u074B\u074C\u07B2-\u07BF\u07FB\u07FC\u082E\u082F\u083F\u085C\u085D\u085F\u086B-\u089F\u08B5\u08C8-\u08D2\u08E2\u0984\u098D\u098E\u0991\u0992\u09A9\u09B1\u09B3-\u09B5\u09BA\u09BB\u09C5\u09C6\u09C9\u09CA\u09CF-\u09D6\u09D8-\u09DB\u09DE\u09E4\u09E5\u09FF\u0A00\u0A04\u0A0B-\u0A0E\u0A11\u0A12\u0A29\u0A31\u0A34\u0A37\u0A3A\u0A3B\u0A3D\u0A43-\u0A46\u0A49\u0A4A\u0A4E-\u0A50\u0A52-\u0A58\u0A5D\u0A5F-\u0A65\u0A77-\u0A80\u0A84\u0A8E\u0A92\u0AA9\u0AB1\u0AB4\u0ABA\u0ABB\u0AC6\u0ACA\u0ACE\u0ACF\u0AD1-\u0ADF\u0AE4\u0AE5\u0AF2-\u0AF8\u0B00\u0B04\u0B0D\u0B0E\u0B11\u0B12\u0B29\u0B31\u0B34\u0B3A\u0B3B\u0B45\u0B46\u0B49\u0B4A\u0B4E-\u0B54\u0B58-\u0B5B\u0B5E\u0B64\u0B65\u0B78-\u0B81\u0B84\u0B8B-\u0B8D\u0B91\u0B96-\u0B98\u0B9B\u0B9D\u0BA0-\u0BA2\u0BA5-\u0BA7\u0BAB-\u0BAD\u0BBA-\u0BBD\u0BC3-\u0BC5\u0BC9\u0BCE\u0BCF\u0BD1-\u0BD6\u0BD8-\u0BE5\u0BFB-\u0BFF\u0C0D\u0C11\u0C29\u0C3A-\u0C3C\u0C45\u0C49\u0C4E-\u0C54\u0C57\u0C5B-\u0C5F\u0C64\u0C65\u0C70-\u0C76\u0C8D\u0C91\u0CA9\u0CB4\u0CBA\u0CBB\u0CC5\u0CC9\u0CCE-\u0CD4\u0CD7-\u0CDD\u0CDF\u0CE4\u0CE5\u0CF0\u0CF3-\u0CFF\u0D0D\u0D11\u0D45\u0D49\u0D50-\u0D53\u0D64\u0D65\u0D80\u0D84\u0D97-\u0D99\u0DB2\u0DBC\u0DBE\u0DBF\u0DC7-\u0DC9\u0DCB-\u0DCE\u0DD5\u0DD7\u0DE0-\u0DE5\u0DF0\u0DF1\u0DF5-\u0E00\u0E3B-\u0E3E\u0E5C-\u0E80\u0E83\u0E85\u0E8B\u0EA4\u0EA6\u0EBE\u0EBF\u0EC5\u0EC7\u0ECE\u0ECF\u0EDA\u0EDB\u0EE0-\u0EFF\u0F48\u0F6D-\u0F70\u0F98\u0FBD\u0FCD\u0FDB-\u0FFF\u10C6\u10C8-\u10CC\u10CE\u10CF\u1249\u124E\u124F\u1257\u1259\u125E\u125F\u1289\u128E\u128F\u12B1\u12B6\u12B7\u12BF\u12C1\u12C6\u12C7\u12D7\u1311\u1316\u1317\u135B\u135C\u137D-\u137F\u139A-\u139F\u13F6\u13F7\u13FE\u13FF\u169D-\u169F\u16F9-\u16FF\u170D\u1715-\u171F\u1737-\u173F\u1754-\u175F\u176D\u1771\u1774-\u177F\u17DE\u17DF\u17EA-\u17EF\u17FA-\u17FF\u180E\u180F\u181A-\u181F\u1879-\u187F\u18AB-\u18AF\u18F6-\u18FF\u191F\u192C-\u192F\u193C-\u193F\u1941-\u1943\u196E\u196F\u1975-\u197F\u19AC-\u19AF\u19CA-\u19CF\u19DB-\u19DD\u1A1C\u1A1D\u1A5F\u1A7D\u1A7E\u1A8A-\u1A8F\u1A9A-\u1A9F\u1AAE\u1AAF\u1AC1-\u1AFF\u1B4C-\u1B4F\u1B7D-\u1B7F\u1BF4-\u1BFB\u1C38-\u1C3A\u1C4A-\u1C4C\u1C89-\u1C8F\u1CBB\u1CBC\u1CC8-\u1CCF\u1CFB-\u1CFF\u1DFA\u1F16\u1F17\u1F1E\u1F1F\u1F46\u1F47\u1F4E\u1F4F\u1F58\u1F5A\u1F5C\u1F5E\u1F7E\u1F7F\u1FB5\u1FC5\u1FD4\u1FD5\u1FDC\u1FF0\u1FF1\u1FF5\u1FFF\u200B-\u200F\u202A-\u202E\u2060-\u206F\u2072\u2073\u208F\u209D-\u209F\u20C0-\u20CF\u20F1-\u20FF\u218C-\u218F\u2427-\u243F\u244B-\u245F\u2B74\u2B75\u2B96\u2C2F\u2C5F\u2CF4-\u2CF8\u2D26\u2D28-\u2D2C\u2D2E\u2D2F\u2D68-\u2D6E\u2D71-\u2D7E\u2D97-\u2D9F\u2DA7\u2DAF\u2DB7\u2DBF\u2DC7\u2DCF\u2DD7\u2DDF\u2E53-\u2E7F\u2E9A\u2EF4-\u2EFF\u2FD6-\u2FEF\u2FFC-\u2FFF\u3040\u3097\u3098\u3100-\u3104\u3130\u318F\u31E4-\u31EF\u321F\u9FFD-\u9FFF\uA48D-\uA48F\uA4C7-\uA4CF\uA62C-\uA63F\uA6F8-\uA6FF\uA7C0\uA7C1\uA7CB-\uA7F4\uA82D-\uA82F\uA83A-\uA83F\uA878-\uA87F\uA8C6-\uA8CD\uA8DA-\uA8DF\uA954-\uA95E\uA97D-\uA97F\uA9CE\uA9DA-\uA9DD\uA9FF\uAA37-\uAA3F\uAA4E\uAA4F\uAA5A\uAA5B\uAAC3-\uAADA\uAAF7-\uAB00\uAB07\uAB08\uAB0F\uAB10\uAB17-\uAB1F\uAB27\uAB2F\uAB6C-\uAB6F\uABEE\uABEF\uABFA-\uABFF\uD7A4-\uD7AF\uD7C7-\uD7CA\uD7FC-\uF8FF\uFA6E\uFA6F\uFADA-\uFAFF\uFB07-\uFB12\uFB18-\uFB1C\uFB37\uFB3D\uFB3F\uFB42\uFB45\uFBC2-\uFBD2\uFD40-\uFD4F\uFD90\uFD91\uFDC8-\uFDEF\uFDFE\uFDFF\uFE1A-\uFE1F\uFE53\uFE67\uFE6C-\uFE6F\uFE75\uFEFD-\uFF00\uFFBF-\uFFC1\uFFC8\uFFC9\uFFD0\uFFD1\uFFD8\uFFD9\uFFDD-\uFFDF\uFFE7\uFFEF-\uFFFB\uFFFE\uFFFF',
          'astral': '\uD800[\uDC0C\uDC27\uDC3B\uDC3E\uDC4E\uDC4F\uDC5E-\uDC7F\uDCFB-\uDCFF\uDD03-\uDD06\uDD34-\uDD36\uDD8F\uDD9D-\uDD9F\uDDA1-\uDDCF\uDDFE-\uDE7F\uDE9D-\uDE9F\uDED1-\uDEDF\uDEFC-\uDEFF\uDF24-\uDF2C\uDF4B-\uDF4F\uDF7B-\uDF7F\uDF9E\uDFC4-\uDFC7\uDFD6-\uDFFF]|\uD801[\uDC9E\uDC9F\uDCAA-\uDCAF\uDCD4-\uDCD7\uDCFC-\uDCFF\uDD28-\uDD2F\uDD64-\uDD6E\uDD70-\uDDFF\uDF37-\uDF3F\uDF56-\uDF5F\uDF68-\uDFFF]|\uD802[\uDC06\uDC07\uDC09\uDC36\uDC39-\uDC3B\uDC3D\uDC3E\uDC56\uDC9F-\uDCA6\uDCB0-\uDCDF\uDCF3\uDCF6-\uDCFA\uDD1C-\uDD1E\uDD3A-\uDD3E\uDD40-\uDD7F\uDDB8-\uDDBB\uDDD0\uDDD1\uDE04\uDE07-\uDE0B\uDE14\uDE18\uDE36\uDE37\uDE3B-\uDE3E\uDE49-\uDE4F\uDE59-\uDE5F\uDEA0-\uDEBF\uDEE7-\uDEEA\uDEF7-\uDEFF\uDF36-\uDF38\uDF56\uDF57\uDF73-\uDF77\uDF92-\uDF98\uDF9D-\uDFA8\uDFB0-\uDFFF]|\uD803[\uDC49-\uDC7F\uDCB3-\uDCBF\uDCF3-\uDCF9\uDD28-\uDD2F\uDD3A-\uDE5F\uDE7F\uDEAA\uDEAE\uDEAF\uDEB2-\uDEFF\uDF28-\uDF2F\uDF5A-\uDFAF\uDFCC-\uDFDF\uDFF7-\uDFFF]|\uD804[\uDC4E-\uDC51\uDC70-\uDC7E\uDCBD\uDCC2-\uDCCF\uDCE9-\uDCEF\uDCFA-\uDCFF\uDD35\uDD48-\uDD4F\uDD77-\uDD7F\uDDE0\uDDF5-\uDDFF\uDE12\uDE3F-\uDE7F\uDE87\uDE89\uDE8E\uDE9E\uDEAA-\uDEAF\uDEEB-\uDEEF\uDEFA-\uDEFF\uDF04\uDF0D\uDF0E\uDF11\uDF12\uDF29\uDF31\uDF34\uDF3A\uDF45\uDF46\uDF49\uDF4A\uDF4E\uDF4F\uDF51-\uDF56\uDF58-\uDF5C\uDF64\uDF65\uDF6D-\uDF6F\uDF75-\uDFFF]|\uD805[\uDC5C\uDC62-\uDC7F\uDCC8-\uDCCF\uDCDA-\uDD7F\uDDB6\uDDB7\uDDDE-\uDDFF\uDE45-\uDE4F\uDE5A-\uDE5F\uDE6D-\uDE7F\uDEB9-\uDEBF\uDECA-\uDEFF\uDF1B\uDF1C\uDF2C-\uDF2F\uDF40-\uDFFF]|\uD806[\uDC3C-\uDC9F\uDCF3-\uDCFE\uDD07\uDD08\uDD0A\uDD0B\uDD14\uDD17\uDD36\uDD39\uDD3A\uDD47-\uDD4F\uDD5A-\uDD9F\uDDA8\uDDA9\uDDD8\uDDD9\uDDE5-\uDDFF\uDE48-\uDE4F\uDEA3-\uDEBF\uDEF9-\uDFFF]|\uD807[\uDC09\uDC37\uDC46-\uDC4F\uDC6D-\uDC6F\uDC90\uDC91\uDCA8\uDCB7-\uDCFF\uDD07\uDD0A\uDD37-\uDD39\uDD3B\uDD3E\uDD48-\uDD4F\uDD5A-\uDD5F\uDD66\uDD69\uDD8F\uDD92\uDD99-\uDD9F\uDDAA-\uDEDF\uDEF9-\uDFAF\uDFB1-\uDFBF\uDFF2-\uDFFE]|\uD808[\uDF9A-\uDFFF]|\uD809[\uDC6F\uDC75-\uDC7F\uDD44-\uDFFF]|[\uD80A\uD80B\uD80E-\uD810\uD812-\uD819\uD824-\uD82B\uD82D\uD82E\uD830-\uD833\uD837\uD839\uD83F\uD87B-\uD87D\uD87F\uD885-\uDB3F\uDB41-\uDBFF][\uDC00-\uDFFF]|\uD80D[\uDC2F-\uDFFF]|\uD811[\uDE47-\uDFFF]|\uD81A[\uDE39-\uDE3F\uDE5F\uDE6A-\uDE6D\uDE70-\uDECF\uDEEE\uDEEF\uDEF6-\uDEFF\uDF46-\uDF4F\uDF5A\uDF62\uDF78-\uDF7C\uDF90-\uDFFF]|\uD81B[\uDC00-\uDE3F\uDE9B-\uDEFF\uDF4B-\uDF4E\uDF88-\uDF8E\uDFA0-\uDFDF\uDFE5-\uDFEF\uDFF2-\uDFFF]|\uD821[\uDFF8-\uDFFF]|\uD823[\uDCD6-\uDCFF\uDD09-\uDFFF]|\uD82C[\uDD1F-\uDD4F\uDD53-\uDD63\uDD68-\uDD6F\uDEFC-\uDFFF]|\uD82F[\uDC6B-\uDC6F\uDC7D-\uDC7F\uDC89-\uDC8F\uDC9A\uDC9B\uDCA0-\uDFFF]|\uD834[\uDCF6-\uDCFF\uDD27\uDD28\uDD73-\uDD7A\uDDE9-\uDDFF\uDE46-\uDEDF\uDEF4-\uDEFF\uDF57-\uDF5F\uDF79-\uDFFF]|\uD835[\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDFCC\uDFCD]|\uD836[\uDE8C-\uDE9A\uDEA0\uDEB0-\uDFFF]|\uD838[\uDC07\uDC19\uDC1A\uDC22\uDC25\uDC2B-\uDCFF\uDD2D-\uDD2F\uDD3E\uDD3F\uDD4A-\uDD4D\uDD50-\uDEBF\uDEFA-\uDEFE\uDF00-\uDFFF]|\uD83A[\uDCC5\uDCC6\uDCD7-\uDCFF\uDD4C-\uDD4F\uDD5A-\uDD5D\uDD60-\uDFFF]|\uD83B[\uDC00-\uDC70\uDCB5-\uDD00\uDD3E-\uDDFF\uDE04\uDE20\uDE23\uDE25\uDE26\uDE28\uDE33\uDE38\uDE3A\uDE3C-\uDE41\uDE43-\uDE46\uDE48\uDE4A\uDE4C\uDE50\uDE53\uDE55\uDE56\uDE58\uDE5A\uDE5C\uDE5E\uDE60\uDE63\uDE65\uDE66\uDE6B\uDE73\uDE78\uDE7D\uDE7F\uDE8A\uDE9C-\uDEA0\uDEA4\uDEAA\uDEBC-\uDEEF\uDEF2-\uDFFF]|\uD83C[\uDC2C-\uDC2F\uDC94-\uDC9F\uDCAF\uDCB0\uDCC0\uDCD0\uDCF6-\uDCFF\uDDAE-\uDDE5\uDE03-\uDE0F\uDE3C-\uDE3F\uDE49-\uDE4F\uDE52-\uDE5F\uDE66-\uDEFF]|\uD83D[\uDED8-\uDEDF\uDEED-\uDEEF\uDEFD-\uDEFF\uDF74-\uDF7F\uDFD9-\uDFDF\uDFEC-\uDFFF]|\uD83E[\uDC0C-\uDC0F\uDC48-\uDC4F\uDC5A-\uDC5F\uDC88-\uDC8F\uDCAE\uDCAF\uDCB2-\uDCFF\uDD79\uDDCC\uDE54-\uDE5F\uDE6E\uDE6F\uDE75-\uDE77\uDE7B-\uDE7F\uDE87-\uDE8F\uDEA9-\uDEAF\uDEB7-\uDEBF\uDEC3-\uDECF\uDED7-\uDEFF\uDF93\uDFCB-\uDFEF\uDFFA-\uDFFF]|\uD869[\uDEDE-\uDEFF]|\uD86D[\uDF35-\uDF3F]|\uD86E[\uDC1E\uDC1F]|\uD873[\uDEA2-\uDEAF]|\uD87A[\uDFE1-\uDFFF]|\uD87E[\uDE1E-\uDFFF]|\uD884[\uDF4B-\uDFFF]|\uDB40[\uDC00-\uDCFF\uDDF0-\uDFFF]'
      },
      {
          'name': 'Cc',
          'alias': 'Control',
          'bmp': '\0-\x1F\x7F-\x9F'
      },
      {
          'name': 'Cf',
          'alias': 'Format',
          'bmp': '\xAD\u0600-\u0605\u061C\u06DD\u070F\u08E2\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF\uFFF9-\uFFFB',
          'astral': '\uD804[\uDCBD\uDCCD]|\uD80D[\uDC30-\uDC38]|\uD82F[\uDCA0-\uDCA3]|\uD834[\uDD73-\uDD7A]|\uDB40[\uDC01\uDC20-\uDC7F]'
      },
      {
          'name': 'Cn',
          'alias': 'Unassigned',
          'bmp': '\u0378\u0379\u0380-\u0383\u038B\u038D\u03A2\u0530\u0557\u0558\u058B\u058C\u0590\u05C8-\u05CF\u05EB-\u05EE\u05F5-\u05FF\u061D\u070E\u074B\u074C\u07B2-\u07BF\u07FB\u07FC\u082E\u082F\u083F\u085C\u085D\u085F\u086B-\u089F\u08B5\u08C8-\u08D2\u0984\u098D\u098E\u0991\u0992\u09A9\u09B1\u09B3-\u09B5\u09BA\u09BB\u09C5\u09C6\u09C9\u09CA\u09CF-\u09D6\u09D8-\u09DB\u09DE\u09E4\u09E5\u09FF\u0A00\u0A04\u0A0B-\u0A0E\u0A11\u0A12\u0A29\u0A31\u0A34\u0A37\u0A3A\u0A3B\u0A3D\u0A43-\u0A46\u0A49\u0A4A\u0A4E-\u0A50\u0A52-\u0A58\u0A5D\u0A5F-\u0A65\u0A77-\u0A80\u0A84\u0A8E\u0A92\u0AA9\u0AB1\u0AB4\u0ABA\u0ABB\u0AC6\u0ACA\u0ACE\u0ACF\u0AD1-\u0ADF\u0AE4\u0AE5\u0AF2-\u0AF8\u0B00\u0B04\u0B0D\u0B0E\u0B11\u0B12\u0B29\u0B31\u0B34\u0B3A\u0B3B\u0B45\u0B46\u0B49\u0B4A\u0B4E-\u0B54\u0B58-\u0B5B\u0B5E\u0B64\u0B65\u0B78-\u0B81\u0B84\u0B8B-\u0B8D\u0B91\u0B96-\u0B98\u0B9B\u0B9D\u0BA0-\u0BA2\u0BA5-\u0BA7\u0BAB-\u0BAD\u0BBA-\u0BBD\u0BC3-\u0BC5\u0BC9\u0BCE\u0BCF\u0BD1-\u0BD6\u0BD8-\u0BE5\u0BFB-\u0BFF\u0C0D\u0C11\u0C29\u0C3A-\u0C3C\u0C45\u0C49\u0C4E-\u0C54\u0C57\u0C5B-\u0C5F\u0C64\u0C65\u0C70-\u0C76\u0C8D\u0C91\u0CA9\u0CB4\u0CBA\u0CBB\u0CC5\u0CC9\u0CCE-\u0CD4\u0CD7-\u0CDD\u0CDF\u0CE4\u0CE5\u0CF0\u0CF3-\u0CFF\u0D0D\u0D11\u0D45\u0D49\u0D50-\u0D53\u0D64\u0D65\u0D80\u0D84\u0D97-\u0D99\u0DB2\u0DBC\u0DBE\u0DBF\u0DC7-\u0DC9\u0DCB-\u0DCE\u0DD5\u0DD7\u0DE0-\u0DE5\u0DF0\u0DF1\u0DF5-\u0E00\u0E3B-\u0E3E\u0E5C-\u0E80\u0E83\u0E85\u0E8B\u0EA4\u0EA6\u0EBE\u0EBF\u0EC5\u0EC7\u0ECE\u0ECF\u0EDA\u0EDB\u0EE0-\u0EFF\u0F48\u0F6D-\u0F70\u0F98\u0FBD\u0FCD\u0FDB-\u0FFF\u10C6\u10C8-\u10CC\u10CE\u10CF\u1249\u124E\u124F\u1257\u1259\u125E\u125F\u1289\u128E\u128F\u12B1\u12B6\u12B7\u12BF\u12C1\u12C6\u12C7\u12D7\u1311\u1316\u1317\u135B\u135C\u137D-\u137F\u139A-\u139F\u13F6\u13F7\u13FE\u13FF\u169D-\u169F\u16F9-\u16FF\u170D\u1715-\u171F\u1737-\u173F\u1754-\u175F\u176D\u1771\u1774-\u177F\u17DE\u17DF\u17EA-\u17EF\u17FA-\u17FF\u180F\u181A-\u181F\u1879-\u187F\u18AB-\u18AF\u18F6-\u18FF\u191F\u192C-\u192F\u193C-\u193F\u1941-\u1943\u196E\u196F\u1975-\u197F\u19AC-\u19AF\u19CA-\u19CF\u19DB-\u19DD\u1A1C\u1A1D\u1A5F\u1A7D\u1A7E\u1A8A-\u1A8F\u1A9A-\u1A9F\u1AAE\u1AAF\u1AC1-\u1AFF\u1B4C-\u1B4F\u1B7D-\u1B7F\u1BF4-\u1BFB\u1C38-\u1C3A\u1C4A-\u1C4C\u1C89-\u1C8F\u1CBB\u1CBC\u1CC8-\u1CCF\u1CFB-\u1CFF\u1DFA\u1F16\u1F17\u1F1E\u1F1F\u1F46\u1F47\u1F4E\u1F4F\u1F58\u1F5A\u1F5C\u1F5E\u1F7E\u1F7F\u1FB5\u1FC5\u1FD4\u1FD5\u1FDC\u1FF0\u1FF1\u1FF5\u1FFF\u2065\u2072\u2073\u208F\u209D-\u209F\u20C0-\u20CF\u20F1-\u20FF\u218C-\u218F\u2427-\u243F\u244B-\u245F\u2B74\u2B75\u2B96\u2C2F\u2C5F\u2CF4-\u2CF8\u2D26\u2D28-\u2D2C\u2D2E\u2D2F\u2D68-\u2D6E\u2D71-\u2D7E\u2D97-\u2D9F\u2DA7\u2DAF\u2DB7\u2DBF\u2DC7\u2DCF\u2DD7\u2DDF\u2E53-\u2E7F\u2E9A\u2EF4-\u2EFF\u2FD6-\u2FEF\u2FFC-\u2FFF\u3040\u3097\u3098\u3100-\u3104\u3130\u318F\u31E4-\u31EF\u321F\u9FFD-\u9FFF\uA48D-\uA48F\uA4C7-\uA4CF\uA62C-\uA63F\uA6F8-\uA6FF\uA7C0\uA7C1\uA7CB-\uA7F4\uA82D-\uA82F\uA83A-\uA83F\uA878-\uA87F\uA8C6-\uA8CD\uA8DA-\uA8DF\uA954-\uA95E\uA97D-\uA97F\uA9CE\uA9DA-\uA9DD\uA9FF\uAA37-\uAA3F\uAA4E\uAA4F\uAA5A\uAA5B\uAAC3-\uAADA\uAAF7-\uAB00\uAB07\uAB08\uAB0F\uAB10\uAB17-\uAB1F\uAB27\uAB2F\uAB6C-\uAB6F\uABEE\uABEF\uABFA-\uABFF\uD7A4-\uD7AF\uD7C7-\uD7CA\uD7FC-\uD7FF\uFA6E\uFA6F\uFADA-\uFAFF\uFB07-\uFB12\uFB18-\uFB1C\uFB37\uFB3D\uFB3F\uFB42\uFB45\uFBC2-\uFBD2\uFD40-\uFD4F\uFD90\uFD91\uFDC8-\uFDEF\uFDFE\uFDFF\uFE1A-\uFE1F\uFE53\uFE67\uFE6C-\uFE6F\uFE75\uFEFD\uFEFE\uFF00\uFFBF-\uFFC1\uFFC8\uFFC9\uFFD0\uFFD1\uFFD8\uFFD9\uFFDD-\uFFDF\uFFE7\uFFEF-\uFFF8\uFFFE\uFFFF',
          'astral': '\uD800[\uDC0C\uDC27\uDC3B\uDC3E\uDC4E\uDC4F\uDC5E-\uDC7F\uDCFB-\uDCFF\uDD03-\uDD06\uDD34-\uDD36\uDD8F\uDD9D-\uDD9F\uDDA1-\uDDCF\uDDFE-\uDE7F\uDE9D-\uDE9F\uDED1-\uDEDF\uDEFC-\uDEFF\uDF24-\uDF2C\uDF4B-\uDF4F\uDF7B-\uDF7F\uDF9E\uDFC4-\uDFC7\uDFD6-\uDFFF]|\uD801[\uDC9E\uDC9F\uDCAA-\uDCAF\uDCD4-\uDCD7\uDCFC-\uDCFF\uDD28-\uDD2F\uDD64-\uDD6E\uDD70-\uDDFF\uDF37-\uDF3F\uDF56-\uDF5F\uDF68-\uDFFF]|\uD802[\uDC06\uDC07\uDC09\uDC36\uDC39-\uDC3B\uDC3D\uDC3E\uDC56\uDC9F-\uDCA6\uDCB0-\uDCDF\uDCF3\uDCF6-\uDCFA\uDD1C-\uDD1E\uDD3A-\uDD3E\uDD40-\uDD7F\uDDB8-\uDDBB\uDDD0\uDDD1\uDE04\uDE07-\uDE0B\uDE14\uDE18\uDE36\uDE37\uDE3B-\uDE3E\uDE49-\uDE4F\uDE59-\uDE5F\uDEA0-\uDEBF\uDEE7-\uDEEA\uDEF7-\uDEFF\uDF36-\uDF38\uDF56\uDF57\uDF73-\uDF77\uDF92-\uDF98\uDF9D-\uDFA8\uDFB0-\uDFFF]|\uD803[\uDC49-\uDC7F\uDCB3-\uDCBF\uDCF3-\uDCF9\uDD28-\uDD2F\uDD3A-\uDE5F\uDE7F\uDEAA\uDEAE\uDEAF\uDEB2-\uDEFF\uDF28-\uDF2F\uDF5A-\uDFAF\uDFCC-\uDFDF\uDFF7-\uDFFF]|\uD804[\uDC4E-\uDC51\uDC70-\uDC7E\uDCC2-\uDCCC\uDCCE\uDCCF\uDCE9-\uDCEF\uDCFA-\uDCFF\uDD35\uDD48-\uDD4F\uDD77-\uDD7F\uDDE0\uDDF5-\uDDFF\uDE12\uDE3F-\uDE7F\uDE87\uDE89\uDE8E\uDE9E\uDEAA-\uDEAF\uDEEB-\uDEEF\uDEFA-\uDEFF\uDF04\uDF0D\uDF0E\uDF11\uDF12\uDF29\uDF31\uDF34\uDF3A\uDF45\uDF46\uDF49\uDF4A\uDF4E\uDF4F\uDF51-\uDF56\uDF58-\uDF5C\uDF64\uDF65\uDF6D-\uDF6F\uDF75-\uDFFF]|\uD805[\uDC5C\uDC62-\uDC7F\uDCC8-\uDCCF\uDCDA-\uDD7F\uDDB6\uDDB7\uDDDE-\uDDFF\uDE45-\uDE4F\uDE5A-\uDE5F\uDE6D-\uDE7F\uDEB9-\uDEBF\uDECA-\uDEFF\uDF1B\uDF1C\uDF2C-\uDF2F\uDF40-\uDFFF]|\uD806[\uDC3C-\uDC9F\uDCF3-\uDCFE\uDD07\uDD08\uDD0A\uDD0B\uDD14\uDD17\uDD36\uDD39\uDD3A\uDD47-\uDD4F\uDD5A-\uDD9F\uDDA8\uDDA9\uDDD8\uDDD9\uDDE5-\uDDFF\uDE48-\uDE4F\uDEA3-\uDEBF\uDEF9-\uDFFF]|\uD807[\uDC09\uDC37\uDC46-\uDC4F\uDC6D-\uDC6F\uDC90\uDC91\uDCA8\uDCB7-\uDCFF\uDD07\uDD0A\uDD37-\uDD39\uDD3B\uDD3E\uDD48-\uDD4F\uDD5A-\uDD5F\uDD66\uDD69\uDD8F\uDD92\uDD99-\uDD9F\uDDAA-\uDEDF\uDEF9-\uDFAF\uDFB1-\uDFBF\uDFF2-\uDFFE]|\uD808[\uDF9A-\uDFFF]|\uD809[\uDC6F\uDC75-\uDC7F\uDD44-\uDFFF]|[\uD80A\uD80B\uD80E-\uD810\uD812-\uD819\uD824-\uD82B\uD82D\uD82E\uD830-\uD833\uD837\uD839\uD83F\uD87B-\uD87D\uD87F\uD885-\uDB3F\uDB41-\uDB7F][\uDC00-\uDFFF]|\uD80D[\uDC2F\uDC39-\uDFFF]|\uD811[\uDE47-\uDFFF]|\uD81A[\uDE39-\uDE3F\uDE5F\uDE6A-\uDE6D\uDE70-\uDECF\uDEEE\uDEEF\uDEF6-\uDEFF\uDF46-\uDF4F\uDF5A\uDF62\uDF78-\uDF7C\uDF90-\uDFFF]|\uD81B[\uDC00-\uDE3F\uDE9B-\uDEFF\uDF4B-\uDF4E\uDF88-\uDF8E\uDFA0-\uDFDF\uDFE5-\uDFEF\uDFF2-\uDFFF]|\uD821[\uDFF8-\uDFFF]|\uD823[\uDCD6-\uDCFF\uDD09-\uDFFF]|\uD82C[\uDD1F-\uDD4F\uDD53-\uDD63\uDD68-\uDD6F\uDEFC-\uDFFF]|\uD82F[\uDC6B-\uDC6F\uDC7D-\uDC7F\uDC89-\uDC8F\uDC9A\uDC9B\uDCA4-\uDFFF]|\uD834[\uDCF6-\uDCFF\uDD27\uDD28\uDDE9-\uDDFF\uDE46-\uDEDF\uDEF4-\uDEFF\uDF57-\uDF5F\uDF79-\uDFFF]|\uD835[\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDFCC\uDFCD]|\uD836[\uDE8C-\uDE9A\uDEA0\uDEB0-\uDFFF]|\uD838[\uDC07\uDC19\uDC1A\uDC22\uDC25\uDC2B-\uDCFF\uDD2D-\uDD2F\uDD3E\uDD3F\uDD4A-\uDD4D\uDD50-\uDEBF\uDEFA-\uDEFE\uDF00-\uDFFF]|\uD83A[\uDCC5\uDCC6\uDCD7-\uDCFF\uDD4C-\uDD4F\uDD5A-\uDD5D\uDD60-\uDFFF]|\uD83B[\uDC00-\uDC70\uDCB5-\uDD00\uDD3E-\uDDFF\uDE04\uDE20\uDE23\uDE25\uDE26\uDE28\uDE33\uDE38\uDE3A\uDE3C-\uDE41\uDE43-\uDE46\uDE48\uDE4A\uDE4C\uDE50\uDE53\uDE55\uDE56\uDE58\uDE5A\uDE5C\uDE5E\uDE60\uDE63\uDE65\uDE66\uDE6B\uDE73\uDE78\uDE7D\uDE7F\uDE8A\uDE9C-\uDEA0\uDEA4\uDEAA\uDEBC-\uDEEF\uDEF2-\uDFFF]|\uD83C[\uDC2C-\uDC2F\uDC94-\uDC9F\uDCAF\uDCB0\uDCC0\uDCD0\uDCF6-\uDCFF\uDDAE-\uDDE5\uDE03-\uDE0F\uDE3C-\uDE3F\uDE49-\uDE4F\uDE52-\uDE5F\uDE66-\uDEFF]|\uD83D[\uDED8-\uDEDF\uDEED-\uDEEF\uDEFD-\uDEFF\uDF74-\uDF7F\uDFD9-\uDFDF\uDFEC-\uDFFF]|\uD83E[\uDC0C-\uDC0F\uDC48-\uDC4F\uDC5A-\uDC5F\uDC88-\uDC8F\uDCAE\uDCAF\uDCB2-\uDCFF\uDD79\uDDCC\uDE54-\uDE5F\uDE6E\uDE6F\uDE75-\uDE77\uDE7B-\uDE7F\uDE87-\uDE8F\uDEA9-\uDEAF\uDEB7-\uDEBF\uDEC3-\uDECF\uDED7-\uDEFF\uDF93\uDFCB-\uDFEF\uDFFA-\uDFFF]|\uD869[\uDEDE-\uDEFF]|\uD86D[\uDF35-\uDF3F]|\uD86E[\uDC1E\uDC1F]|\uD873[\uDEA2-\uDEAF]|\uD87A[\uDFE1-\uDFFF]|\uD87E[\uDE1E-\uDFFF]|\uD884[\uDF4B-\uDFFF]|\uDB40[\uDC00\uDC02-\uDC1F\uDC80-\uDCFF\uDDF0-\uDFFF]|[\uDBBF\uDBFF][\uDFFE\uDFFF]'
      },
      {
          'name': 'Co',
          'alias': 'Private_Use',
          'bmp': '\uE000-\uF8FF',
          'astral': '[\uDB80-\uDBBE\uDBC0-\uDBFE][\uDC00-\uDFFF]|[\uDBBF\uDBFF][\uDC00-\uDFFD]'
      },
      {
          'name': 'Cs',
          'alias': 'Surrogate',
          'bmp': '\uD800-\uDFFF'
      },
      {
          'name': 'L',
          'alias': 'Letter',
          'bmp': 'A-Za-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08C7\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\u9FFC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA7BF\uA7C2-\uA7CA\uA7F5-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC',
          'astral': '\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF40\uDF42-\uDF49\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDD00-\uDD23\uDE80-\uDEA9\uDEB0\uDEB1\uDF00-\uDF1C\uDF27\uDF30-\uDF45\uDFB0-\uDFC4\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDEB8\uDF00-\uDF1A]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCDF\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDEE0-\uDEF2\uDFB0]|\uD808[\uDC00-\uDF99]|\uD809[\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE7F\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82C[\uDC00-\uDD1E\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD838[\uDD00-\uDD2C\uDD37-\uDD3D\uDD4E\uDEC0-\uDEEB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43\uDD4B]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDEDD\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A]'
      },
      {
          'name': 'LC',
          'alias': 'Cased_Letter',
          'bmp': 'A-Za-z\xB5\xC0-\xD6\xD8-\xF6\xF8-\u01BA\u01BC-\u01BF\u01C4-\u0293\u0295-\u02AF\u0370-\u0373\u0376\u0377\u037B-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0560-\u0588\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FD-\u10FF\u13A0-\u13F5\u13F8-\u13FD\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1D00-\u1D2B\u1D6B-\u1D77\u1D79-\u1D9A\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2134\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2C7B\u2C7E-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\uA640-\uA66D\uA680-\uA69B\uA722-\uA76F\uA771-\uA787\uA78B-\uA78E\uA790-\uA7BF\uA7C2-\uA7CA\uA7F5\uA7F6\uA7FA\uAB30-\uAB5A\uAB60-\uAB68\uAB70-\uABBF\uFB00-\uFB06\uFB13-\uFB17\uFF21-\uFF3A\uFF41-\uFF5A',
          'astral': '\uD801[\uDC00-\uDC4F\uDCB0-\uDCD3\uDCD8-\uDCFB]|\uD803[\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD806[\uDCA0-\uDCDF]|\uD81B[\uDE40-\uDE7F]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDD00-\uDD43]'
      },
      {
          'name': 'Ll',
          'alias': 'Lowercase_Letter',
          'bmp': 'a-z\xB5\xDF-\xF6\xF8-\xFF\u0101\u0103\u0105\u0107\u0109\u010B\u010D\u010F\u0111\u0113\u0115\u0117\u0119\u011B\u011D\u011F\u0121\u0123\u0125\u0127\u0129\u012B\u012D\u012F\u0131\u0133\u0135\u0137\u0138\u013A\u013C\u013E\u0140\u0142\u0144\u0146\u0148\u0149\u014B\u014D\u014F\u0151\u0153\u0155\u0157\u0159\u015B\u015D\u015F\u0161\u0163\u0165\u0167\u0169\u016B\u016D\u016F\u0171\u0173\u0175\u0177\u017A\u017C\u017E-\u0180\u0183\u0185\u0188\u018C\u018D\u0192\u0195\u0199-\u019B\u019E\u01A1\u01A3\u01A5\u01A8\u01AA\u01AB\u01AD\u01B0\u01B4\u01B6\u01B9\u01BA\u01BD-\u01BF\u01C6\u01C9\u01CC\u01CE\u01D0\u01D2\u01D4\u01D6\u01D8\u01DA\u01DC\u01DD\u01DF\u01E1\u01E3\u01E5\u01E7\u01E9\u01EB\u01ED\u01EF\u01F0\u01F3\u01F5\u01F9\u01FB\u01FD\u01FF\u0201\u0203\u0205\u0207\u0209\u020B\u020D\u020F\u0211\u0213\u0215\u0217\u0219\u021B\u021D\u021F\u0221\u0223\u0225\u0227\u0229\u022B\u022D\u022F\u0231\u0233-\u0239\u023C\u023F\u0240\u0242\u0247\u0249\u024B\u024D\u024F-\u0293\u0295-\u02AF\u0371\u0373\u0377\u037B-\u037D\u0390\u03AC-\u03CE\u03D0\u03D1\u03D5-\u03D7\u03D9\u03DB\u03DD\u03DF\u03E1\u03E3\u03E5\u03E7\u03E9\u03EB\u03ED\u03EF-\u03F3\u03F5\u03F8\u03FB\u03FC\u0430-\u045F\u0461\u0463\u0465\u0467\u0469\u046B\u046D\u046F\u0471\u0473\u0475\u0477\u0479\u047B\u047D\u047F\u0481\u048B\u048D\u048F\u0491\u0493\u0495\u0497\u0499\u049B\u049D\u049F\u04A1\u04A3\u04A5\u04A7\u04A9\u04AB\u04AD\u04AF\u04B1\u04B3\u04B5\u04B7\u04B9\u04BB\u04BD\u04BF\u04C2\u04C4\u04C6\u04C8\u04CA\u04CC\u04CE\u04CF\u04D1\u04D3\u04D5\u04D7\u04D9\u04DB\u04DD\u04DF\u04E1\u04E3\u04E5\u04E7\u04E9\u04EB\u04ED\u04EF\u04F1\u04F3\u04F5\u04F7\u04F9\u04FB\u04FD\u04FF\u0501\u0503\u0505\u0507\u0509\u050B\u050D\u050F\u0511\u0513\u0515\u0517\u0519\u051B\u051D\u051F\u0521\u0523\u0525\u0527\u0529\u052B\u052D\u052F\u0560-\u0588\u10D0-\u10FA\u10FD-\u10FF\u13F8-\u13FD\u1C80-\u1C88\u1D00-\u1D2B\u1D6B-\u1D77\u1D79-\u1D9A\u1E01\u1E03\u1E05\u1E07\u1E09\u1E0B\u1E0D\u1E0F\u1E11\u1E13\u1E15\u1E17\u1E19\u1E1B\u1E1D\u1E1F\u1E21\u1E23\u1E25\u1E27\u1E29\u1E2B\u1E2D\u1E2F\u1E31\u1E33\u1E35\u1E37\u1E39\u1E3B\u1E3D\u1E3F\u1E41\u1E43\u1E45\u1E47\u1E49\u1E4B\u1E4D\u1E4F\u1E51\u1E53\u1E55\u1E57\u1E59\u1E5B\u1E5D\u1E5F\u1E61\u1E63\u1E65\u1E67\u1E69\u1E6B\u1E6D\u1E6F\u1E71\u1E73\u1E75\u1E77\u1E79\u1E7B\u1E7D\u1E7F\u1E81\u1E83\u1E85\u1E87\u1E89\u1E8B\u1E8D\u1E8F\u1E91\u1E93\u1E95-\u1E9D\u1E9F\u1EA1\u1EA3\u1EA5\u1EA7\u1EA9\u1EAB\u1EAD\u1EAF\u1EB1\u1EB3\u1EB5\u1EB7\u1EB9\u1EBB\u1EBD\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7\u1EC9\u1ECB\u1ECD\u1ECF\u1ED1\u1ED3\u1ED5\u1ED7\u1ED9\u1EDB\u1EDD\u1EDF\u1EE1\u1EE3\u1EE5\u1EE7\u1EE9\u1EEB\u1EED\u1EEF\u1EF1\u1EF3\u1EF5\u1EF7\u1EF9\u1EFB\u1EFD\u1EFF-\u1F07\u1F10-\u1F15\u1F20-\u1F27\u1F30-\u1F37\u1F40-\u1F45\u1F50-\u1F57\u1F60-\u1F67\u1F70-\u1F7D\u1F80-\u1F87\u1F90-\u1F97\u1FA0-\u1FA7\u1FB0-\u1FB4\u1FB6\u1FB7\u1FBE\u1FC2-\u1FC4\u1FC6\u1FC7\u1FD0-\u1FD3\u1FD6\u1FD7\u1FE0-\u1FE7\u1FF2-\u1FF4\u1FF6\u1FF7\u210A\u210E\u210F\u2113\u212F\u2134\u2139\u213C\u213D\u2146-\u2149\u214E\u2184\u2C30-\u2C5E\u2C61\u2C65\u2C66\u2C68\u2C6A\u2C6C\u2C71\u2C73\u2C74\u2C76-\u2C7B\u2C81\u2C83\u2C85\u2C87\u2C89\u2C8B\u2C8D\u2C8F\u2C91\u2C93\u2C95\u2C97\u2C99\u2C9B\u2C9D\u2C9F\u2CA1\u2CA3\u2CA5\u2CA7\u2CA9\u2CAB\u2CAD\u2CAF\u2CB1\u2CB3\u2CB5\u2CB7\u2CB9\u2CBB\u2CBD\u2CBF\u2CC1\u2CC3\u2CC5\u2CC7\u2CC9\u2CCB\u2CCD\u2CCF\u2CD1\u2CD3\u2CD5\u2CD7\u2CD9\u2CDB\u2CDD\u2CDF\u2CE1\u2CE3\u2CE4\u2CEC\u2CEE\u2CF3\u2D00-\u2D25\u2D27\u2D2D\uA641\uA643\uA645\uA647\uA649\uA64B\uA64D\uA64F\uA651\uA653\uA655\uA657\uA659\uA65B\uA65D\uA65F\uA661\uA663\uA665\uA667\uA669\uA66B\uA66D\uA681\uA683\uA685\uA687\uA689\uA68B\uA68D\uA68F\uA691\uA693\uA695\uA697\uA699\uA69B\uA723\uA725\uA727\uA729\uA72B\uA72D\uA72F-\uA731\uA733\uA735\uA737\uA739\uA73B\uA73D\uA73F\uA741\uA743\uA745\uA747\uA749\uA74B\uA74D\uA74F\uA751\uA753\uA755\uA757\uA759\uA75B\uA75D\uA75F\uA761\uA763\uA765\uA767\uA769\uA76B\uA76D\uA76F\uA771-\uA778\uA77A\uA77C\uA77F\uA781\uA783\uA785\uA787\uA78C\uA78E\uA791\uA793-\uA795\uA797\uA799\uA79B\uA79D\uA79F\uA7A1\uA7A3\uA7A5\uA7A7\uA7A9\uA7AF\uA7B5\uA7B7\uA7B9\uA7BB\uA7BD\uA7BF\uA7C3\uA7C8\uA7CA\uA7F6\uA7FA\uAB30-\uAB5A\uAB60-\uAB68\uAB70-\uABBF\uFB00-\uFB06\uFB13-\uFB17\uFF41-\uFF5A',
          'astral': '\uD801[\uDC28-\uDC4F\uDCD8-\uDCFB]|\uD803[\uDCC0-\uDCF2]|\uD806[\uDCC0-\uDCDF]|\uD81B[\uDE60-\uDE7F]|\uD835[\uDC1A-\uDC33\uDC4E-\uDC54\uDC56-\uDC67\uDC82-\uDC9B\uDCB6-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDCEA-\uDD03\uDD1E-\uDD37\uDD52-\uDD6B\uDD86-\uDD9F\uDDBA-\uDDD3\uDDEE-\uDE07\uDE22-\uDE3B\uDE56-\uDE6F\uDE8A-\uDEA5\uDEC2-\uDEDA\uDEDC-\uDEE1\uDEFC-\uDF14\uDF16-\uDF1B\uDF36-\uDF4E\uDF50-\uDF55\uDF70-\uDF88\uDF8A-\uDF8F\uDFAA-\uDFC2\uDFC4-\uDFC9\uDFCB]|\uD83A[\uDD22-\uDD43]'
      },
      {
          'name': 'Lm',
          'alias': 'Modifier_Letter',
          'bmp': '\u02B0-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0374\u037A\u0559\u0640\u06E5\u06E6\u07F4\u07F5\u07FA\u081A\u0824\u0828\u0971\u0E46\u0EC6\u10FC\u17D7\u1843\u1AA7\u1C78-\u1C7D\u1D2C-\u1D6A\u1D78\u1D9B-\u1DBF\u2071\u207F\u2090-\u209C\u2C7C\u2C7D\u2D6F\u2E2F\u3005\u3031-\u3035\u303B\u309D\u309E\u30FC-\u30FE\uA015\uA4F8-\uA4FD\uA60C\uA67F\uA69C\uA69D\uA717-\uA71F\uA770\uA788\uA7F8\uA7F9\uA9CF\uA9E6\uAA70\uAADD\uAAF3\uAAF4\uAB5C-\uAB5F\uAB69\uFF70\uFF9E\uFF9F',
          'astral': '\uD81A[\uDF40-\uDF43]|\uD81B[\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3]|\uD838[\uDD37-\uDD3D]|\uD83A\uDD4B'
      },
      {
          'name': 'Lo',
          'alias': 'Other_Letter',
          'bmp': '\xAA\xBA\u01BB\u01C0-\u01C3\u0294\u05D0-\u05EA\u05EF-\u05F2\u0620-\u063F\u0641-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u0800-\u0815\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08C7\u0904-\u0939\u093D\u0950\u0958-\u0961\u0972-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E45\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u1100-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17DC\u1820-\u1842\u1844-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C77\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u2135-\u2138\u2D30-\u2D67\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3006\u303C\u3041-\u3096\u309F\u30A1-\u30FA\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\u9FFC\uA000-\uA014\uA016-\uA48C\uA4D0-\uA4F7\uA500-\uA60B\uA610-\uA61F\uA62A\uA62B\uA66E\uA6A0-\uA6E5\uA78F\uA7F7\uA7FB-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9E0-\uA9E4\uA9E7-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA6F\uAA71-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB\uAADC\uAAE0-\uAAEA\uAAF2\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF66-\uFF6F\uFF71-\uFF9D\uFFA0-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC',
          'astral': '\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF40\uDF42-\uDF49\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF]|\uD801[\uDC50-\uDC9D\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDD00-\uDD23\uDE80-\uDEA9\uDEB0\uDEB1\uDF00-\uDF1C\uDF27\uDF30-\uDF45\uDFB0-\uDFC4\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDEB8\uDF00-\uDF1A]|\uD806[\uDC00-\uDC2B\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDEE0-\uDEF2\uDFB0]|\uD808[\uDC00-\uDF99]|\uD809[\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF4A\uDF50]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82C[\uDC00-\uDD1E\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD838[\uDD00-\uDD2C\uDD4E\uDEC0-\uDEEB]|\uD83A[\uDC00-\uDCC4]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDEDD\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A]'
      },
      {
          'name': 'Lt',
          'alias': 'Titlecase_Letter',
          'bmp': '\u01C5\u01C8\u01CB\u01F2\u1F88-\u1F8F\u1F98-\u1F9F\u1FA8-\u1FAF\u1FBC\u1FCC\u1FFC'
      },
      {
          'name': 'Lu',
          'alias': 'Uppercase_Letter',
          'bmp': 'A-Z\xC0-\xD6\xD8-\xDE\u0100\u0102\u0104\u0106\u0108\u010A\u010C\u010E\u0110\u0112\u0114\u0116\u0118\u011A\u011C\u011E\u0120\u0122\u0124\u0126\u0128\u012A\u012C\u012E\u0130\u0132\u0134\u0136\u0139\u013B\u013D\u013F\u0141\u0143\u0145\u0147\u014A\u014C\u014E\u0150\u0152\u0154\u0156\u0158\u015A\u015C\u015E\u0160\u0162\u0164\u0166\u0168\u016A\u016C\u016E\u0170\u0172\u0174\u0176\u0178\u0179\u017B\u017D\u0181\u0182\u0184\u0186\u0187\u0189-\u018B\u018E-\u0191\u0193\u0194\u0196-\u0198\u019C\u019D\u019F\u01A0\u01A2\u01A4\u01A6\u01A7\u01A9\u01AC\u01AE\u01AF\u01B1-\u01B3\u01B5\u01B7\u01B8\u01BC\u01C4\u01C7\u01CA\u01CD\u01CF\u01D1\u01D3\u01D5\u01D7\u01D9\u01DB\u01DE\u01E0\u01E2\u01E4\u01E6\u01E8\u01EA\u01EC\u01EE\u01F1\u01F4\u01F6-\u01F8\u01FA\u01FC\u01FE\u0200\u0202\u0204\u0206\u0208\u020A\u020C\u020E\u0210\u0212\u0214\u0216\u0218\u021A\u021C\u021E\u0220\u0222\u0224\u0226\u0228\u022A\u022C\u022E\u0230\u0232\u023A\u023B\u023D\u023E\u0241\u0243-\u0246\u0248\u024A\u024C\u024E\u0370\u0372\u0376\u037F\u0386\u0388-\u038A\u038C\u038E\u038F\u0391-\u03A1\u03A3-\u03AB\u03CF\u03D2-\u03D4\u03D8\u03DA\u03DC\u03DE\u03E0\u03E2\u03E4\u03E6\u03E8\u03EA\u03EC\u03EE\u03F4\u03F7\u03F9\u03FA\u03FD-\u042F\u0460\u0462\u0464\u0466\u0468\u046A\u046C\u046E\u0470\u0472\u0474\u0476\u0478\u047A\u047C\u047E\u0480\u048A\u048C\u048E\u0490\u0492\u0494\u0496\u0498\u049A\u049C\u049E\u04A0\u04A2\u04A4\u04A6\u04A8\u04AA\u04AC\u04AE\u04B0\u04B2\u04B4\u04B6\u04B8\u04BA\u04BC\u04BE\u04C0\u04C1\u04C3\u04C5\u04C7\u04C9\u04CB\u04CD\u04D0\u04D2\u04D4\u04D6\u04D8\u04DA\u04DC\u04DE\u04E0\u04E2\u04E4\u04E6\u04E8\u04EA\u04EC\u04EE\u04F0\u04F2\u04F4\u04F6\u04F8\u04FA\u04FC\u04FE\u0500\u0502\u0504\u0506\u0508\u050A\u050C\u050E\u0510\u0512\u0514\u0516\u0518\u051A\u051C\u051E\u0520\u0522\u0524\u0526\u0528\u052A\u052C\u052E\u0531-\u0556\u10A0-\u10C5\u10C7\u10CD\u13A0-\u13F5\u1C90-\u1CBA\u1CBD-\u1CBF\u1E00\u1E02\u1E04\u1E06\u1E08\u1E0A\u1E0C\u1E0E\u1E10\u1E12\u1E14\u1E16\u1E18\u1E1A\u1E1C\u1E1E\u1E20\u1E22\u1E24\u1E26\u1E28\u1E2A\u1E2C\u1E2E\u1E30\u1E32\u1E34\u1E36\u1E38\u1E3A\u1E3C\u1E3E\u1E40\u1E42\u1E44\u1E46\u1E48\u1E4A\u1E4C\u1E4E\u1E50\u1E52\u1E54\u1E56\u1E58\u1E5A\u1E5C\u1E5E\u1E60\u1E62\u1E64\u1E66\u1E68\u1E6A\u1E6C\u1E6E\u1E70\u1E72\u1E74\u1E76\u1E78\u1E7A\u1E7C\u1E7E\u1E80\u1E82\u1E84\u1E86\u1E88\u1E8A\u1E8C\u1E8E\u1E90\u1E92\u1E94\u1E9E\u1EA0\u1EA2\u1EA4\u1EA6\u1EA8\u1EAA\u1EAC\u1EAE\u1EB0\u1EB2\u1EB4\u1EB6\u1EB8\u1EBA\u1EBC\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6\u1EC8\u1ECA\u1ECC\u1ECE\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u1EDA\u1EDC\u1EDE\u1EE0\u1EE2\u1EE4\u1EE6\u1EE8\u1EEA\u1EEC\u1EEE\u1EF0\u1EF2\u1EF4\u1EF6\u1EF8\u1EFA\u1EFC\u1EFE\u1F08-\u1F0F\u1F18-\u1F1D\u1F28-\u1F2F\u1F38-\u1F3F\u1F48-\u1F4D\u1F59\u1F5B\u1F5D\u1F5F\u1F68-\u1F6F\u1FB8-\u1FBB\u1FC8-\u1FCB\u1FD8-\u1FDB\u1FE8-\u1FEC\u1FF8-\u1FFB\u2102\u2107\u210B-\u210D\u2110-\u2112\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u2130-\u2133\u213E\u213F\u2145\u2183\u2C00-\u2C2E\u2C60\u2C62-\u2C64\u2C67\u2C69\u2C6B\u2C6D-\u2C70\u2C72\u2C75\u2C7E-\u2C80\u2C82\u2C84\u2C86\u2C88\u2C8A\u2C8C\u2C8E\u2C90\u2C92\u2C94\u2C96\u2C98\u2C9A\u2C9C\u2C9E\u2CA0\u2CA2\u2CA4\u2CA6\u2CA8\u2CAA\u2CAC\u2CAE\u2CB0\u2CB2\u2CB4\u2CB6\u2CB8\u2CBA\u2CBC\u2CBE\u2CC0\u2CC2\u2CC4\u2CC6\u2CC8\u2CCA\u2CCC\u2CCE\u2CD0\u2CD2\u2CD4\u2CD6\u2CD8\u2CDA\u2CDC\u2CDE\u2CE0\u2CE2\u2CEB\u2CED\u2CF2\uA640\uA642\uA644\uA646\uA648\uA64A\uA64C\uA64E\uA650\uA652\uA654\uA656\uA658\uA65A\uA65C\uA65E\uA660\uA662\uA664\uA666\uA668\uA66A\uA66C\uA680\uA682\uA684\uA686\uA688\uA68A\uA68C\uA68E\uA690\uA692\uA694\uA696\uA698\uA69A\uA722\uA724\uA726\uA728\uA72A\uA72C\uA72E\uA732\uA734\uA736\uA738\uA73A\uA73C\uA73E\uA740\uA742\uA744\uA746\uA748\uA74A\uA74C\uA74E\uA750\uA752\uA754\uA756\uA758\uA75A\uA75C\uA75E\uA760\uA762\uA764\uA766\uA768\uA76A\uA76C\uA76E\uA779\uA77B\uA77D\uA77E\uA780\uA782\uA784\uA786\uA78B\uA78D\uA790\uA792\uA796\uA798\uA79A\uA79C\uA79E\uA7A0\uA7A2\uA7A4\uA7A6\uA7A8\uA7AA-\uA7AE\uA7B0-\uA7B4\uA7B6\uA7B8\uA7BA\uA7BC\uA7BE\uA7C2\uA7C4-\uA7C7\uA7C9\uA7F5\uFF21-\uFF3A',
          'astral': '\uD801[\uDC00-\uDC27\uDCB0-\uDCD3]|\uD803[\uDC80-\uDCB2]|\uD806[\uDCA0-\uDCBF]|\uD81B[\uDE40-\uDE5F]|\uD835[\uDC00-\uDC19\uDC34-\uDC4D\uDC68-\uDC81\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB5\uDCD0-\uDCE9\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD38\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD6C-\uDD85\uDDA0-\uDDB9\uDDD4-\uDDED\uDE08-\uDE21\uDE3C-\uDE55\uDE70-\uDE89\uDEA8-\uDEC0\uDEE2-\uDEFA\uDF1C-\uDF34\uDF56-\uDF6E\uDF90-\uDFA8\uDFCA]|\uD83A[\uDD00-\uDD21]'
      },
      {
          'name': 'M',
          'alias': 'Mark',
          'bmp': '\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1AC0\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F',
          'astral': '\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD803[\uDD24-\uDD27\uDEAB\uDEAC\uDF46-\uDF50]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC7F-\uDC82\uDCB0-\uDCBA\uDD00-\uDD02\uDD27-\uDD34\uDD45\uDD46\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDDC9-\uDDCC\uDDCE\uDDCF\uDE2C-\uDE37\uDE3E\uDEDF-\uDEEA\uDF00-\uDF03\uDF3B\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC35-\uDC46\uDC5E\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDDDC\uDDDD\uDE30-\uDE40\uDEAB-\uDEB7\uDF1D-\uDF2B]|\uD806[\uDC2C-\uDC3A\uDD30-\uDD35\uDD37\uDD38\uDD3B-\uDD3E\uDD40\uDD42\uDD43\uDDD1-\uDDD7\uDDDA-\uDDE0\uDDE4\uDE01-\uDE0A\uDE33-\uDE39\uDE3B-\uDE3E\uDE47\uDE51-\uDE5B\uDE8A-\uDE99]|\uD807[\uDC2F-\uDC36\uDC38-\uDC3F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD31-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD45\uDD47\uDD8A-\uDD8E\uDD90\uDD91\uDD93-\uDD97\uDEF3-\uDEF6]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF4F\uDF51-\uDF87\uDF8F-\uDF92\uDFE4\uDFF0\uDFF1]|\uD82F[\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDD30-\uDD36\uDEEC-\uDEEF]|\uD83A[\uDCD0-\uDCD6\uDD44-\uDD4A]|\uDB40[\uDD00-\uDDEF]'
      },
      {
          'name': 'Mc',
          'alias': 'Spacing_Mark',
          'bmp': '\u0903\u093B\u093E-\u0940\u0949-\u094C\u094E\u094F\u0982\u0983\u09BE-\u09C0\u09C7\u09C8\u09CB\u09CC\u09D7\u0A03\u0A3E-\u0A40\u0A83\u0ABE-\u0AC0\u0AC9\u0ACB\u0ACC\u0B02\u0B03\u0B3E\u0B40\u0B47\u0B48\u0B4B\u0B4C\u0B57\u0BBE\u0BBF\u0BC1\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCC\u0BD7\u0C01-\u0C03\u0C41-\u0C44\u0C82\u0C83\u0CBE\u0CC0-\u0CC4\u0CC7\u0CC8\u0CCA\u0CCB\u0CD5\u0CD6\u0D02\u0D03\u0D3E-\u0D40\u0D46-\u0D48\u0D4A-\u0D4C\u0D57\u0D82\u0D83\u0DCF-\u0DD1\u0DD8-\u0DDF\u0DF2\u0DF3\u0F3E\u0F3F\u0F7F\u102B\u102C\u1031\u1038\u103B\u103C\u1056\u1057\u1062-\u1064\u1067-\u106D\u1083\u1084\u1087-\u108C\u108F\u109A-\u109C\u17B6\u17BE-\u17C5\u17C7\u17C8\u1923-\u1926\u1929-\u192B\u1930\u1931\u1933-\u1938\u1A19\u1A1A\u1A55\u1A57\u1A61\u1A63\u1A64\u1A6D-\u1A72\u1B04\u1B35\u1B3B\u1B3D-\u1B41\u1B43\u1B44\u1B82\u1BA1\u1BA6\u1BA7\u1BAA\u1BE7\u1BEA-\u1BEC\u1BEE\u1BF2\u1BF3\u1C24-\u1C2B\u1C34\u1C35\u1CE1\u1CF7\u302E\u302F\uA823\uA824\uA827\uA880\uA881\uA8B4-\uA8C3\uA952\uA953\uA983\uA9B4\uA9B5\uA9BA\uA9BB\uA9BE-\uA9C0\uAA2F\uAA30\uAA33\uAA34\uAA4D\uAA7B\uAA7D\uAAEB\uAAEE\uAAEF\uAAF5\uABE3\uABE4\uABE6\uABE7\uABE9\uABEA\uABEC',
          'astral': '\uD804[\uDC00\uDC02\uDC82\uDCB0-\uDCB2\uDCB7\uDCB8\uDD2C\uDD45\uDD46\uDD82\uDDB3-\uDDB5\uDDBF\uDDC0\uDDCE\uDE2C-\uDE2E\uDE32\uDE33\uDE35\uDEE0-\uDEE2\uDF02\uDF03\uDF3E\uDF3F\uDF41-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63]|\uD805[\uDC35-\uDC37\uDC40\uDC41\uDC45\uDCB0-\uDCB2\uDCB9\uDCBB-\uDCBE\uDCC1\uDDAF-\uDDB1\uDDB8-\uDDBB\uDDBE\uDE30-\uDE32\uDE3B\uDE3C\uDE3E\uDEAC\uDEAE\uDEAF\uDEB6\uDF20\uDF21\uDF26]|\uD806[\uDC2C-\uDC2E\uDC38\uDD30-\uDD35\uDD37\uDD38\uDD3D\uDD40\uDD42\uDDD1-\uDDD3\uDDDC-\uDDDF\uDDE4\uDE39\uDE57\uDE58\uDE97]|\uD807[\uDC2F\uDC3E\uDCA9\uDCB1\uDCB4\uDD8A-\uDD8E\uDD93\uDD94\uDD96\uDEF5\uDEF6]|\uD81B[\uDF51-\uDF87\uDFF0\uDFF1]|\uD834[\uDD65\uDD66\uDD6D-\uDD72]'
      },
      {
          'name': 'Me',
          'alias': 'Enclosing_Mark',
          'bmp': '\u0488\u0489\u1ABE\u20DD-\u20E0\u20E2-\u20E4\uA670-\uA672'
      },
      {
          'name': 'Mn',
          'alias': 'Nonspacing_Mark',
          'bmp': '\u0300-\u036F\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0902\u093A\u093C\u0941-\u0948\u094D\u0951-\u0957\u0962\u0963\u0981\u09BC\u09C1-\u09C4\u09CD\u09E2\u09E3\u09FE\u0A01\u0A02\u0A3C\u0A41\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81\u0A82\u0ABC\u0AC1-\u0AC5\u0AC7\u0AC8\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01\u0B3C\u0B3F\u0B41-\u0B44\u0B4D\u0B55\u0B56\u0B62\u0B63\u0B82\u0BC0\u0BCD\u0C00\u0C04\u0C3E-\u0C40\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81\u0CBC\u0CBF\u0CC6\u0CCC\u0CCD\u0CE2\u0CE3\u0D00\u0D01\u0D3B\u0D3C\u0D41-\u0D44\u0D4D\u0D62\u0D63\u0D81\u0DCA\u0DD2-\u0DD4\u0DD6\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F71-\u0F7E\u0F80-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102D-\u1030\u1032-\u1037\u1039\u103A\u103D\u103E\u1058\u1059\u105E-\u1060\u1071-\u1074\u1082\u1085\u1086\u108D\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4\u17B5\u17B7-\u17BD\u17C6\u17C9-\u17D3\u17DD\u180B-\u180D\u1885\u1886\u18A9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193B\u1A17\u1A18\u1A1B\u1A56\u1A58-\u1A5E\u1A60\u1A62\u1A65-\u1A6C\u1A73-\u1A7C\u1A7F\u1AB0-\u1ABD\u1ABF\u1AC0\u1B00-\u1B03\u1B34\u1B36-\u1B3A\u1B3C\u1B42\u1B6B-\u1B73\u1B80\u1B81\u1BA2-\u1BA5\u1BA8\u1BA9\u1BAB-\u1BAD\u1BE6\u1BE8\u1BE9\u1BED\u1BEF-\u1BF1\u1C2C-\u1C33\u1C36\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE0\u1CE2-\u1CE8\u1CED\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302D\u3099\u309A\uA66F\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA825\uA826\uA82C\uA8C4\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA951\uA980-\uA982\uA9B3\uA9B6-\uA9B9\uA9BC\uA9BD\uA9E5\uAA29-\uAA2E\uAA31\uAA32\uAA35\uAA36\uAA43\uAA4C\uAA7C\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEC\uAAED\uAAF6\uABE5\uABE8\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F',
          'astral': '\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD803[\uDD24-\uDD27\uDEAB\uDEAC\uDF46-\uDF50]|\uD804[\uDC01\uDC38-\uDC46\uDC7F-\uDC81\uDCB3-\uDCB6\uDCB9\uDCBA\uDD00-\uDD02\uDD27-\uDD2B\uDD2D-\uDD34\uDD73\uDD80\uDD81\uDDB6-\uDDBE\uDDC9-\uDDCC\uDDCF\uDE2F-\uDE31\uDE34\uDE36\uDE37\uDE3E\uDEDF\uDEE3-\uDEEA\uDF00\uDF01\uDF3B\uDF3C\uDF40\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC38-\uDC3F\uDC42-\uDC44\uDC46\uDC5E\uDCB3-\uDCB8\uDCBA\uDCBF\uDCC0\uDCC2\uDCC3\uDDB2-\uDDB5\uDDBC\uDDBD\uDDBF\uDDC0\uDDDC\uDDDD\uDE33-\uDE3A\uDE3D\uDE3F\uDE40\uDEAB\uDEAD\uDEB0-\uDEB5\uDEB7\uDF1D-\uDF1F\uDF22-\uDF25\uDF27-\uDF2B]|\uD806[\uDC2F-\uDC37\uDC39\uDC3A\uDD3B\uDD3C\uDD3E\uDD43\uDDD4-\uDDD7\uDDDA\uDDDB\uDDE0\uDE01-\uDE0A\uDE33-\uDE38\uDE3B-\uDE3E\uDE47\uDE51-\uDE56\uDE59-\uDE5B\uDE8A-\uDE96\uDE98\uDE99]|\uD807[\uDC30-\uDC36\uDC38-\uDC3D\uDC3F\uDC92-\uDCA7\uDCAA-\uDCB0\uDCB2\uDCB3\uDCB5\uDCB6\uDD31-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD45\uDD47\uDD90\uDD91\uDD95\uDD97\uDEF3\uDEF4]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF4F\uDF8F-\uDF92\uDFE4]|\uD82F[\uDC9D\uDC9E]|\uD834[\uDD67-\uDD69\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDD30-\uDD36\uDEEC-\uDEEF]|\uD83A[\uDCD0-\uDCD6\uDD44-\uDD4A]|\uDB40[\uDD00-\uDDEF]'
      },
      {
          'name': 'N',
          'alias': 'Number',
          'bmp': '0-9\xB2\xB3\xB9\xBC-\xBE\u0660-\u0669\u06F0-\u06F9\u07C0-\u07C9\u0966-\u096F\u09E6-\u09EF\u09F4-\u09F9\u0A66-\u0A6F\u0AE6-\u0AEF\u0B66-\u0B6F\u0B72-\u0B77\u0BE6-\u0BF2\u0C66-\u0C6F\u0C78-\u0C7E\u0CE6-\u0CEF\u0D58-\u0D5E\u0D66-\u0D78\u0DE6-\u0DEF\u0E50-\u0E59\u0ED0-\u0ED9\u0F20-\u0F33\u1040-\u1049\u1090-\u1099\u1369-\u137C\u16EE-\u16F0\u17E0-\u17E9\u17F0-\u17F9\u1810-\u1819\u1946-\u194F\u19D0-\u19DA\u1A80-\u1A89\u1A90-\u1A99\u1B50-\u1B59\u1BB0-\u1BB9\u1C40-\u1C49\u1C50-\u1C59\u2070\u2074-\u2079\u2080-\u2089\u2150-\u2182\u2185-\u2189\u2460-\u249B\u24EA-\u24FF\u2776-\u2793\u2CFD\u3007\u3021-\u3029\u3038-\u303A\u3192-\u3195\u3220-\u3229\u3248-\u324F\u3251-\u325F\u3280-\u3289\u32B1-\u32BF\uA620-\uA629\uA6E6-\uA6EF\uA830-\uA835\uA8D0-\uA8D9\uA900-\uA909\uA9D0-\uA9D9\uA9F0-\uA9F9\uAA50-\uAA59\uABF0-\uABF9\uFF10-\uFF19',
          'astral': '\uD800[\uDD07-\uDD33\uDD40-\uDD78\uDD8A\uDD8B\uDEE1-\uDEFB\uDF20-\uDF23\uDF41\uDF4A\uDFD1-\uDFD5]|\uD801[\uDCA0-\uDCA9]|\uD802[\uDC58-\uDC5F\uDC79-\uDC7F\uDCA7-\uDCAF\uDCFB-\uDCFF\uDD16-\uDD1B\uDDBC\uDDBD\uDDC0-\uDDCF\uDDD2-\uDDFF\uDE40-\uDE48\uDE7D\uDE7E\uDE9D-\uDE9F\uDEEB-\uDEEF\uDF58-\uDF5F\uDF78-\uDF7F\uDFA9-\uDFAF]|\uD803[\uDCFA-\uDCFF\uDD30-\uDD39\uDE60-\uDE7E\uDF1D-\uDF26\uDF51-\uDF54\uDFC5-\uDFCB]|\uD804[\uDC52-\uDC6F\uDCF0-\uDCF9\uDD36-\uDD3F\uDDD0-\uDDD9\uDDE1-\uDDF4\uDEF0-\uDEF9]|\uD805[\uDC50-\uDC59\uDCD0-\uDCD9\uDE50-\uDE59\uDEC0-\uDEC9\uDF30-\uDF3B]|\uD806[\uDCE0-\uDCF2\uDD50-\uDD59]|\uD807[\uDC50-\uDC6C\uDD50-\uDD59\uDDA0-\uDDA9\uDFC0-\uDFD4]|\uD809[\uDC00-\uDC6E]|\uD81A[\uDE60-\uDE69\uDF50-\uDF59\uDF5B-\uDF61]|\uD81B[\uDE80-\uDE96]|\uD834[\uDEE0-\uDEF3\uDF60-\uDF78]|\uD835[\uDFCE-\uDFFF]|\uD838[\uDD40-\uDD49\uDEF0-\uDEF9]|\uD83A[\uDCC7-\uDCCF\uDD50-\uDD59]|\uD83B[\uDC71-\uDCAB\uDCAD-\uDCAF\uDCB1-\uDCB4\uDD01-\uDD2D\uDD2F-\uDD3D]|\uD83C[\uDD00-\uDD0C]|\uD83E[\uDFF0-\uDFF9]'
      },
      {
          'name': 'Nd',
          'alias': 'Decimal_Number',
          'bmp': '0-9\u0660-\u0669\u06F0-\u06F9\u07C0-\u07C9\u0966-\u096F\u09E6-\u09EF\u0A66-\u0A6F\u0AE6-\u0AEF\u0B66-\u0B6F\u0BE6-\u0BEF\u0C66-\u0C6F\u0CE6-\u0CEF\u0D66-\u0D6F\u0DE6-\u0DEF\u0E50-\u0E59\u0ED0-\u0ED9\u0F20-\u0F29\u1040-\u1049\u1090-\u1099\u17E0-\u17E9\u1810-\u1819\u1946-\u194F\u19D0-\u19D9\u1A80-\u1A89\u1A90-\u1A99\u1B50-\u1B59\u1BB0-\u1BB9\u1C40-\u1C49\u1C50-\u1C59\uA620-\uA629\uA8D0-\uA8D9\uA900-\uA909\uA9D0-\uA9D9\uA9F0-\uA9F9\uAA50-\uAA59\uABF0-\uABF9\uFF10-\uFF19',
          'astral': '\uD801[\uDCA0-\uDCA9]|\uD803[\uDD30-\uDD39]|\uD804[\uDC66-\uDC6F\uDCF0-\uDCF9\uDD36-\uDD3F\uDDD0-\uDDD9\uDEF0-\uDEF9]|\uD805[\uDC50-\uDC59\uDCD0-\uDCD9\uDE50-\uDE59\uDEC0-\uDEC9\uDF30-\uDF39]|\uD806[\uDCE0-\uDCE9\uDD50-\uDD59]|\uD807[\uDC50-\uDC59\uDD50-\uDD59\uDDA0-\uDDA9]|\uD81A[\uDE60-\uDE69\uDF50-\uDF59]|\uD835[\uDFCE-\uDFFF]|\uD838[\uDD40-\uDD49\uDEF0-\uDEF9]|\uD83A[\uDD50-\uDD59]|\uD83E[\uDFF0-\uDFF9]'
      },
      {
          'name': 'Nl',
          'alias': 'Letter_Number',
          'bmp': '\u16EE-\u16F0\u2160-\u2182\u2185-\u2188\u3007\u3021-\u3029\u3038-\u303A\uA6E6-\uA6EF',
          'astral': '\uD800[\uDD40-\uDD74\uDF41\uDF4A\uDFD1-\uDFD5]|\uD809[\uDC00-\uDC6E]'
      },
      {
          'name': 'No',
          'alias': 'Other_Number',
          'bmp': '\xB2\xB3\xB9\xBC-\xBE\u09F4-\u09F9\u0B72-\u0B77\u0BF0-\u0BF2\u0C78-\u0C7E\u0D58-\u0D5E\u0D70-\u0D78\u0F2A-\u0F33\u1369-\u137C\u17F0-\u17F9\u19DA\u2070\u2074-\u2079\u2080-\u2089\u2150-\u215F\u2189\u2460-\u249B\u24EA-\u24FF\u2776-\u2793\u2CFD\u3192-\u3195\u3220-\u3229\u3248-\u324F\u3251-\u325F\u3280-\u3289\u32B1-\u32BF\uA830-\uA835',
          'astral': '\uD800[\uDD07-\uDD33\uDD75-\uDD78\uDD8A\uDD8B\uDEE1-\uDEFB\uDF20-\uDF23]|\uD802[\uDC58-\uDC5F\uDC79-\uDC7F\uDCA7-\uDCAF\uDCFB-\uDCFF\uDD16-\uDD1B\uDDBC\uDDBD\uDDC0-\uDDCF\uDDD2-\uDDFF\uDE40-\uDE48\uDE7D\uDE7E\uDE9D-\uDE9F\uDEEB-\uDEEF\uDF58-\uDF5F\uDF78-\uDF7F\uDFA9-\uDFAF]|\uD803[\uDCFA-\uDCFF\uDE60-\uDE7E\uDF1D-\uDF26\uDF51-\uDF54\uDFC5-\uDFCB]|\uD804[\uDC52-\uDC65\uDDE1-\uDDF4]|\uD805[\uDF3A\uDF3B]|\uD806[\uDCEA-\uDCF2]|\uD807[\uDC5A-\uDC6C\uDFC0-\uDFD4]|\uD81A[\uDF5B-\uDF61]|\uD81B[\uDE80-\uDE96]|\uD834[\uDEE0-\uDEF3\uDF60-\uDF78]|\uD83A[\uDCC7-\uDCCF]|\uD83B[\uDC71-\uDCAB\uDCAD-\uDCAF\uDCB1-\uDCB4\uDD01-\uDD2D\uDD2F-\uDD3D]|\uD83C[\uDD00-\uDD0C]'
      },
      {
          'name': 'P',
          'alias': 'Punctuation',
          'bmp': '!-#%-\\*,-\\/:;\\?@\\[-\\]_\\{\\}\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65',
          'astral': '\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD803[\uDEAD\uDF55-\uDF59]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5A\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDF3C-\uDF3E]|\uD806[\uDC3B\uDD44-\uDD46\uDDE2\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2]|\uD807[\uDC41-\uDC45\uDC70\uDC71\uDEF7\uDEF8\uDFFF]|\uD809[\uDC70-\uDC74]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD81B[\uDE97-\uDE9A\uDFE2]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]'
      },
      {
          'name': 'Pc',
          'alias': 'Connector_Punctuation',
          'bmp': '_\u203F\u2040\u2054\uFE33\uFE34\uFE4D-\uFE4F\uFF3F'
      },
      {
          'name': 'Pd',
          'alias': 'Dash_Punctuation',
          'bmp': '\\-\u058A\u05BE\u1400\u1806\u2010-\u2015\u2E17\u2E1A\u2E3A\u2E3B\u2E40\u301C\u3030\u30A0\uFE31\uFE32\uFE58\uFE63\uFF0D',
          'astral': '\uD803\uDEAD'
      },
      {
          'name': 'Pe',
          'alias': 'Close_Punctuation',
          'bmp': '\\)\\]\\}\u0F3B\u0F3D\u169C\u2046\u207E\u208E\u2309\u230B\u232A\u2769\u276B\u276D\u276F\u2771\u2773\u2775\u27C6\u27E7\u27E9\u27EB\u27ED\u27EF\u2984\u2986\u2988\u298A\u298C\u298E\u2990\u2992\u2994\u2996\u2998\u29D9\u29DB\u29FD\u2E23\u2E25\u2E27\u2E29\u3009\u300B\u300D\u300F\u3011\u3015\u3017\u3019\u301B\u301E\u301F\uFD3E\uFE18\uFE36\uFE38\uFE3A\uFE3C\uFE3E\uFE40\uFE42\uFE44\uFE48\uFE5A\uFE5C\uFE5E\uFF09\uFF3D\uFF5D\uFF60\uFF63'
      },
      {
          'name': 'Pf',
          'alias': 'Final_Punctuation',
          'bmp': '\xBB\u2019\u201D\u203A\u2E03\u2E05\u2E0A\u2E0D\u2E1D\u2E21'
      },
      {
          'name': 'Pi',
          'alias': 'Initial_Punctuation',
          'bmp': '\xAB\u2018\u201B\u201C\u201F\u2039\u2E02\u2E04\u2E09\u2E0C\u2E1C\u2E20'
      },
      {
          'name': 'Po',
          'alias': 'Other_Punctuation',
          'bmp': '!-#%-\'\\*,\\.\\/:;\\?@\\\xA1\xA7\xB6\xB7\xBF\u037E\u0387\u055A-\u055F\u0589\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u166E\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u1805\u1807-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2016\u2017\u2020-\u2027\u2030-\u2038\u203B-\u203E\u2041-\u2043\u2047-\u2051\u2053\u2055-\u205E\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00\u2E01\u2E06-\u2E08\u2E0B\u2E0E-\u2E16\u2E18\u2E19\u2E1B\u2E1E\u2E1F\u2E2A-\u2E2E\u2E30-\u2E39\u2E3C-\u2E3F\u2E41\u2E43-\u2E4F\u2E52\u3001-\u3003\u303D\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFE10-\uFE16\uFE19\uFE30\uFE45\uFE46\uFE49-\uFE4C\uFE50-\uFE52\uFE54-\uFE57\uFE5F-\uFE61\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF07\uFF0A\uFF0C\uFF0E\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3C\uFF61\uFF64\uFF65',
          'astral': '\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD803[\uDF55-\uDF59]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5A\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDF3C-\uDF3E]|\uD806[\uDC3B\uDD44-\uDD46\uDDE2\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2]|\uD807[\uDC41-\uDC45\uDC70\uDC71\uDEF7\uDEF8\uDFFF]|\uD809[\uDC70-\uDC74]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD81B[\uDE97-\uDE9A\uDFE2]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]'
      },
      {
          'name': 'Ps',
          'alias': 'Open_Punctuation',
          'bmp': '\\(\\[\\{\u0F3A\u0F3C\u169B\u201A\u201E\u2045\u207D\u208D\u2308\u230A\u2329\u2768\u276A\u276C\u276E\u2770\u2772\u2774\u27C5\u27E6\u27E8\u27EA\u27EC\u27EE\u2983\u2985\u2987\u2989\u298B\u298D\u298F\u2991\u2993\u2995\u2997\u29D8\u29DA\u29FC\u2E22\u2E24\u2E26\u2E28\u2E42\u3008\u300A\u300C\u300E\u3010\u3014\u3016\u3018\u301A\u301D\uFD3F\uFE17\uFE35\uFE37\uFE39\uFE3B\uFE3D\uFE3F\uFE41\uFE43\uFE47\uFE59\uFE5B\uFE5D\uFF08\uFF3B\uFF5B\uFF5F\uFF62'
      },
      {
          'name': 'S',
          'alias': 'Symbol',
          'bmp': '\\$\\+<->\\^`\\|~\xA2-\xA6\xA8\xA9\xAC\xAE-\xB1\xB4\xB8\xD7\xF7\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0384\u0385\u03F6\u0482\u058D-\u058F\u0606-\u0608\u060B\u060E\u060F\u06DE\u06E9\u06FD\u06FE\u07F6\u07FE\u07FF\u09F2\u09F3\u09FA\u09FB\u0AF1\u0B70\u0BF3-\u0BFA\u0C7F\u0D4F\u0D79\u0E3F\u0F01-\u0F03\u0F13\u0F15-\u0F17\u0F1A-\u0F1F\u0F34\u0F36\u0F38\u0FBE-\u0FC5\u0FC7-\u0FCC\u0FCE\u0FCF\u0FD5-\u0FD8\u109E\u109F\u1390-\u1399\u166D\u17DB\u1940\u19DE-\u19FF\u1B61-\u1B6A\u1B74-\u1B7C\u1FBD\u1FBF-\u1FC1\u1FCD-\u1FCF\u1FDD-\u1FDF\u1FED-\u1FEF\u1FFD\u1FFE\u2044\u2052\u207A-\u207C\u208A-\u208C\u20A0-\u20BF\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u2140-\u2144\u214A-\u214D\u214F\u218A\u218B\u2190-\u2307\u230C-\u2328\u232B-\u2426\u2440-\u244A\u249C-\u24E9\u2500-\u2767\u2794-\u27C4\u27C7-\u27E5\u27F0-\u2982\u2999-\u29D7\u29DC-\u29FB\u29FE-\u2B73\u2B76-\u2B95\u2B97-\u2BFF\u2CE5-\u2CEA\u2E50\u2E51\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFB\u3004\u3012\u3013\u3020\u3036\u3037\u303E\u303F\u309B\u309C\u3190\u3191\u3196-\u319F\u31C0-\u31E3\u3200-\u321E\u322A-\u3247\u3250\u3260-\u327F\u328A-\u32B0\u32C0-\u33FF\u4DC0-\u4DFF\uA490-\uA4C6\uA700-\uA716\uA720\uA721\uA789\uA78A\uA828-\uA82B\uA836-\uA839\uAA77-\uAA79\uAB5B\uAB6A\uAB6B\uFB29\uFBB2-\uFBC1\uFDFC\uFDFD\uFE62\uFE64-\uFE66\uFE69\uFF04\uFF0B\uFF1C-\uFF1E\uFF3E\uFF40\uFF5C\uFF5E\uFFE0-\uFFE6\uFFE8-\uFFEE\uFFFC\uFFFD',
          'astral': '\uD800[\uDD37-\uDD3F\uDD79-\uDD89\uDD8C-\uDD8E\uDD90-\uDD9C\uDDA0\uDDD0-\uDDFC]|\uD802[\uDC77\uDC78\uDEC8]|\uD805\uDF3F|\uD807[\uDFD5-\uDFF1]|\uD81A[\uDF3C-\uDF3F\uDF45]|\uD82F\uDC9C|\uD834[\uDC00-\uDCF5\uDD00-\uDD26\uDD29-\uDD64\uDD6A-\uDD6C\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDDE8\uDE00-\uDE41\uDE45\uDF00-\uDF56]|\uD835[\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85\uDE86]|\uD838[\uDD4F\uDEFF]|\uD83B[\uDCAC\uDCB0\uDD2E\uDEF0\uDEF1]|\uD83C[\uDC00-\uDC2B\uDC30-\uDC93\uDCA0-\uDCAE\uDCB1-\uDCBF\uDCC1-\uDCCF\uDCD1-\uDCF5\uDD0D-\uDDAD\uDDE6-\uDE02\uDE10-\uDE3B\uDE40-\uDE48\uDE50\uDE51\uDE60-\uDE65\uDF00-\uDFFF]|\uD83D[\uDC00-\uDED7\uDEE0-\uDEEC\uDEF0-\uDEFC\uDF00-\uDF73\uDF80-\uDFD8\uDFE0-\uDFEB]|\uD83E[\uDC00-\uDC0B\uDC10-\uDC47\uDC50-\uDC59\uDC60-\uDC87\uDC90-\uDCAD\uDCB0\uDCB1\uDD00-\uDD78\uDD7A-\uDDCB\uDDCD-\uDE53\uDE60-\uDE6D\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6\uDF00-\uDF92\uDF94-\uDFCA]'
      },
      {
          'name': 'Sc',
          'alias': 'Currency_Symbol',
          'bmp': '\\$\xA2-\xA5\u058F\u060B\u07FE\u07FF\u09F2\u09F3\u09FB\u0AF1\u0BF9\u0E3F\u17DB\u20A0-\u20BF\uA838\uFDFC\uFE69\uFF04\uFFE0\uFFE1\uFFE5\uFFE6',
          'astral': '\uD807[\uDFDD-\uDFE0]|\uD838\uDEFF|\uD83B\uDCB0'
      },
      {
          'name': 'Sk',
          'alias': 'Modifier_Symbol',
          'bmp': '\\^`\xA8\xAF\xB4\xB8\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0384\u0385\u1FBD\u1FBF-\u1FC1\u1FCD-\u1FCF\u1FDD-\u1FDF\u1FED-\u1FEF\u1FFD\u1FFE\u309B\u309C\uA700-\uA716\uA720\uA721\uA789\uA78A\uAB5B\uAB6A\uAB6B\uFBB2-\uFBC1\uFF3E\uFF40\uFFE3',
          'astral': '\uD83C[\uDFFB-\uDFFF]'
      },
      {
          'name': 'Sm',
          'alias': 'Math_Symbol',
          'bmp': '\\+<->\\|~\xAC\xB1\xD7\xF7\u03F6\u0606-\u0608\u2044\u2052\u207A-\u207C\u208A-\u208C\u2118\u2140-\u2144\u214B\u2190-\u2194\u219A\u219B\u21A0\u21A3\u21A6\u21AE\u21CE\u21CF\u21D2\u21D4\u21F4-\u22FF\u2320\u2321\u237C\u239B-\u23B3\u23DC-\u23E1\u25B7\u25C1\u25F8-\u25FF\u266F\u27C0-\u27C4\u27C7-\u27E5\u27F0-\u27FF\u2900-\u2982\u2999-\u29D7\u29DC-\u29FB\u29FE-\u2AFF\u2B30-\u2B44\u2B47-\u2B4C\uFB29\uFE62\uFE64-\uFE66\uFF0B\uFF1C-\uFF1E\uFF5C\uFF5E\uFFE2\uFFE9-\uFFEC',
          'astral': '\uD835[\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3]|\uD83B[\uDEF0\uDEF1]'
      },
      {
          'name': 'So',
          'alias': 'Other_Symbol',
          'bmp': '\xA6\xA9\xAE\xB0\u0482\u058D\u058E\u060E\u060F\u06DE\u06E9\u06FD\u06FE\u07F6\u09FA\u0B70\u0BF3-\u0BF8\u0BFA\u0C7F\u0D4F\u0D79\u0F01-\u0F03\u0F13\u0F15-\u0F17\u0F1A-\u0F1F\u0F34\u0F36\u0F38\u0FBE-\u0FC5\u0FC7-\u0FCC\u0FCE\u0FCF\u0FD5-\u0FD8\u109E\u109F\u1390-\u1399\u166D\u1940\u19DE-\u19FF\u1B61-\u1B6A\u1B74-\u1B7C\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116\u2117\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u214A\u214C\u214D\u214F\u218A\u218B\u2195-\u2199\u219C-\u219F\u21A1\u21A2\u21A4\u21A5\u21A7-\u21AD\u21AF-\u21CD\u21D0\u21D1\u21D3\u21D5-\u21F3\u2300-\u2307\u230C-\u231F\u2322-\u2328\u232B-\u237B\u237D-\u239A\u23B4-\u23DB\u23E2-\u2426\u2440-\u244A\u249C-\u24E9\u2500-\u25B6\u25B8-\u25C0\u25C2-\u25F7\u2600-\u266E\u2670-\u2767\u2794-\u27BF\u2800-\u28FF\u2B00-\u2B2F\u2B45\u2B46\u2B4D-\u2B73\u2B76-\u2B95\u2B97-\u2BFF\u2CE5-\u2CEA\u2E50\u2E51\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFB\u3004\u3012\u3013\u3020\u3036\u3037\u303E\u303F\u3190\u3191\u3196-\u319F\u31C0-\u31E3\u3200-\u321E\u322A-\u3247\u3250\u3260-\u327F\u328A-\u32B0\u32C0-\u33FF\u4DC0-\u4DFF\uA490-\uA4C6\uA828-\uA82B\uA836\uA837\uA839\uAA77-\uAA79\uFDFD\uFFE4\uFFE8\uFFED\uFFEE\uFFFC\uFFFD',
          'astral': '\uD800[\uDD37-\uDD3F\uDD79-\uDD89\uDD8C-\uDD8E\uDD90-\uDD9C\uDDA0\uDDD0-\uDDFC]|\uD802[\uDC77\uDC78\uDEC8]|\uD805\uDF3F|\uD807[\uDFD5-\uDFDC\uDFE1-\uDFF1]|\uD81A[\uDF3C-\uDF3F\uDF45]|\uD82F\uDC9C|\uD834[\uDC00-\uDCF5\uDD00-\uDD26\uDD29-\uDD64\uDD6A-\uDD6C\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDDE8\uDE00-\uDE41\uDE45\uDF00-\uDF56]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85\uDE86]|\uD838\uDD4F|\uD83B[\uDCAC\uDD2E]|\uD83C[\uDC00-\uDC2B\uDC30-\uDC93\uDCA0-\uDCAE\uDCB1-\uDCBF\uDCC1-\uDCCF\uDCD1-\uDCF5\uDD0D-\uDDAD\uDDE6-\uDE02\uDE10-\uDE3B\uDE40-\uDE48\uDE50\uDE51\uDE60-\uDE65\uDF00-\uDFFA]|\uD83D[\uDC00-\uDED7\uDEE0-\uDEEC\uDEF0-\uDEFC\uDF00-\uDF73\uDF80-\uDFD8\uDFE0-\uDFEB]|\uD83E[\uDC00-\uDC0B\uDC10-\uDC47\uDC50-\uDC59\uDC60-\uDC87\uDC90-\uDCAD\uDCB0\uDCB1\uDD00-\uDD78\uDD7A-\uDDCB\uDDCD-\uDE53\uDE60-\uDE6D\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6\uDF00-\uDF92\uDF94-\uDFCA]'
      },
      {
          'name': 'Z',
          'alias': 'Separator',
          'bmp': ' \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000'
      },
      {
          'name': 'Zl',
          'alias': 'Line_Separator',
          'bmp': '\u2028'
      },
      {
          'name': 'Zp',
          'alias': 'Paragraph_Separator',
          'bmp': '\u2029'
      },
      {
          'name': 'Zs',
          'alias': 'Space_Separator',
          'bmp': ' \xA0\u1680\u2000-\u200A\u202F\u205F\u3000'
      }
  ];

  var jabref = createCommonjsModule(function (module, exports) {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.parse = void 0;
  function decode(s, sep = ';') {
      s = s.replace(/\n/g, '');
      let pos = 0;
      const records = [''];
      while (pos < s.length) {
          switch (s[pos]) {
              case '\\':
                  pos++;
                  records[0] += s[pos];
                  break;
              case sep:
                  records.unshift('');
                  break;
              default:
                  records[0] += s[pos];
          }
          pos++;
      }
      return records.reverse().filter(record => record);
  }
  const prefixes = {
      fileDirectory: 'jabref-meta: fileDirectory:',
      groupsversion: 'jabref-meta: groupsversion:',
      groupstree: 'jabref-meta: groupstree:',
      grouping: 'jabref-meta: grouping:',
  };
  /**
   * Import the JabRef groups from the `@string` comments in which they were stored. You would typically pass the comments parsed by [[bibtex.parse]] in here.
   *
   * JabRef knows several group types, and this parser parses most, but not all of them:
   *
   * * independent group: the keys listed in the group are the entries that are considered to belong to it
   * * intersection: the keys listed in the group are considered to belong to the group if they're also in the parent group
   * * union: the keys listed in the group are considered to belong to the group, and also the keys that are in the parent group
   * * query: not supported by this parser
   */
  function parse(comments) {
      const result = {
          root: [],
          groups: {},
          fileDirectory: '',
          version: '',
      };
      const levels = [];
      const decoded = {
          fileDirectory: null,
          groupsversion: null,
          groupstree: null,
          grouping: null,
      };
      for (const comment of comments) {
          for (const [meta, prefix] of Object.entries(prefixes)) {
              if (comment.startsWith(prefix)) {
                  decoded[meta] = decode(comment.substring(prefix.length));
              }
          }
      }
      result.version = decoded.groupsversion && decoded.groupsversion[0];
      result.fileDirectory = decoded.fileDirectory && decoded.fileDirectory[0];
      for (const tree of ['groupstree', 'grouping']) {
          if (!decoded[tree])
              continue;
          for (const encoded of decoded[tree]) {
              const fields = decode(encoded);
              const level_type_name = decode(fields.shift(), ':');
              const m = /^([0-9]+) (.+)/.exec(level_type_name[0]);
              if (!m)
                  break;
              const level = parseInt(m[1]);
              const type = m[2]; // test for StaticGroup?
              if (type === 'AllEntriesGroup')
                  continue; // root
              const name = level_type_name[1];
              const intersection = decode(fields.shift())[0];
              const keys = tree === 'grouping' ? [] : fields.map(field => decode(field)[0]);
              const group = {
                  name,
                  entries: keys,
                  groups: [],
              };
              result.groups[name] = result.groups[name] || group;
              if (levels.length < level) {
                  levels.push(group);
              }
              else {
                  levels[level - 1] = group;
              }
              if (level === 1) {
                  result.root.push(group);
              }
              else {
                  const parent = levels[level - 2];
                  switch (intersection) {
                      case '0': // independent
                          break;
                      case '1': // intersect
                          group.entries = group.entries.filter(key => parent.entries.includes(key));
                          break;
                      case '2': // union
                          group.entries = group.entries.concat(parent.entries.filter(key => !group.entries.includes(key)));
                          break;
                  }
                  levels[level - 2].groups.push(group);
              }
          }
      }
      return result;
  }
  exports.parse = parse;

  });

  var bibtexParser = createCommonjsModule(function (module, exports) {
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.jabref = exports.chunker = exports.ast = exports.parse = void 0;



  class ParserError extends Error {
      constructor(message, node) {
          super(message); // 'Error' breaks prototype chain here
          Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
          this.name = this.constructor.name;
          this.node = node;
      }
  }
  class TeXError extends Error {
      constructor(message, node, text) {
          super(message); // 'Error' breaks prototype chain here
          Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
          this.name = this.constructor.name;
          this.node = node;
          this.text = text;
      }
  }

  const charClass = {
      Lu: categories.filter(cat => ['Uppercase_Letter', 'Titlecase_Letter'].includes(cat.alias)).map(cat => cat.bmp).join(''),
      Ll: categories.find(cat => cat.alias === 'Lowercase_Letter').bmp,
      LnotLu: categories.filter(cat => ['Lowercase_Letter', 'Modifier_Letter', 'Other_Letter', 'Nonspacing_Mark', 'Spacing_Mark', 'Decimal_Number', 'Letter_Number'].includes(cat.alias)).map(cat => cat.bmp).join(''),
      P: categories.find(cat => cat.alias === 'Punctuation').bmp,
      L: categories.find(cat => cat.alias === 'Letter').bmp,
      N: categories.filter(cat => ['Decimal_Number', 'Letter_Number'].includes(cat.alias)).map(cat => cat.bmp).join(''),
      AlphaNum: categories.filter(cat => ['Letter', 'Decimal_Number', 'Letter_Number'].includes(cat.alias)).map(cat => cat.bmp).join(''),
      LC: categories.find(cat => cat.alias === 'Cased_Letter').bmp,
  };
  const marker = {
      and: '\u0001',
      comma: '\u0002',
      space: '\u0003',
      literal: '\u0004',
      markup: '\u0005',
      re: {
          and: /./,
          comma: /./,
          space: /./,
          literal: /./,
          literalName: /./,
      },
      clean(s) {
          return s.replace(marker.re.space, ' ').replace(marker.re.comma, ', ').replace(marker.re.literal, '');
      },
  };
  marker.re = {
      and: new RegExp(marker.and, 'g'),
      comma: new RegExp(marker.comma, 'g'),
      space: new RegExp(marker.space, 'g'),
      literal: new RegExp(marker.literal, 'g'),
      literalName: new RegExp(`^${marker.literal}([^${marker.literal}]*)${marker.literal}$`),
  };
  const preserveCase = {
      leadingCap: new RegExp(`^[${charClass.Lu}][${charClass.LnotLu}]+[${charClass.P}]?$`),
      allCaps: new RegExp(`^[${charClass.Lu}${charClass.N}]{2,}$`),
      allLower: new RegExp(`^[${charClass.Ll}${charClass.N}]{2,}$`),
      joined: new RegExp(`^[${charClass.Lu}][${charClass.LnotLu}]*([-+][${charClass.L}${charClass.N}]+)*[${charClass.P}]*$`),
      hasUpper: new RegExp(`[${charClass.Lu}]`),
      hasLower: new RegExp(`[${charClass.Ll}]`),
      isNumber: /^[0-9]+$/,
      hasAlpha: new RegExp(`[${charClass.L}]`),
      hasAlphaNum: new RegExp(`[${charClass.AlphaNum}]`),
      notAlphaNum: new RegExp(`[^${charClass.AlphaNum}]`, 'g'),
      sentenceStart: new RegExp(`(^|([\u2014:?!.]\\s+))[${charClass.Lu}]`, 'g'),
      markup: /<\/?span[^>]*>/g,
      acronym: new RegExp(`.*\\.${marker.markup}*[${charClass.Lu}]${marker.markup}*\\.$`),
      notCaseSensitive: new RegExp(`[^${charClass.LC}]`),
      isCaseSensitive: new RegExp(`[${charClass.LC}]`),
      quoted: /("[^"]+")|(“[^“]+“)/g,
  };
  const fields = {
      creator: [
          'author',
          'bookauthor',
          'collaborator',
          'commentator',
          'director',
          'editor',
          'editora',
          'editorb',
          'editors',
          'holder',
          'scriptwriter',
          'translator',
      ],
      title: [
          'title',
          'series',
          'shorttitle',
          'booktitle',
          'type',
          'origtitle',
          'maintitle',
          'eventtitle',
      ],
      unnest: [
          'publisher',
          'location',
      ],
      verbatim: [
          'url',
          'doi',
          'file',
          'files',
          'eprint',
          'verba',
          'verbb',
          'verbc',
          'groups',
      ],
      html: [
          'annotation',
          'comment',
          'annote',
          'review',
          'notes',
          'note',
      ],
      unabbrev: [
          'journal',
          'journaltitle',
          'journal-full',
      ],
  };
  const english = [
      'american',
      'british',
      'canadian',
      'english',
      'australian',
      'newzealand',
      'usenglish',
      'ukenglish',
      'en',
      'eng',
      'en-au',
      'en-bz',
      'en-ca',
      'en-cb',
      'en-gb',
      'en-ie',
      'en-jm',
      'en-nz',
      'en-ph',
      'en-tt',
      'en-us',
      'en-za',
      'en-zw',
      'anglais',
  ];
  class Parser {
      constructor(options = {}) {
          this.in_preamble = false;
          this.preamble = [];
          this.log = function (str) { }; // tslint:disable-line variable-name only-arrow-functions no-empty
          for (const [option, value] of Object.entries(options)) {
              if (typeof value === 'undefined')
                  delete options[option];
          }
          if (options.errorHandler === false) {
              // tslint:disable-next-line only-arrow-functions no-empty
              options.errorHandler = function (err) { };
          }
          else if (options.errorHandler === undefined) {
              // tslint:disable-next-line only-arrow-functions
              options.errorHandler = function (err) { throw err; };
          }
          if (typeof options.sentenceCase === 'boolean') {
              options.sentenceCase = options.sentenceCase ? english : [];
          }
          else {
              options.sentenceCase = options.sentenceCase || english;
          }
          if (!options.strings)
              options.strings = {};
          if (!options.unabbreviate)
              options.unabbreviate = {};
          if (options.raw) {
              options.sentenceCase = false;
              options.caseProtection = false;
          }
          this.options = Object.assign({ caseProtection: 'as-needed', verbatimFields: [/^citeulike-linkout-[0-9]+$/, ...fields.verbatim], verbatimCommands: ['url', 'href'], unnestFields: [...fields.title, ...fields.unnest, ...fields.verbatim], unnestMode: 'unwrap', htmlFields: fields.html, guessAlreadySentenceCased: true, markup: {} }, options);
          const markup_defaults = {
              enquote: { open: '\u201c', close: '\u201d' },
              sub: { open: '<sub>', close: '</sub>' },
              sup: { open: '<sup>', close: '</sup>' },
              bold: { open: '<b>', close: '</b>' },
              italics: { open: '<i>', close: '</i>' },
              smallCaps: { open: '<span style="font-variant:small-caps;">', close: '</span>' },
              caseProtect: { open: '<span class="nocase">', close: '</span>' },
              roman: { open: '', close: '' },
              fixedWidth: { open: '', close: '' },
          };
          // patch in because the options will likely not have enquote and case-protect
          for (const [markup, { open, close }] of Object.entries(markup_defaults)) {
              this.options.markup[markup] = this.options.markup[markup] || { open, close };
          }
          for (const i of [1, 2, 3, 4]) { // tslint:disable-line:no-magic-numbers
              this.options.markup[`h${i}`] = this.options.markup[`h${i}`] || { open: `<h${i}>`, close: `</h${i}>` };
          }
          this.unresolvedStrings = {};
          this.errors = [];
          this.comments = [];
          this.entries = [];
          this.strings = {};
          this.newcommands = {};
          this.default_strings = {
              JAN: [this.text('01')],
              FEB: [this.text('02')],
              MAR: [this.text('03')],
              APR: [this.text('04')],
              MAY: [this.text('05')],
              JUN: [this.text('06')],
              JUL: [this.text('07')],
              AUG: [this.text('08')],
              SEP: [this.text('09')],
              OCT: [this.text('10')],
              NOV: [this.text('11')],
              DEC: [this.text('12')],
              ACMCS: [this.text('ACM Computing Surveys')],
              ACTA: [this.text('Acta Informatica')],
              CACM: [this.text('Communications of the ACM')],
              IBMJRD: [this.text('IBM Journal of Research and Development')],
              IBMSJ: [this.text('IBM Systems Journal')],
              IEEESE: [this.text('IEEE Transactions on Software Engineering')],
              IEEETC: [this.text('IEEE Transactions on Computers')],
              IEEETCAD: [this.text('IEEE Transactions on Computer-Aided Design of Integrated Circuits')],
              IPL: [this.text('Information Processing Letters')],
              JACM: [this.text('Journal of the ACM')],
              JCSS: [this.text('Journal of Computer and System Sciences')],
              SCP: [this.text('Science of Computer Programming')],
              SICOMP: [this.text('SIAM Journal on Computing')],
              TOCS: [this.text('ACM Transactions on Computer Systems')],
              TODS: [this.text('ACM Transactions on Database Systems')],
              TOG: [this.text('ACM Transactions on Graphics')],
              TOMS: [this.text('ACM Transactions on Mathematical Software')],
              TOOIS: [this.text('ACM Transactions on Office Information Systems')],
              TOPLAS: [this.text('ACM Transactions on Programming Languages and Systems')],
              TCS: [this.text('Theoretical Computer Science')],
          };
      }
      ast(input, clean = true) {
          const _ast = [];
          for (const chunk of chunker.parse(input)) {
              let chunk_ast = grammar.parse(chunk.text, Object.assign(Object.assign({}, this.options), { combiningDiacritics: unicode2latex.diacritics.commands }));
              if (clean)
                  chunk_ast = this.clean(chunk_ast);
              _ast.push(chunk_ast);
          }
          return _ast;
      }
      parse(input) {
          return this.options.async ? this.parseAsync(input) : this.parseSync(input);
      }
      parseSync(input) {
          for (const chunk of chunker.parse(input)) {
              this.parseChunk(chunk);
          }
          return this.parsed();
      }
      async parseAsync(input) {
          for (const chunk of await chunker.parse(input, { async: true })) {
              this.parseChunk(chunk);
          }
          return this.parsed();
      }
      parsed() {
          this.field = null;
          const strings = {};
          this.cleaning = { type: 'other' };
          for (const [key, value] of Object.entries(this.strings)) {
              this.field = {
                  name: '@string',
                  text: '',
                  level: 0,
                  preserveRanges: null,
                  words: {
                      upper: 0,
                      lower: 0,
                      other: 0,
                  },
              };
              this.convert(this.clean(value));
              strings[key] = this.field.text;
          }
          return {
              errors: this.errors,
              entries: this.entries,
              comments: this.comments,
              strings,
              preamble: this.preamble,
          };
      }
      preserve(start, end, reason) {
          if (!this.field.preserveRanges)
              return;
          if (!end) {
              this.field.preserveRanges = null;
              return;
          }
          /*
          this.field.preserveRanges = this.field.preserveRanges.filter(range => range.start < start || range.end > end)
          if (this.field.preserveRanges.find(range => range.start <= start && range.end >= end)) return
          */
          /*
          if (this.field.preserveRanges && this.field.preserveRanges.length) {
            const last = this.field.preserveRanges[this.field.preserveRanges.length - 1]
            if (start < last.start) throw new Error(JSON.stringify({...last, new: { start, end, reason }, text: this.field.text}))
          }
          */
          this.field.preserveRanges.push({ start, end, reason });
      }
      parseChunk(chunk) {
          this.chunk = chunk.text;
          try {
              let bib = grammar.parse(chunk.text, Object.assign(Object.assign({}, this.options), { combiningDiacritics: unicode2latex.diacritics.commands }));
              if (bib.kind !== 'Bibliography')
                  throw new Error(this.show(bib));
              bib = this.clean(bib);
              for (const entity of bib.children) {
                  switch (entity.kind) {
                      case 'Entry':
                      case 'BracedComment':
                      case 'LineComment':
                      case 'PreambleExpression':
                          this.convert(entity);
                          break;
                      case 'StringDeclaration':
                      case 'NonEntryText':
                          break;
                  }
              }
              return bib;
          }
          catch (err) {
              if (!err.location)
                  throw err;
              this.errors.push({
                  message: err.message,
                  line: err.location.start.line + chunk.offset.line,
                  column: err.location.start.column,
                  source: this.chunk,
              });
              return null;
          }
      }
      show(o) {
          // tslint:disable-next-line prefer-template
          let text = JSON.stringify(o);
          if (this.chunk)
              text += '\n' + this.chunk.trim();
          return text;
      }
      text(value = '') {
          return { kind: 'Text', value, mode: 'text' };
      }
      error(err, returnvalue) {
          if (typeof this.options.errorHandler === 'function')
              this.options.errorHandler(err);
          return returnvalue;
      }
      condense(node) {
          // apply cleaning to resulting children
          node.value = node.value.map(child => this.clean(child));
          // unpack redundant blocks
          node.value = node.value.reduce((acc, child, i) => {
              if (child.kind === 'Block' && !child.case && Object.keys(child.markup).length === 0) {
                  acc = acc.concat(child.value);
              }
              else {
                  acc.push(child);
              }
              return acc;
          }, []);
          // condense text nodes to make whole words for sentence casing
          node.value = node.value.reduce((acc, child, i) => {
              if (acc.length === 0) {
                  acc.push(child);
                  return acc;
              }
              const last = acc[acc.length - 1];
              const next = node.value[i + 1];
              if (this.options.caseProtection === 'strict' && this.onlyCaseProtected(last) && child.kind === 'Text' && !child.value.match(preserveCase.isCaseSensitive) && this.onlyCaseProtected(next)) {
                  last.value.push(child);
                  delete last.source;
                  return acc;
              }
              if (last.kind === 'Block' && child.kind === 'Block' && Object.keys(last.markup).sort().join('/') === Object.keys(child.markup).sort().join('/')) {
                  last.value = last.value.concat(child.value);
                  delete last.source;
                  return acc;
              }
              if (last.kind === 'Text' && child.kind === 'Text' && last.mode === child.mode) {
                  last.value += child.value;
                  delete last.source;
                  return acc;
              }
              acc.push(child);
              return acc;
          }, []);
      }
      onlyCaseProtected(node) {
          return (node === null || node === void 0 ? void 0 : node.kind) === 'Block' && node.case === 'protect' && Object.keys(node.markup).join('/') === '';
      }
      argument(node, kind) {
          if (!node.arguments || !node.arguments.required.length)
              return (kind === 'none');
          // expect 'n' text arguments
          if (typeof kind === 'number') {
              if (node.arguments.required.length !== kind)
                  return false;
              return node.arguments.required;
          }
          // return first argument if it's the only one
          if (node.arguments.required.length !== 1)
              return false;
          // loose checking for text
          if (kind === 'text') {
              const first = node.arguments.required[0];
              if (first.kind === 'Block' && first.value.length === 1) {
                  if (first.value[0].kind === 'Text')
                      return first.value[0].value;
              }
              // fall back to strict kind check
              kind = 'Text';
          }
          // return first argument if it's the only one and is of the specified kind
          if (node.arguments.required.length !== 1 || node.arguments.required[0].kind !== kind)
              return false;
          switch (kind) {
              case 'Text':
                  return node.arguments.required[0].value;
              case 'RegularCommand':
              case 'Block':
                  return node.arguments.required[0];
          }
          return false;
      }
      clean(node) {
          if (Array.isArray(node))
              return node.map(child => this.clean(child));
          delete node.loc;
          switch (node.kind) {
              case 'InlineMath':
              case 'DisplayMath':
                  return this.clean_block(node);
              case 'Environment':
                  return this.clean_environment(node);
              case 'Block':
                  return this.clean_block(node);
              case 'Bibliography':
                  return this.clean_bib(node);
              case 'RegularCommand':
                  return this.clean_command(node);
              case 'DiacriticCommand':
                  return this.clean_diacritic(node);
              case 'Entry':
                  return this.clean_entry(node);
              case 'Field':
                  return this.options.raw ? node : this.clean_field(node);
              case 'StringDeclaration':
                  return this.clean_stringdecl(node);
              case 'StringReference':
                  return this.clean_stringref(node);
              case 'SubscriptCommand':
              case 'SuperscriptCommand':
                  return this.clean_script(node);
              case 'SymbolCommand':
                  return this.clean_symbol(node);
              case 'PreambleExpression':
                  return this.clean_preamble(node);
              case 'Number':
              case 'Text':
              case 'BracedComment':
              case 'LineComment':
                  return node;
              default:
                  return this.error(new ParserError(`no cleanup method for ${this.show(node)}`, node), this.text());
          }
      }
      clean_preamble(node) {
          this.in_preamble = true;
          const clean = this.clean(node.value);
          this.in_preamble = false;
          return clean;
      }
      clean_bib(node) {
          node.children = node.children.filter(child => child.kind !== 'NonEntryText').map(child => this.clean(child));
          return node;
      }
      clean_stringdecl(node) {
          this.strings[node.name.toUpperCase()] = node.value;
          return node;
      }
      clean_stringref(node) {
          var _a;
          const name = node.name.toUpperCase();
          const _string = this.strings[name]
              || this.options.strings[name]
              || this.default_strings[name]
              || (fields.unabbrev.includes(this.cleaning.name) && ((_a = this.options.unabbreviate[name]) === null || _a === void 0 ? void 0 : _a.text) && [this.text(this.options.unabbreviate[name].text)]);
          if (!_string) {
              if (!this.unresolvedStrings[name])
                  this.errors.push({ message: `Unresolved @string reference ${JSON.stringify(node.name)}` });
              this.unresolvedStrings[name] = true;
          }
          return this.clean({
              kind: 'Block',
              // if the string isn't found, add it as-is but exempt it from sentence casing
              case: _string ? undefined : 'preserve',
              markup: {},
              value: _string ? JSON.parse(JSON.stringify(_string)) : [this.text(node.name)],
          });
      }
      clean_entry(node) {
          const shortjournals = [];
          for (const field of node.fields) {
              if (fields.unabbrev.includes(field.name) && Array.isArray(field.value)) {
                  const abbr = field.value.map(v => v.source).join('');
                  const journal = this.options.unabbreviate[abbr];
                  if (journal) {
                      shortjournals.push(Object.assign(Object.assign({}, JSON.parse(JSON.stringify(field))), { name: 'shortjournal' }));
                      field.value = JSON.parse(JSON.stringify(journal.ast));
                  }
              }
          }
          node.fields = node.fields.concat(shortjournals).map(child => this.clean(child));
          return node;
      }
      startCleaning(name) {
          name = name.toLowerCase();
          if (fields.title.includes(name)) {
              this.cleaning = { type: 'title', name };
          }
          else if (fields.creator.includes(name.replace(/s$/, ''))) {
              this.cleaning = { type: 'creator', name: name.replace(/s$/, '') };
          }
          else {
              this.cleaning = { type: 'other', name };
          }
      }
      stripNoCase(node, strip, preserve) {
          switch (node.kind) {
              case 'RegularCommand':
                  // a bit cheaty to assume these to be nocased, but it's just more likely to be what people want
                  if (['chsf', 'bibstring', 'cite'].includes(node.command))
                      strip = true;
                  node.arguments.required.map(arg => this.stripNoCase(arg, strip, preserve));
                  break;
              case 'Block':
              case 'InlineMath':
              case 'DisplayMath':
                  if (strip && node.case === 'protect') {
                      if (preserve) {
                          node.case = 'preserve';
                      }
                      else {
                          delete node.case;
                      }
                  }
                  node.value.map(v => this.stripNoCase(v, strip || node.case === 'protect', preserve));
                  break;
              case 'Field':
                  if (Array.isArray(node.value))
                      node.value.map(v => this.stripNoCase(v, strip, preserve));
                  break;
          }
      }
      isVerbatimField(name) {
          return !!this.options.verbatimFields.find(p => (typeof p === 'string') ? name === p : name.match(p));
      }
      clean_field(node) {
          this.startCleaning(node.name);
          this.stripNoCase(node, !this.options.caseProtection || this.isVerbatimField(node.name), this.options.sentenceCase.length === 0);
          if (Array.isArray(node.value))
              this.condense(node);
          return node;
      }
      clean_script(node) {
          let m, value, singlechar;
          // recognize combined forms like \^\circ
          if (singlechar = unicode2latex.latex[node.source])
              return this.text(singlechar);
          if ((m = node.source.match(/^([\^_])([^{}]+)$/)) && ((singlechar = unicode2latex.latex[`${m[1]}${m[2]}`]) || (singlechar = unicode2latex.latex[`${m[1]}{${m[2]}}`])))
              return this.text(singlechar);
          if ((m = node.source.match(/^([\^_])\{([^{}]+)\}$/)) && ((singlechar = unicode2latex.latex[`${m[1]}${m[2]}`]) || (singlechar = unicode2latex.latex[`${m[1]}{${m[2]}}`])))
              return this.text(singlechar);
          const cmd = node.kind === 'SuperscriptCommand' ? '^' : '_';
          if (typeof node.value === 'string' && (singlechar = unicode2latex.latex[`${cmd}${node.value}`] || unicode2latex.latex[`${cmd}{${node.value}}`])) {
              return this.text(singlechar);
          }
          if (typeof node.value === 'string') {
              value = [this.text(node.value)];
          }
          else if (!Array.isArray(node.value)) {
              value = [node.value];
          }
          else {
              value = node.value;
          }
          const mode = node.kind === 'SuperscriptCommand' ? 'sup' : 'sub';
          return this.clean({
              kind: 'Block',
              markup: { [mode]: true },
              value,
          });
      }
      clean_environment(node) {
          this.condense(node);
          return node;
      }
      needsProtection(word) {
          return !word.match(preserveCase.hasUpper) && word.match(preserveCase.hasLower);
      }
      clean_block(node) {
          var _a;
          this.condense(node);
          if (this.options.caseProtection !== 'strict' && ((_a = this.cleaning) === null || _a === void 0 ? void 0 : _a.type) === 'title' && node.case === 'protect') {
              // test whether we can get away with skipping case protection because it contains all words that will be preserved anyway when converting back to Title Case
              let preserve = true;
              for (const child of node.value) {
                  if (child.kind === 'Text') {
                      const value = child.value.trim();
                      preserve = !value.match(preserveCase.isCaseSensitive) || !value.split(/\s+/).find(word => this.needsProtection(word));
                  }
                  else {
                      preserve = false;
                  }
                  if (!preserve)
                      break;
              }
              if (preserve)
                  node.case = 'preserve';
          }
          if (node.kind === 'Block') {
              for (const [markup, on] of Object.entries(node.markup)) {
                  if (!on)
                      delete node.markup[markup];
              }
          }
          return node;
      }
      clean_diacritic(node) {
          const char = node.dotless ? `\\${node.character}` : node.character;
          let unicode = unicode2latex.latex[`\\${node.mark}{${char}}`]
              || unicode2latex.latex[`\\${node.mark}${char}`]
              || unicode2latex.latex[`{\\${node.mark} ${char}}`]
              || unicode2latex.latex[`{\\${node.mark}${char}}`]
              || unicode2latex.latex[`\\${node.mark} ${char}`];
          if (!unicode && !node.dotless && node.character.length === 1 && unicode2latex.diacritics.tounicode[node.mark])
              unicode = node.character + unicode2latex.diacritics.tounicode[node.mark];
          if (!unicode && !this.in_preamble)
              return this.error(new TeXError(`Unhandled \\${node.mark}{${char}}`, node, this.chunk), this.text());
          return this.text(unicode);
      }
      clean_symbol(node) {
          if (node.command === '\\')
              return this.text('\n');
          return this.text(unicode2latex.latex[`\\${node.command}`] || node.command);
      }
      first_text_block(node) {
          if (!node)
              return null;
          if (node.kind === 'Block') {
              for (const child of node.value) {
                  switch (child.kind) {
                      case 'Text':
                          return child.value ? node : null;
                      case 'Block':
                          const candidate = this.first_text_block(child);
                          if (candidate)
                              return candidate;
                          break;
                      default:
                          return null;
                  }
              }
          }
          else {
              return null;
          }
      }
      clean_command(node) {
          var _a;
          let arg, unicode;
          if (unicode = unicode2latex.latex[node.source])
              return this.text(unicode);
          switch (node.command) {
              case 'newcommand':
                  if (((_a = node.arguments) === null || _a === void 0 ? void 0 : _a.required.length) === 2
                      && node.arguments.required[0].kind === 'Block'
                      && node.arguments.required[0].value.length === 1
                      && node.arguments.required[0].value[0].kind === 'RegularCommand'
                      && node.arguments.required[1].kind === 'Block') {
                      this.newcommands[node.arguments.required[0].value[0].command] = node.arguments.required[1].value;
                      return this.text();
                  }
                  // console.log('newcommand?', JSON.stringify(node, null, 2))
                  break;
              case 'item':
                  return { kind: 'Markup', value: '<li>', source: node.source };
              case 'frac':
                  if (arg = this.argument(node, 2)) {
                      if (arg[0].kind === 'Text' && arg[1].kind === 'Text' && (unicode = unicode2latex.latex[`\\frac{${arg[0].value}}{${arg[1].value}}`]))
                          return this.text(unicode);
                      return this.clean({
                          kind: 'Block',
                          case: 'protect',
                          markup: {},
                          value: [
                              { kind: 'Block', markup: { sup: true }, value: [arg[0]] },
                              this.text('\u2044'),
                              { kind: 'Block', markup: { sub: true }, value: [arg[1]] },
                          ],
                      });
                  }
                  break;
              // ignore
              case 'vspace':
              case 'vphantom':
              case 'path':
              case 'aftergroup':
              case 'ignorespaces':
              case 'relax':
              case 'noopsort':
              case 'ifdefined':
              case 'DeclarePrefChars':
              case 'else':
              case 'fi':
              case 'makeatletter':
                  return this.text();
              case 'ElsevierGlyph':
                  if (arg = this.argument(node, 'Text')) {
                      if (unicode = unicode2latex.latex[`\\${node.command}{${arg}}`])
                          return this.text(unicode);
                      return this.text(String.fromCharCode(parseInt(arg, 16)));
                  }
                  break;
              case 'chsf':
                  if (this.argument(node, 'none'))
                      return this.text();
                  if (arg = this.argument(node, 'Block'))
                      return this.clean(arg);
                  break;
              case 'bibstring':
                  if (arg = this.argument(node, 'Block'))
                      return this.clean(arg);
                  break;
              case 'cite':
                  if (arg = this.argument(node, 'Block'))
                      return this.clean(arg);
                  break;
              case 'textsuperscript':
              case 'sp':
                  if ((arg = this.argument(node, 'Text')) && (unicode = unicode2latex.latex[`^{${arg}}`]))
                      return this.text(unicode);
                  if (arg = this.argument(node, 'Block'))
                      return this.clean(arg);
                  break;
              case 'textsubscript':
              case 'sb':
                  if ((arg = this.argument(node, 'Text')) && (unicode = unicode2latex.latex[`_{${arg}}`]))
                      return this.text(unicode);
                  if (arg = this.argument(node, 'Block'))
                      return this.clean(arg);
                  break;
              case 'textsc':
                  if (arg = this.argument(node, 'Block'))
                      return this.clean(arg);
                  break;
              case 'enquote':
              case 'mkbibquote':
                  if (arg = this.argument(node, 'Block'))
                      return this.clean(arg);
                  break;
              case 'textbf':
              case 'mkbibbold':
                  if (arg = this.argument(node, 'Block'))
                      return this.clean(arg);
                  break;
              case 'section':
              case 'subsection':
              case 'subsubsection':
              case 'subsubsubsection':
                  if (arg = this.argument(node, 'Block'))
                      return this.clean(arg);
                  break;
              case 'mkbibitalic':
              case 'mkbibemph':
              case 'textit':
              case 'emph':
                  if (arg = this.argument(node, 'Block'))
                      return this.clean(arg);
                  if (arg = this.argument(node, 'Text'))
                      return this.clean({ kind: 'Block', markup: { italics: true }, value: [this.text(arg)] });
                  break;
              case 'bibcyr':
                  if (this.argument(node, 'none'))
                      return this.text();
                  if (arg = this.argument(node, 'Block'))
                      return this.clean(arg);
                  break;
              case 'hspace':
              case 'mathrm':
              case 'textrm':
              case 'ocirc':
              case 'mbox':
                  if (arg = this.argument(node, 'text')) {
                      unicode = unicode2latex.latex[`\\${node.command}{${arg}}`];
                      return this.text(unicode || (node.command === 'hspace' ? ' ' : arg));
                  }
                  else if (!node.arguments.required.length) {
                      return this.text();
                  }
                  else if (arg = this.argument(node, 'Block')) {
                      return this.clean(arg);
                  }
                  break;
              // just take the URL? Not the label?
              case 'href':
                  if (arg = this.argument(node, 2))
                      return this.clean(arg[0]);
                  break;
              case 'url':
                  if (arg = this.argument(node, 'Text'))
                      return this.text(arg);
                  if (arg = this.argument(node, 'Block'))
                      return this.clean(arg);
                  break;
              case 'sl':
              case 'em':
              case 'it':
              case 'itshape':
              case 'bf':
              case 'bfseries':
              case 'sc':
              case 'scshape':
              case 'tt':
              case 'rm':
              case 'sf':
              case 'verb':
                  // handled in the grammar
                  return this.text();
              // wouldn't know what to do with these
              case 'left':
              case 'right':
                  return this.text();
              case 'par':
                  return this.text('\n\n');
              case 'cyr':
                  if (this.argument(node, 'none'))
                      return this.text();
                  break;
              case 'polhk':
                  if (unicode = this.argument(node, 'text')) {
                      if (unicode.length === 1)
                          return this.text(unicode + '\u0328');
                  }
                  if (this.argument(node, 'none'))
                      return this.text('\u0328');
                  break;
              default:
                  if (node.kind === 'RegularCommand' && this.newcommands[node.command]) {
                      return this.clean({
                          kind: 'Block',
                          markup: {},
                          value: JSON.parse(JSON.stringify(this.newcommands[node.command])),
                      });
                  }
                  if (unicode2latex.diacritics.tounicode[node.command]) {
                      node.arguments.required = this.clean(node.arguments.required);
                      let block;
                      if (node.arguments.required.length === 1 && node.arguments.required[0].kind === 'Text') {
                          // no idea why I can't just straight return this but typescript just won't shut up
                          block = {
                              kind: 'Block',
                              markup: {},
                              value: [{
                                      kind: 'DiacriticCommand',
                                      mark: node.command,
                                      character: node.arguments.required[0].value,
                                      dotless: false,
                                      loc: node.arguments.required[0].loc,
                                      source: node.arguments.required[0].source,
                                  }],
                          };
                          return this.clean(block);
                      }
                      else if (block = this.first_text_block(node.arguments.required[0])) {
                          let fixed = false;
                          block.value = block.value.reduce((value, child) => {
                              if (!fixed && child.kind === 'Text') {
                                  fixed = true;
                                  value.push({ kind: 'DiacriticCommand', mark: node.command, character: child.value[0] });
                                  value.push(Object.assign(Object.assign({}, child), { value: child.value.substring(1) }));
                              }
                              else {
                                  value.push(child);
                              }
                              return value;
                          }, []);
                          return this.clean({
                              kind: 'Block',
                              markup: {},
                              value: node.arguments.required,
                          });
                      }
                      else {
                          // overline without arguments doesn't seem to render in LaTeX
                          if (node.command === 'overline')
                              return this.text(' ');
                          return this.clean({
                              kind: 'Block',
                              markup: {},
                              value: [this.text(' ' + unicode2latex.diacritics.tounicode[node.command])].concat(node.arguments.required),
                          });
                      }
                  }
                  if (unicode = unicode2latex.latex[node.source] || unicode2latex.latex[`${node.source}{}`])
                      return this.text(unicode);
                  if ((unicode = unicode2latex.latex[`\\${node.command}`] || unicode2latex.latex[`\\${node.command}{}`]) && this.argument(node, 'none'))
                      return this.text(unicode);
                  if ((arg = this.argument(node, 'Text')) && (unicode = unicode2latex.latex[`\\${node.command}{${arg}}`]))
                      return this.text(unicode);
                  break;
          }
          if (this.in_preamble)
              return this.text(node.source);
          return this.error(new TeXError(`Unhandled command: ${node.command}` + this.show(node), node, this.chunk), this.text());
      }
      preserveCase(word) {
          // word = word.replace(new RegExp(`"[${this.markup.enquote.open}${this.markup.enquote.close}:()]`, 'g'), '')
          var _a, _b;
          if (!word.trim())
              return false;
          if (!word.match(preserveCase.hasAlphaNum))
              return true;
          word = word.replace(/[\/’'”:()]/g, '');
          if (word === 'I')
              return true;
          if (word.length === 1)
              return false;
          if (word.replace(preserveCase.notCaseSensitive) === '')
              return false;
          // word = word.replace(preserveCase.notAlphaNum, '')
          // simple cap at start of field
          if (word.match(preserveCase.leadingCap) && ((_b = (_a = this.field) === null || _a === void 0 ? void 0 : _a.text) === null || _b === void 0 ? void 0 : _b.length) === 0)
              return false;
          if (word.match(preserveCase.allCaps))
              return true;
          if (word.length > 1 && word.match(preserveCase.joined))
              return false;
          if (word.match(preserveCase.hasUpper))
              return true;
          if (word.match(preserveCase.isNumber))
              return true;
          return false;
      }
      convert(node) {
          if (Array.isArray(node))
              return node.map(child => this.convert(child));
          if (this.options.raw && this.field)
              node = this.text(node.source);
          switch (node.kind) {
              case 'Markup':
                  if (this.field)
                      this.field.text += node.value;
                  break;
              case 'BracedComment':
              case 'LineComment':
                  this.comments.push(node.value);
                  break;
              case 'Entry':
                  this.convert_entry(node);
                  break;
              case 'Number':
                  this.convert_number(node);
                  break;
              case 'Text':
                  this.convert_text(node);
                  break;
              case 'Block':
              case 'InlineMath':
              case 'DisplayMath':
                  const start = this.field ? this.field.text.length : null;
                  const preserve = typeof start === 'number' && this.field.preserveRanges;
                  this.convert_block(node);
                  if (preserve && (node.case || node.kind.endsWith('Math')))
                      this.preserve(start, this.field.text.length); // , `convert-block: case=${node.case}, math=${node.kind.endsWith('Math')}`)
                  break;
              case 'Environment':
                  this.convert_environment(node);
                  break;
              case 'PreambleExpression':
                  this.preamble.push(node.value.map(preamble => preamble.source).join('\n\n'));
                  break;
              case 'DisplayMath':
              case 'InlineMath':
              case 'StringDeclaration':
                  break;
              default:
                  return this.error(new ParserError(`no converter for ${node.kind}: ${this.show(node)}`, node), undefined);
          }
      }
      splitOnce(s, sep, fromEnd = false) {
          const split = fromEnd ? s.lastIndexOf(sep) : s.indexOf(sep);
          return (split < 0) ? [s, ''] : [s.substr(0, split), s.substr(split + 1)];
      }
      parseName(name) {
          let parsed = null;
          const parts = name.split(marker.comma);
          if (parts.length && !parts.find(p => !p.match(/^[a-z]+(-i)?=/i))) { // extended name format
              for (const part of parts) {
                  parsed = parsed || {};
                  const [attr, value] = this.splitOnce(part.replace(marker.re.space, ''), '=').map(v => v.trim());
                  if (!value) {
                      parsed = null;
                      break;
                  }
                  switch (attr.toLowerCase()) {
                      case 'family':
                          parsed.lastName = value;
                          break;
                      case 'given-i':
                          parsed.initial = value;
                          break;
                      case 'given':
                          parsed.firstName = value;
                          break;
                      case 'prefix':
                          parsed.prefix = value;
                          break;
                      case 'suffix':
                          parsed.suffix = value;
                          break;
                      case 'useprefix':
                          parsed.useprefix = value.toLowerCase() === 'true';
                          break;
                      case 'juniorcomma':
                          parsed.useprefix = value.toLowerCase() === 'true';
                          break;
                      default:
                          parsed[attr.toLowerCase()] = value;
                          break;
                  }
              }
          }
          const prefix = /(.+?)\s+(vere|von|van den|van der|van|de|del|della|der|di|da|pietro|vanden|du|st.|st|la|lo|ter|bin|ibn|te|ten|op|ben|al)\s+(.+)/;
          let m;
          switch (parsed ? 0 : parts.length) {
              case 0:
                  // already parsed
                  break;
              case 1: // name without commas
                  // literal
                  if (marker.re.literalName.test(parts[0])) {
                      parsed = { literal: parts[0] };
                  }
                  else if (m = parts[0].replace(marker.re.space, ' ').match(prefix)) { // split on prefix
                      parsed = {
                          firstName: m[1],
                          prefix: m[2],
                          lastName: m[3],
                      };
                  }
                  else {
                      // top-level "firstname lastname"
                      const [firstName, lastName] = this.splitOnce(parts[0], marker.space, true);
                      if (lastName) {
                          parsed = { firstName, lastName };
                      }
                      else {
                          parsed = { lastName: firstName };
                      }
                  }
                  break;
              case 2: // lastname, firstname
                  parsed = {
                      lastName: parts[0],
                      firstName: parts[1],
                  };
                  break;
              default: // lastname, suffix, firstname
                  parsed = {
                      lastName: parts[0],
                      suffix: parts[1],
                      firstName: parts.slice(2).join(marker.comma),
                  };
          }
          for (const [k, v] of Object.entries(parsed)) {
              if (typeof v !== 'string')
                  continue;
              parsed[k] = marker.clean(v).trim();
          }
          return parsed;
      }
      convert_entry(node) {
          var _a;
          this.entry = {
              key: node.id,
              type: node.type,
              fields: {},
              creators: {},
          };
          this.entries.push(this.entry);
          // order these first for language-dependent sentence casing
          const order = ['langid', 'hyphenation', 'language'];
          node.fields.sort((a, b) => {
              const ia = order.indexOf(a.name);
              const ib = order.indexOf(b.name);
              if (ia === -1 && ib === -1)
                  return a.name.localeCompare(b.name); // doesn't matter really
              if (ia === -1)
                  return 1;
              if (ib === -1)
                  return -1;
              return ia - ib;
          });
          let sentenceCase = !!this.options.sentenceCase.length; // if sentenceCase is empty, no sentence casing
          for (const field of node.fields) {
              if (field.kind !== 'Field')
                  return this.error(new ParserError(`Expected Field, got ${field.kind}`, node), undefined);
              this.startCleaning(field.name);
              /*
              if (this.options.raw && this.fieldType !== 'creator') {
                this.entry.fields[field.name] = [ field.value.map(v => v.source).join('') ]
                continue
              }
              */
              this.field = {
                  name: field.name,
                  text: '',
                  level: 0,
                  words: {
                      upper: 0,
                      lower: 0,
                      other: 0,
                  },
                  preserveRanges: (sentenceCase && fields.title.includes(field.name)) ? [] : null,
                  html: this.options.htmlFields.includes(field.name),
              };
              this.entry.fields[this.field.name] = this.entry.fields[this.field.name] || [];
              // special case for 'title = 2020'
              if (field.value.kind === 'Number') {
                  this.entry.fields[this.field.name].push(field.value.value);
                  this.field = null;
                  continue;
              }
              this.convert(field.value);
              this.field.text = this.field.text.trim();
              this.field.text = this.field.text.replace(/<\/([a-z])><\1>/g, '');
              this.field.text = this.field.text.replace(/<([a-z])>(\s*)<\/\1>/g, '$1');
              if (!this.field.text)
                  continue;
              // disable sentenceCasing if not an english
              switch (this.field.name) {
                  case 'langid':
                  case 'hyphenation':
                      sentenceCase = sentenceCase && this.options.sentenceCase.includes(this.field.text.toLowerCase());
                      break;
                  case 'language':
                      sentenceCase = sentenceCase && !!(this.field.text.toLowerCase().trim().split(/\s*,\s*/).find(lang => this.options.sentenceCase.includes(lang)));
                      break;
              }
              // "groups" is a jabref 3.8+ monstrosity
              if (this.field.name.match(/^(keywords?|groups)$/)) {
                  for (let text of this.field.text.split(marker.comma)) {
                      text = text.trim();
                      if (text)
                          this.entry.fields[this.field.name].push(text);
                  }
              }
              else if (this.cleaning.type === 'creator') {
                  if (!this.entry.creators[this.field.name])
                      this.entry.creators[this.field.name] = [];
                  // {M. Halle, J. Bresnan, and G. Miller}
                  if (this.field.text.includes(`${marker.comma}${marker.and}`)) { //
                      this.field.text = this.field.text.replace(new RegExp(`${marker.comma}${marker.and}`, 'g'), marker.and).replace(new RegExp(marker.comma), marker.and);
                  }
                  for (const creator of this.field.text.split(marker.and)) {
                      this.entry.fields[this.field.name].push(marker.clean(creator));
                      this.entry.creators[this.field.name].push(this.parseName(creator));
                  }
              }
              else if (fields.unabbrev.includes(field.name)) { // doesn't get sentence casing anyhow TODO: booktitle does!
                  this.entry.fields[this.field.name].push((((_a = this.options.unabbreviate[this.field.text]) === null || _a === void 0 ? void 0 : _a.text) || this.field.text).normalize('NFC'));
              }
              else {
                  if (this.field.preserveRanges) {
                      if (this.options.guessAlreadySentenceCased && Math.max(this.field.words.upper, this.field.words.lower) > (this.field.words.other + Math.min(this.field.words.upper, this.field.words.lower))) {
                          this.preserve(null, null); // , 'mostly sentence cased already')
                      }
                      else {
                          const txt = this.field.text.replace(preserveCase.markup, markup => marker.markup.repeat(markup.length));
                          let match;
                          preserveCase.sentenceStart.lastIndex = 0;
                          while ((match = preserveCase.sentenceStart.exec(txt))) {
                              // exclude stuff like "U.S. Taxes"
                              if (match.index > 2 && txt.substr(0, match.index + 1).match(preserveCase.acronym))
                                  continue;
                              this.preserve(match.index, match.index + match[0].length); // , `sentenceStart: ${match[0]} at ${match.index}..${match.index + match[0].length}`)
                          }
                          preserveCase.quoted.lastIndex = 0;
                          while ((match = preserveCase.quoted.exec(this.field.text))) {
                              this.preserve(match.index, match.index + match[0].length); // , 'quoted')
                          }
                      }
                  }
                  this.entry.fields[this.field.name].push(this.convertToSentenceCase(this.field.text).normalize('NFC'));
              }
          }
          this.field = null;
      }
      convertToSentenceCase(text) {
          if (!this.field.preserveRanges)
              return text;
          // always keep the leading char, but skip markup
          const lead = text.match(/^(<[^>]+>)*./);
          if (lead) {
              this.preserve(lead[0].length - 1, lead[0].length);
          }
          else {
              this.preserve(0, 1);
          }
          let sentenceCased = text.toLowerCase().replace(/(([\?!]\s*|^)([\'\"¡¿“‘„«\s]+)?[^\s])/g, x => x.toUpperCase());
          for (const { start, end } of this.field.preserveRanges) {
              sentenceCased = sentenceCased.substring(0, start) + text.substring(start, end) + sentenceCased.substring(end);
          }
          if (text !== sentenceCased)
              this.entry.sentenceCased = true;
          return sentenceCased;
      }
      convert_number(node) {
          this.field.text += `${node.value}`;
      }
      convert_text(node) {
          if (node.mode === 'verbatim') {
              this.field.text += node.value.trim();
              return;
          }
          // heuristic to detect pre-sentencecased text
          for (const word of node.value.split(/\b/)) {
              if (word.match(preserveCase.allLower)) {
                  this.field.words.lower++;
              }
              else if (word.match(preserveCase.allCaps)) {
                  this.field.words.upper++;
              }
              else if (word.match(preserveCase.hasAlpha)) {
                  this.field.words.other++;
              }
          }
          if (this.field.level === 0 && this.cleaning.type === 'creator') {
              this.field.text += node.value.replace(/\s+and\s+/ig, marker.and).replace(/\s*,\s*/g, marker.comma).replace(/\s+/g, marker.space);
              return;
          }
          if (this.field.level === 0 && this.field.name.match(/^(keywords?|groups)$/)) {
              this.field.text += node.value.replace(/\s*[;,]\s*/g, marker.comma);
              return;
          }
          if (this.field.html) {
              this.field.text += node.value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
          }
          else if (this.field.preserveRanges) {
              const words = node.value.split(/(\s+)/);
              for (const word of words) {
                  const start = this.field.text.length;
                  this.field.text += word;
                  if (this.preserveCase(word))
                      this.preserve(start, this.field.text.length); // , `word: ${JSON.stringify(word)}`)
              }
          }
          else {
              this.field.text += node.value;
          }
      }
      convert_environment(node) {
          this.field.text += { enumerate: '<ol>', itemize: '<ul>' }[node.env];
          this.convert_block(Object.assign(Object.assign({}, node), { kind: 'Block', markup: {} }));
          this.field.text += { enumerate: '</ol>', itemize: '</ul>' }[node.env];
      }
      convert_block(node) {
          const start = this.field.text.length;
          let prefix = '';
          let postfix = '';
          if (this.options.caseProtection !== 'strict' && this.cleaning.type === 'other')
              delete node.case;
          if (this.cleaning.type === 'creator' && node.case === 'protect') {
              prefix += marker.literal;
              postfix = marker.literal + postfix;
              delete node.case;
          }
          if (node.case === 'protect') {
              prefix += this.options.markup.caseProtect.open;
              postfix = this.options.markup.caseProtect.close + postfix;
          }
          if (node.kind === 'Block') {
              for (const markup of Object.keys(node.markup)) {
                  if (!this.options.markup[markup])
                      return this.error(new ParserError(`markup: ${markup}`, node), undefined);
                  prefix += this.options.markup[markup].open;
                  postfix = this.options.markup[markup].close + postfix;
              }
          }
          const end = {
              withoutPrefix: this.field.text.length,
              withPrefix: this.field.text.length + prefix.length,
          };
          this.field.text += prefix;
          this.field.level++;
          this.convert(node.value);
          this.field.level--;
          const added = this.field.text.substring(end.withPrefix);
          const added_text = added.replace(/<\/?[^>]+>/g, '');
          const needsProtection = added_text && ((this.options.caseProtection === 'strict' && added_text.match(preserveCase.isCaseSensitive))
              ||
                  (this.options.caseProtection === 'as-needed' && added_text.split(/\s+/).find(word => this.needsProtection(word))));
          if (!added) { // nothing was added, so remove prefix
              this.field.text = this.field.text.substring(0, end.withoutPrefix);
          }
          else if (this.field.preserveRanges && prefix === this.options.markup.caseProtect.open && !needsProtection) {
              // something was added that didn't actually need case protection
              this.field.text = this.field.text.substring(0, end.withoutPrefix) + added;
              this.field.preserveRanges = this.field.preserveRanges.filter(range => range.start < end.withoutPrefix);
          }
          else {
              this.field.text += postfix;
          }
          this.field.text = this.field.text.replace(/<(sup|sub)>([^<>]+)<\/\1>$/i, (m, mode, chars) => {
              const cmd = mode === 'sup' ? '^' : '_';
              let script = '';
              for (const char of chars) {
                  const unicode = unicode2latex.latex[`${cmd}${char}`] || unicode2latex.latex[`${cmd}{${char}}`];
                  script += unicode ? unicode : `<${mode}>${char}</${mode}>`;
              }
              script = script.replace(new RegExp(`</${mode}><${mode}>`, 'g'), '');
              return script.length < m.length ? script : m;
          });
          if (node.case && this.field.preserveRanges)
              this.preserve(start, this.field.text.length); // , 'in convert-block ' + node.source || '<source>')
      }
  }
  /**
   * parse bibtex. This will try to convert TeX commands into unicode equivalents, and apply `@string` expansion
   */
  function parse(input, options = {}) {
      const parser = new Parser(options);
      return parser.parse(input);
  }
  exports.parse = parse;
  function ast(input, options = {}, clean = true) {
      const parser = new Parser(options);
      return parser.ast(input, clean);
  }
  exports.ast = ast;
  var chunker_2 = chunker;
  Object.defineProperty(exports, "chunker", { enumerable: true, get: function () { return chunker_2.parse; } });

  Object.defineProperty(exports, "jabref", { enumerable: true, get: function () { return jabref.parse; } });

  });

  var Library = /** @class */ (function () {
      function Library(entries) {
          this.entries = entries;
      }
      Object.defineProperty(Library.prototype, "size", {
          get: function () {
              return Object.keys(this.entries).length;
          },
          enumerable: false,
          configurable: true
      });
      /**
       * For the given citekey, find the corresponding `Entry` and return a
       * collection of template variable assignments.
       */
      Library.prototype.getTemplateVariablesForCitekey = function (citekey) {
          var _a;
          var entry = this.entries[citekey];
          var shortcuts = {
              citekey: citekey,
              abstract: entry.abstract,
              authorString: entry.authorString,
              containerTitle: entry.containerTitle,
              DOI: entry.DOI,
              eprint: entry.eprint,
              eprinttype: entry.eprinttype,
              eventPlace: entry.eventPlace,
              note: entry.note,
              page: entry.page,
              publisher: entry.publisher,
              publisherPlace: entry.publisherPlace,
              title: entry.title,
              titleShort: entry.titleShort,
              URL: entry.URL,
              year: (_a = entry.year) === null || _a === void 0 ? void 0 : _a.toString(),
              zoteroSelectURI: entry.zoteroSelectURI,
          };
          return __assign({ entry: entry.toJSON() }, shortcuts);
      };
      return Library;
  }());
  /**
   * Load reference entries from the given raw database data.
   *
   * Returns a list of `EntryData`, which should be wrapped with the relevant
   * adapter and used to instantiate a `Library`.
   */
  function loadEntries(databaseRaw, databaseType) {
      var libraryArray;
      if (databaseType == 'csl-json') {
          libraryArray = JSON.parse(databaseRaw);
      }
      else if (databaseType == 'biblatex') {
          var options = {
              errorHandler: function (err) {
                  console.warn('Citation plugin: non-fatal error loading BibLaTeX entry:', err);
              },
          };
          var parsed = bibtexParser.parse(databaseRaw, options);
          parsed.errors.forEach(function (error) {
              console.error("Citation plugin: fatal error loading BibLaTeX entry" +
                  (" (line " + error.line + ", column " + error.column + "):"), error.message);
          });
          libraryArray = parsed.entries;
      }
      return libraryArray;
  }
  /**
   * An `Entry` represents a single reference in a reference database.
   * Each entry has a unique identifier, known in most reference managers as its
   * "citekey."
   */
  var Entry = /** @class */ (function () {
      function Entry() {
      }
      Object.defineProperty(Entry.prototype, "year", {
          get: function () {
              var _a;
              return this._year
                  ? parseInt(this._year)
                  : (_a = this.issuedDate) === null || _a === void 0 ? void 0 : _a.getUTCFullYear();
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(Entry.prototype, "note", {
          get: function () {
              var _a;
              return (_a = this._note) === null || _a === void 0 ? void 0 : _a.map(function (el) { return el.replace(/(zotero:\/\/.+)/g, '[Link]($1)'); }).join('\n\n');
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(Entry.prototype, "zoteroSelectURI", {
          /**
           * A URI which will open the relevant entry in the Zotero client.
           */
          get: function () {
              return "zotero://select/items/@" + this.id;
          },
          enumerable: false,
          configurable: true
      });
      Entry.prototype.toJSON = function () {
          var _this = this;
          var jsonObj = Object.assign({}, this);
          // add getter values
          var proto = Object.getPrototypeOf(this);
          Object.entries(Object.getOwnPropertyDescriptors(proto))
              .filter(function (_a) {
              var descriptor = _a[1];
              return typeof descriptor.get == 'function';
          })
              .forEach(function (_a) {
              var key = _a[0], descriptor = _a[1];
              if (descriptor && key[0] !== '_') {
                  try {
                      var val = _this[key];
                      jsonObj[key] = val;
                  }
                  catch (error) {
                      return;
                  }
              }
          });
          return jsonObj;
      };
      return Entry;
  }());
  var EntryCSLAdapter = /** @class */ (function (_super) {
      __extends(EntryCSLAdapter, _super);
      function EntryCSLAdapter(data) {
          var _this = _super.call(this) || this;
          _this.data = data;
          _this.eprint = null;
          _this.eprinttype = null;
          _this.files = null;
          return _this;
      }
      Object.defineProperty(EntryCSLAdapter.prototype, "id", {
          get: function () {
              return this.data.id;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryCSLAdapter.prototype, "type", {
          get: function () {
              return this.data.type;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryCSLAdapter.prototype, "abstract", {
          get: function () {
              return this.data.abstract;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryCSLAdapter.prototype, "author", {
          get: function () {
              return this.data.author;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryCSLAdapter.prototype, "authorString", {
          get: function () {
              return this.data.author
                  ? this.data.author.map(function (a) { return a.given + " " + a.family; }).join(', ')
                  : null;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryCSLAdapter.prototype, "containerTitle", {
          get: function () {
              return this.data['container-title'];
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryCSLAdapter.prototype, "DOI", {
          get: function () {
              return this.data.DOI;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryCSLAdapter.prototype, "eventPlace", {
          get: function () {
              return this.data['event-place'];
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryCSLAdapter.prototype, "issuedDate", {
          get: function () {
              if (!(this.data.issued &&
                  this.data.issued['date-parts'] &&
                  this.data.issued['date-parts'][0].length > 0))
                  return null;
              var _a = this.data.issued['date-parts'][0], year = _a[0], month = _a[1], day = _a[2];
              return new Date(Date.UTC(year, (month || 1) - 1, day || 1));
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryCSLAdapter.prototype, "page", {
          get: function () {
              return this.data.page;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryCSLAdapter.prototype, "publisher", {
          get: function () {
              return this.data.publisher;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryCSLAdapter.prototype, "publisherPlace", {
          get: function () {
              return this.data['publisher-place'];
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryCSLAdapter.prototype, "title", {
          get: function () {
              return this.data.title;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryCSLAdapter.prototype, "titleShort", {
          get: function () {
              return this.data['title-short'];
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryCSLAdapter.prototype, "URL", {
          get: function () {
              return this.data.URL;
          },
          enumerable: false,
          configurable: true
      });
      return EntryCSLAdapter;
  }(Entry));
  var BIBLATEX_PROPERTY_MAPPING = {
      abstract: 'abstract',
      booktitle: '_containerTitle',
      date: 'issued',
      doi: 'DOI',
      eprint: 'eprint',
      eprinttype: 'eprinttype',
      eventtitle: 'event',
      journal: '_containerTitle',
      journaltitle: '_containerTitle',
      location: 'publisherPlace',
      pages: 'page',
      shortjournal: 'containerTitleShort',
      title: 'title',
      shorttitle: 'titleShort',
      url: 'URL',
      venue: 'eventPlace',
      year: '_year',
      publisher: 'publisher',
      note: '_note',
  };
  // BibLaTeX parser returns arrays of property values (allowing for repeated
  // property entries). For the following fields, just blindly take the first.
  var BIBLATEX_PROPERTY_TAKE_FIRST = [
      'abstract',
      'booktitle',
      '_containerTitle',
      'date',
      'doi',
      'eprint',
      'eprinttype',
      'eventtitle',
      'journaltitle',
      'location',
      'pages',
      'shortjournal',
      'title',
      'shorttitle',
      'url',
      'venue',
      '_year',
      'publisher',
  ];
  var EntryBibLaTeXAdapter = /** @class */ (function (_super) {
      __extends(EntryBibLaTeXAdapter, _super);
      function EntryBibLaTeXAdapter(data) {
          var _this = _super.call(this) || this;
          _this.data = data;
          Object.entries(BIBLATEX_PROPERTY_MAPPING).forEach(function (map) {
              var src = map[0], tgt = map[1];
              if (src in _this.data.fields) {
                  var val = _this.data.fields[src];
                  if (BIBLATEX_PROPERTY_TAKE_FIRST.includes(src)) {
                      val = val[0];
                  }
                  _this[tgt] = val;
              }
          });
          return _this;
      }
      Object.defineProperty(EntryBibLaTeXAdapter.prototype, "id", {
          get: function () {
              return this.data.key;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryBibLaTeXAdapter.prototype, "type", {
          get: function () {
              return this.data.type;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryBibLaTeXAdapter.prototype, "files", {
          get: function () {
              // For some reason the bibtex parser doesn't reliably parse file list to
              // array ; so we'll do it manually / redundantly
              var ret = [];
              if (this.data.fields.file) {
                  ret = ret.concat(this.data.fields.file.flatMap(function (x) { return x.split(';'); }));
              }
              if (this.data.fields.files) {
                  ret = ret.concat(this.data.fields.files.flatMap(function (x) { return x.split(';'); }));
              }
              return ret;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryBibLaTeXAdapter.prototype, "authorString", {
          get: function () {
              var _a;
              if (this.data.creators.author) {
                  var names = this.data.creators.author.map(function (name) {
                      if (name.literal)
                          return name.literal;
                      var parts = [name.firstName, name.prefix, name.lastName, name.suffix];
                      // Drop any null parts and join
                      return parts.filter(function (x) { return x; }).join(' ');
                  });
                  return names.join(', ');
              }
              else {
                  return (_a = this.data.fields.author) === null || _a === void 0 ? void 0 : _a.join(', ');
              }
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryBibLaTeXAdapter.prototype, "containerTitle", {
          get: function () {
              if (this._containerTitle) {
                  return this._containerTitle;
              }
              else if (this.data.fields.eprint) {
                  var prefix = this.data.fields.eprinttype
                      ? this.data.fields.eprinttype + ":"
                      : '';
                  var suffix = this.data.fields.primaryclass
                      ? " [" + this.data.fields.primaryclass + "]"
                      : '';
                  return "" + prefix + this.data.fields.eprint + suffix;
              }
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryBibLaTeXAdapter.prototype, "issuedDate", {
          get: function () {
              return this.issued ? new Date(this.issued) : null;
          },
          enumerable: false,
          configurable: true
      });
      Object.defineProperty(EntryBibLaTeXAdapter.prototype, "author", {
          get: function () {
              var _a;
              return (_a = this.data.creators.author) === null || _a === void 0 ? void 0 : _a.map(function (a) { return ({
                  given: a.firstName,
                  family: a.lastName,
              }); });
          },
          enumerable: false,
          configurable: true
      });
      return EntryBibLaTeXAdapter;
  }(Entry));

  register(function (msg) {
      return loadEntries(msg.databaseRaw, msg.databaseType);
  });

}());
}, 'data:application/json;charset=utf-8;base64, ');
/* eslint-enable */

var CitationPlugin = /** @class */ (function (_super) {
    __extends(CitationPlugin, _super);
    function CitationPlugin() {
        var _this = _super !== null && _super.apply(this, arguments) || this;
        // Template compilation options
        _this.templateSettings = {
            noEscape: true,
        };
        _this.loadWorker = new WorkerManager(new WorkerFactory(), {
            blockingChannel: true,
        });
        _this.events = new CitationEvents();
        _this.loadErrorNotifier = new Notifier('Unable to load citations. Please update Citations plugin settings.');
        _this.literatureNoteErrorNotifier = new Notifier('Unable to access literature note. Please check that the literature note folder exists, or update the Citations plugin settings.');
        return _this;
    }
    Object.defineProperty(CitationPlugin.prototype, "editor", {
        get: function () {
            var view = this.app.workspace.activeLeaf.view;
            if (!(view instanceof obsidian.MarkdownView))
                return null;
            var sourceView = view.sourceMode;
            return sourceView.cmEditor;
        },
        enumerable: false,
        configurable: true
    });
    CitationPlugin.prototype.loadSettings = function () {
        return __awaiter(this, void 0, void 0, function () {
            var loadedSettings, toLoad;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        this.settings = new CitationsPluginSettings();
                        return [4 /*yield*/, this.loadData()];
                    case 1:
                        loadedSettings = _a.sent();
                        if (!loadedSettings)
                            return [2 /*return*/];
                        toLoad = [
                            'citationExportPath',
                            'citationExportFormat',
                            'literatureNoteTitleTemplate',
                            'literatureNoteFolder',
                            'literatureNoteContentTemplate',
                            'markdownCitationTemplate',
                            'alternativeMarkdownCitationTemplate',
                        ];
                        toLoad.forEach(function (setting) {
                            if (setting in loadedSettings) {
                                _this.settings[setting] = loadedSettings[setting];
                            }
                        });
                        return [2 /*return*/];
                }
            });
        });
    };
    CitationPlugin.prototype.saveSettings = function () {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.saveData(this.settings)];
                    case 1:
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        });
    };
    CitationPlugin.prototype.onload = function () {
        var _this = this;
        this.loadSettings().then(function () { return _this.init(); });
    };
    CitationPlugin.prototype.init = function () {
        return __awaiter(this, void 0, void 0, function () {
            var watchOptions;
            var _this = this;
            return __generator(this, function (_a) {
                if (this.settings.citationExportPath) {
                    // Load library for the first time
                    this.loadLibrary();
                    // Set up a watcher to refresh whenever the export is updated
                    try {
                        watchOptions = {
                            awaitWriteFinish: {
                                stabilityThreshold: 500,
                            },
                        };
                        watch_1(this.resolveLibraryPath(this.settings.citationExportPath), watchOptions)
                            .on('change', function () {
                            _this.loadLibrary();
                        });
                    }
                    catch (_b) {
                        this.loadErrorNotifier.show();
                    }
                }
                this.addCommand({
                    id: 'open-literature-note',
                    name: 'Open literature note',
                    hotkeys: [{ modifiers: ['Ctrl', 'Shift'], key: 'o' }],
                    callback: function () {
                        var modal = new OpenNoteModal(_this.app, _this);
                        modal.open();
                    },
                });
                this.addCommand({
                    id: 'update-bib-data',
                    name: 'Refresh citation database',
                    hotkeys: [{ modifiers: ['Ctrl', 'Shift'], key: 'r' }],
                    callback: function () {
                        _this.loadLibrary();
                    },
                });
                this.addCommand({
                    id: 'insert-citation',
                    name: 'Insert literature note link',
                    hotkeys: [{ modifiers: ['Ctrl', 'Shift'], key: 'e' }],
                    callback: function () {
                        var modal = new InsertNoteLinkModal(_this.app, _this);
                        modal.open();
                    },
                });
                this.addCommand({
                    id: 'insert-literature-note-content',
                    name: 'Insert literature note content in the current pane',
                    callback: function () {
                        var modal = new InsertNoteContentModal(_this.app, _this);
                        modal.open();
                    },
                });
                this.addCommand({
                    id: 'insert-markdown-citation',
                    name: 'Insert Markdown citation',
                    callback: function () {
                        var modal = new InsertCitationModal(_this.app, _this);
                        modal.open();
                    },
                });
                this.addSettingTab(new CitationSettingTab(this.app, this));
                return [2 /*return*/];
            });
        });
    };
    /**
     * Resolve a provided library path, allowing for relative paths rooted at
     * the vault directory.
     */
    CitationPlugin.prototype.resolveLibraryPath = function (rawPath) {
        var vaultRoot = this.app.vault.adapter instanceof obsidian.FileSystemAdapter
            ? this.app.vault.adapter.getBasePath()
            : '/';
        return sysPath.resolve(vaultRoot, rawPath);
    };
    CitationPlugin.prototype.loadLibrary = function () {
        return __awaiter(this, void 0, void 0, function () {
            var filePath;
            var _this = this;
            return __generator(this, function (_a) {
                console.debug('Citation plugin: Reloading library');
                if (this.settings.citationExportPath) {
                    filePath = this.resolveLibraryPath(this.settings.citationExportPath);
                    // Unload current library.
                    this.events.trigger('library-load-start');
                    this.library = null;
                    return [2 /*return*/, obsidian.FileSystemAdapter.readLocalFile(filePath)
                            .then(function (buffer) {
                            // If there is a remaining error message, hide it
                            _this.loadErrorNotifier.hide();
                            // Decode file as UTF-8.
                            var dataView = new DataView(buffer);
                            var decoder = new TextDecoder('utf8');
                            var value = decoder.decode(dataView);
                            return _this.loadWorker.post({
                                databaseRaw: value,
                                databaseType: _this.settings.citationExportFormat,
                            });
                        })
                            .then(function (entries) {
                            var adapter;
                            var idKey;
                            switch (_this.settings.citationExportFormat) {
                                case 'biblatex':
                                    adapter = EntryBibLaTeXAdapter;
                                    idKey = 'key';
                                    break;
                                case 'csl-json':
                                    adapter = EntryCSLAdapter;
                                    idKey = 'id';
                                    break;
                            }
                            _this.library = new Library(Object.fromEntries(entries.map(function (e) { return [e[idKey], new adapter(e)]; })));
                            console.debug("Citation plugin: successfully loaded library with " + _this.library.size + " entries.");
                            _this.events.trigger('library-load-complete');
                            return _this.library;
                        })
                            .catch(function (e) {
                            if (e instanceof WorkerManagerBlocked) {
                                // Silently catch WorkerManager error, which will be thrown if the
                                // library is already being loaded
                                return;
                            }
                            console.error(e);
                            _this.loadErrorNotifier.show();
                            return null;
                        })];
                }
                else {
                    console.warn('Citations plugin: citation export path is not set. Please update plugin settings.');
                }
                return [2 /*return*/];
            });
        });
    };
    Object.defineProperty(CitationPlugin.prototype, "isLibraryLoading", {
        /**
         * Returns true iff the library is currently being loaded on the worker thread.
         */
        get: function () {
            return this.loadWorker.blocked;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CitationPlugin.prototype, "literatureNoteTitleTemplate", {
        get: function () {
            return lib.compile(this.settings.literatureNoteTitleTemplate, this.templateSettings);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CitationPlugin.prototype, "literatureNoteContentTemplate", {
        get: function () {
            return lib.compile(this.settings.literatureNoteContentTemplate, this.templateSettings);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CitationPlugin.prototype, "markdownCitationTemplate", {
        get: function () {
            return lib.compile(this.settings.markdownCitationTemplate, this.templateSettings);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(CitationPlugin.prototype, "alternativeMarkdownCitationTemplate", {
        get: function () {
            return lib.compile(this.settings.alternativeMarkdownCitationTemplate, this.templateSettings);
        },
        enumerable: false,
        configurable: true
    });
    CitationPlugin.prototype.getTitleForCitekey = function (citekey) {
        var unsafeTitle = this.literatureNoteTitleTemplate(this.library.getTemplateVariablesForCitekey(citekey));
        return unsafeTitle.replace(DISALLOWED_FILENAME_CHARACTERS_RE, '_');
    };
    CitationPlugin.prototype.getPathForCitekey = function (citekey) {
        var title = this.getTitleForCitekey(citekey);
        // TODO escape note title
        return sysPath.join(this.settings.literatureNoteFolder, title + ".md");
    };
    CitationPlugin.prototype.getInitialContentForCitekey = function (citekey) {
        return this.literatureNoteContentTemplate(this.library.getTemplateVariablesForCitekey(citekey));
    };
    CitationPlugin.prototype.getMarkdownCitationForCitekey = function (citekey) {
        return this.markdownCitationTemplate(this.library.getTemplateVariablesForCitekey(citekey));
    };
    CitationPlugin.prototype.getAlternativeMarkdownCitationForCitekey = function (citekey) {
        return this.alternativeMarkdownCitationTemplate(this.library.getTemplateVariablesForCitekey(citekey));
    };
    /**
     * Run a case-insensitive search for the literature note file corresponding to
     * the given citekey. If no corresponding file is found, create one.
     */
    CitationPlugin.prototype.getOrCreateLiteratureNoteFile = function (citekey) {
        return __awaiter(this, void 0, void 0, function () {
            var path, normalizedPath, file, matches, exc_1;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        path = this.getPathForCitekey(citekey);
                        normalizedPath = obsidian.normalizePath(path);
                        file = this.app.vault.getAbstractFileByPath(normalizedPath);
                        if (!(file == null)) return [3 /*break*/, 4];
                        matches = this.app.vault
                            .getMarkdownFiles()
                            .filter(function (f) { return f.path.toLowerCase() == normalizedPath.toLowerCase(); });
                        if (!(matches.length > 0)) return [3 /*break*/, 1];
                        file = matches[0];
                        return [3 /*break*/, 4];
                    case 1:
                        _a.trys.push([1, 3, , 4]);
                        return [4 /*yield*/, this.app.vault.create(path, this.getInitialContentForCitekey(citekey))];
                    case 2:
                        file = _a.sent();
                        return [3 /*break*/, 4];
                    case 3:
                        exc_1 = _a.sent();
                        this.literatureNoteErrorNotifier.show();
                        throw exc_1;
                    case 4: return [2 /*return*/, file];
                }
            });
        });
    };
    CitationPlugin.prototype.openLiteratureNote = function (citekey, newPane) {
        return __awaiter(this, void 0, void 0, function () {
            var _this = this;
            return __generator(this, function (_a) {
                this.getOrCreateLiteratureNoteFile(citekey)
                    .then(function (file) {
                    _this.app.workspace.getLeaf(newPane).openFile(file);
                })
                    .catch(console.error);
                return [2 /*return*/];
            });
        });
    };
    CitationPlugin.prototype.insertLiteratureNoteLink = function (citekey) {
        return __awaiter(this, void 0, void 0, function () {
            var _this = this;
            return __generator(this, function (_a) {
                this.getOrCreateLiteratureNoteFile(citekey)
                    .then(function (file) {
                    var useMarkdown = _this.app.vault.getConfig('useMarkdownLinks');
                    var title = _this.getTitleForCitekey(citekey);
                    var linkText;
                    if (useMarkdown) {
                        var uri = encodeURI(_this.app.metadataCache.fileToLinktext(file, '', false));
                        linkText = "[" + title + "](" + uri + ")";
                    }
                    else {
                        linkText = "[[" + title + "]]";
                    }
                    _this.editor.replaceSelection(linkText);
                })
                    .catch(console.error);
                return [2 /*return*/];
            });
        });
    };
    /**
     * Format literature note content for a given reference and insert in the
     * currently active pane.
     */
    CitationPlugin.prototype.insertLiteratureNoteContent = function (citekey) {
        return __awaiter(this, void 0, void 0, function () {
            var content;
            return __generator(this, function (_a) {
                content = this.getInitialContentForCitekey(citekey);
                this.editor.replaceRange(content, this.editor.getCursor());
                return [2 /*return*/];
            });
        });
    };
    CitationPlugin.prototype.insertMarkdownCitation = function (citekey, alternative) {
        if (alternative === void 0) { alternative = false; }
        return __awaiter(this, void 0, void 0, function () {
            var func, citation;
            return __generator(this, function (_a) {
                func = alternative
                    ? this.getAlternativeMarkdownCitationForCitekey
                    : this.getMarkdownCitationForCitekey;
                citation = func.bind(this)(citekey);
                this.editor.replaceRange(citation, this.editor.getCursor());
                return [2 /*return*/];
            });
        });
    };
    return CitationPlugin;
}(obsidian.Plugin));

module.exports = CitationPlugin;


/* nosourcemap */