From c1aa09097556c30a755bb138b7989e4efb65cac0 Mon Sep 17 00:00:00 2001 From: Zane Meyers Date: Tue, 2 Jun 2026 07:51:02 -0400 Subject: [PATCH] vault backup: 2026-06-02 07:51:02 --- .obsidian/community-plugins.json | 6 +- .../obsidian-citation-plugin/data.json | 9 + .../plugins/obsidian-citation-plugin/main.js | 85891 ++++++++++++++++ .../obsidian-citation-plugin/manifest.json | 10 + .../obsidian-citation-plugin/styles.css | 114 + bibliography.bib | 358 + timestamped/2026-06-01_23-33-13.md | 17 + 7 files changed, 86401 insertions(+), 4 deletions(-) create mode 100644 .obsidian/plugins/obsidian-citation-plugin/data.json create mode 100644 .obsidian/plugins/obsidian-citation-plugin/main.js create mode 100644 .obsidian/plugins/obsidian-citation-plugin/manifest.json create mode 100644 .obsidian/plugins/obsidian-citation-plugin/styles.css create mode 100644 bibliography.bib create mode 100644 timestamped/2026-06-01_23-33-13.md diff --git a/.obsidian/community-plugins.json b/.obsidian/community-plugins.json index 18e91b9..aea9ca0 100644 --- a/.obsidian/community-plugins.json +++ b/.obsidian/community-plugins.json @@ -26,8 +26,6 @@ "cmdr", "sheets", "tabout", - "inline-spoilers", - "obsidian-quiet-outline", - "tasknotes", - "daily-notes-editor" + "obsidian-tidy-footnotes", + "obsidian-citation-plugin" ] \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-citation-plugin/data.json b/.obsidian/plugins/obsidian-citation-plugin/data.json new file mode 100644 index 0000000..b9257dd --- /dev/null +++ b/.obsidian/plugins/obsidian-citation-plugin/data.json @@ -0,0 +1,9 @@ +{ + "citationExportFormat": "biblatex", + "literatureNoteTitleTemplate": "@{{citekey}}", + "literatureNoteFolder": "", + "literatureNoteContentTemplate": "---\ntitle: {{title}}\nauthors: {{authorString}}\nyear: {{year}}\n---\n\n", + "markdownCitationTemplate": "[@{{citekey}}]", + "alternativeMarkdownCitationTemplate": "@{{citekey}}", + "citationExportPath": "bibliography.bib" +} \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-citation-plugin/main.js b/.obsidian/plugins/obsidian-citation-plugin/main.js new file mode 100644 index 0000000..bf0fc0f --- /dev/null +++ b/.obsidian/plugins/obsidian-citation-plugin/main.js @@ -0,0 +1,85891 @@ +'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 + * + * 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} patterns + * @param {Array} 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 + * + * 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 + * + * 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 + * + * 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} + */ +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} 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} 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} 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} + */ +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} + */ +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} + */ +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} + */ + 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} items + */ +class DirEntry { + /** + * @param {Path} dir + * @param {Function} removeWatcher + */ + constructor(dir, removeWatcher) { + this.path = dir; + this._removeWatcher = removeWatcher; + /** @type {Set} */ + 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} + */ + 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} */ + this._watched = new Map(); + /** @type {Map} */ + this._closers = new Map(); + /** @type {Set} */ + this._ignoredPaths = new Set(); + + /** @type {Map} */ + this._throttled = new Map(); + + /** @type {Map} */ + 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} 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} 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}. +*/ +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 */ + 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} */ + 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} 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 = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''', + '`': '`', + '=': '=' +}; + +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 '/..' 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, '\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 +}, + "IJ": { + text: "IJ" +}, + "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}" +}, + "ʼ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 +}, + "K": { + 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" +}, + "ff": { + text: "ff" +}, + "fi": { + text: "fi" +}, + "fl": { + text: "fl" +}, + "ffi": { + text: "ffi" +}, + "ffl": { + text: "ffl" +}, + "ſt": { + text: "st" +}, + "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}" +}, + "IJ": { + text: "IJ" +}, + "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}" +}, + "ʼ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}" +}, + "K": { + 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" +}, + "ff": { + text: "ff" +}, + "fi": { + text: "fi" +}, + "fl": { + text: "fl" +}, + "ffi": { + text: "ffi" +}, + "ffl": { + text: "ffl" +}, + "ſt": { + text: "st" +}, + "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: '', close: '' }, + sup: { open: '', close: '' }, + bold: { open: '', close: '' }, + italics: { open: '', close: '' }, + smallCaps: { open: '', close: '' }, + caseProtect: { open: '', close: '' }, + 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: ``, close: `` }; + } + 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: '
  • ', 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, '&').replace(//g, '>'); + } + 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: '
      ', itemize: '
        ' }[node.env]; + this.convert_block(Object.assign(Object.assign({}, node), { kind: 'Block', markup: {} })); + this.field.text += { enumerate: '
    ', itemize: '' }[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}`; + } + script = script.replace(new RegExp(`<${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 || '') + } +} +/** + * 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, '\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 + }, + "IJ": { + text: "IJ" + }, + "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}" + }, + "ʼ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 + }, + "K": { + 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" + }, + "ff": { + text: "ff" + }, + "fi": { + text: "fi" + }, + "fl": { + text: "fl" + }, + "ffi": { + text: "ffi" + }, + "ffl": { + text: "ffl" + }, + "ſt": { + text: "st" + }, + "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}" + }, + "IJ": { + text: "IJ" + }, + "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}" + }, + "ʼ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}" + }, + "K": { + 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" + }, + "ff": { + text: "ff" + }, + "fi": { + text: "fi" + }, + "fl": { + text: "fl" + }, + "ffi": { + text: "ffi" + }, + "ffl": { + text: "ffl" + }, + "ſt": { + text: "st" + }, + "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: '', close: '' }, + sup: { open: '', close: '' }, + bold: { open: '', close: '' }, + italics: { open: '', close: '' }, + smallCaps: { open: '', close: '' }, + caseProtect: { open: '', close: '' }, + 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: ``, close: `` }; + } + 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: '
  • ', 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, '&').replace(//g, '>'); + } + 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: '
      ', itemize: '
        ' }[node.env]; + this.convert_block(Object.assign(Object.assign({}, node), { kind: 'Block', markup: {} })); + this.field.text += { enumerate: '
    ', itemize: '' }[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}`; + } + script = script.replace(new RegExp(`<${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 || '') + } + } + /** + * 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,{"version":3,"file":"worker.js","sources":["worker://web-worker/node_modules/promise-worker/register.js","worker://web-worker/node_modules/tslib/tslib.es6.js","worker://web-worker/node_modules/@retorquere/bibtex-parser/grammar.js","worker://web-worker/node_modules/@retorquere/bibtex-parser/chunker.js","worker://web-worker/node_modules/unicode2latex/index.js","worker://web-worker/node_modules/xregexp/tools/output/categories.js","worker://web-worker/node_modules/@retorquere/bibtex-parser/jabref.js","worker://web-worker/node_modules/@retorquere/bibtex-parser/index.js","src/types.ts","src/worker.ts"],"sourcesContent":["'use strict'\n\nfunction isPromise (obj) {\n  // via https://unpkg.com/is-promise@2.1.0/index.js\n  return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function'\n}\n\nfunction registerPromiseWorker (callback) {\n  function postOutgoingMessage (e, messageId, error, result) {\n    function postMessage (msg) {\n      /* istanbul ignore if */\n      if (typeof self.postMessage !== 'function') { // service worker\n        e.ports[0].postMessage(msg)\n      } else { // web worker\n        self.postMessage(msg)\n      }\n    }\n    if (error) {\n      /* istanbul ignore else */\n      if (typeof console !== 'undefined' && 'error' in console) {\n        // This is to make errors easier to debug. I think it's important\n        // enough to just leave here without giving the user an option\n        // to silence it.\n        console.error('Worker caught an error:', error)\n      }\n      postMessage([messageId, {\n        message: error.message\n      }])\n    } else {\n      postMessage([messageId, null, result])\n    }\n  }\n\n  function tryCatchFunc (callback, message) {\n    try {\n      return { res: callback(message) }\n    } catch (e) {\n      return { err: e }\n    }\n  }\n\n  function handleIncomingMessage (e, callback, messageId, message) {\n    var result = tryCatchFunc(callback, message)\n\n    if (result.err) {\n      postOutgoingMessage(e, messageId, result.err)\n    } else if (!isPromise(result.res)) {\n      postOutgoingMessage(e, messageId, null, result.res)\n    } else {\n      result.res.then(function (finalResult) {\n        postOutgoingMessage(e, messageId, null, finalResult)\n      }, function (finalError) {\n        postOutgoingMessage(e, messageId, finalError)\n      })\n    }\n  }\n\n  function onIncomingMessage (e) {\n    var payload = e.data\n    if (!Array.isArray(payload) || payload.length !== 2) {\n      // message doens't match communication format; ignore\n      return\n    }\n    var messageId = payload[0]\n    var message = payload[1]\n\n    if (typeof callback !== 'function') {\n      postOutgoingMessage(e, messageId, new Error(\n        'Please pass a function into register().'))\n    } else {\n      handleIncomingMessage(e, callback, messageId, message)\n    }\n  }\n\n  self.addEventListener('message', onIncomingMessage)\n}\n\nmodule.exports = registerPromiseWorker\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            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;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","/*\n * Generated by PEG.js 0.10.0.\n *\n * http://pegjs.org/\n */\n\n\"use strict\";\n\nfunction peg$subclass(child, parent) {\n  function ctor() { this.constructor = child; }\n  ctor.prototype = parent.prototype;\n  child.prototype = new ctor();\n}\n\nfunction peg$SyntaxError(message, expected, found, location) {\n  this.message  = message;\n  this.expected = expected;\n  this.found    = found;\n  this.location = location;\n  this.name     = \"SyntaxError\";\n\n  if (typeof Error.captureStackTrace === \"function\") {\n    Error.captureStackTrace(this, peg$SyntaxError);\n  }\n}\n\npeg$subclass(peg$SyntaxError, Error);\n\npeg$SyntaxError.buildMessage = function(expected, found) {\n  var DESCRIBE_EXPECTATION_FNS = {\n        literal: function(expectation) {\n          return \"\\\"\" + literalEscape(expectation.text) + \"\\\"\";\n        },\n\n        \"class\": function(expectation) {\n          var escapedParts = \"\",\n              i;\n\n          for (i = 0; i < expectation.parts.length; i++) {\n            escapedParts += expectation.parts[i] instanceof Array\n              ? classEscape(expectation.parts[i][0]) + \"-\" + classEscape(expectation.parts[i][1])\n              : classEscape(expectation.parts[i]);\n          }\n\n          return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts + \"]\";\n        },\n\n        any: function(expectation) {\n          return \"any character\";\n        },\n\n        end: function(expectation) {\n          return \"end of input\";\n        },\n\n        other: function(expectation) {\n          return expectation.description;\n        }\n      };\n\n  function hex(ch) {\n    return ch.charCodeAt(0).toString(16).toUpperCase();\n  }\n\n  function literalEscape(s) {\n    return s\n      .replace(/\\\\/g, '\\\\\\\\')\n      .replace(/\"/g,  '\\\\\"')\n      .replace(/\\0/g, '\\\\0')\n      .replace(/\\t/g, '\\\\t')\n      .replace(/\\n/g, '\\\\n')\n      .replace(/\\r/g, '\\\\r')\n      .replace(/[\\x00-\\x0F]/g,          function(ch) { return '\\\\x0' + hex(ch); })\n      .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return '\\\\x'  + hex(ch); });\n  }\n\n  function classEscape(s) {\n    return s\n      .replace(/\\\\/g, '\\\\\\\\')\n      .replace(/\\]/g, '\\\\]')\n      .replace(/\\^/g, '\\\\^')\n      .replace(/-/g,  '\\\\-')\n      .replace(/\\0/g, '\\\\0')\n      .replace(/\\t/g, '\\\\t')\n      .replace(/\\n/g, '\\\\n')\n      .replace(/\\r/g, '\\\\r')\n      .replace(/[\\x00-\\x0F]/g,          function(ch) { return '\\\\x0' + hex(ch); })\n      .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function(ch) { return '\\\\x'  + hex(ch); });\n  }\n\n  function describeExpectation(expectation) {\n    return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n  }\n\n  function describeExpected(expected) {\n    var descriptions = new Array(expected.length),\n        i, j;\n\n    for (i = 0; i < expected.length; i++) {\n      descriptions[i] = describeExpectation(expected[i]);\n    }\n\n    descriptions.sort();\n\n    if (descriptions.length > 0) {\n      for (i = 1, j = 1; i < descriptions.length; i++) {\n        if (descriptions[i - 1] !== descriptions[i]) {\n          descriptions[j] = descriptions[i];\n          j++;\n        }\n      }\n      descriptions.length = j;\n    }\n\n    switch (descriptions.length) {\n      case 1:\n        return descriptions[0];\n\n      case 2:\n        return descriptions[0] + \" or \" + descriptions[1];\n\n      default:\n        return descriptions.slice(0, -1).join(\", \")\n          + \", or \"\n          + descriptions[descriptions.length - 1];\n    }\n  }\n\n  function describeFound(found) {\n    return found ? \"\\\"\" + literalEscape(found) + \"\\\"\" : \"end of input\";\n  }\n\n  return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n};\n\nfunction peg$parse(input, options) {\n  options = options !== void 0 ? options : {};\n\n  var peg$FAILED = {},\n\n      peg$startRuleFunctions = { Bibliography: peg$parseBibliography },\n      peg$startRuleFunction  = peg$parseBibliography,\n\n      peg$c0 = function(r) {\n          return {\n            kind: 'Bibliography',\n            loc: location(),\n            source: text(),\n            children: r,\n          }\n        },\n      peg$c1 = \"@\",\n      peg$c2 = peg$literalExpectation(\"@\", false),\n      peg$c3 = \"comment\",\n      peg$c4 = peg$literalExpectation(\"comment\", true),\n      peg$c5 = function(v) {\n          return {\n            kind: 'BracedComment',\n            loc: location(),\n            source: text(),\n            value: v.slice(1, -1),\n          }\n        },\n      peg$c6 = /^[^\\n\\r]/,\n      peg$c7 = peg$classExpectation([\"\\n\", \"\\r\"], true, false),\n      peg$c8 = /^[\\n\\r]/,\n      peg$c9 = peg$classExpectation([\"\\n\", \"\\r\"], false, false),\n      peg$c10 = function(v) {\n          return {\n            kind: 'LineComment',\n            loc: location(),\n            source: text(),\n            value: normalizeWhitespace(v),\n          }\n          },\n      peg$c11 = /^[^@]/,\n      peg$c12 = peg$classExpectation([\"@\"], true, false),\n      peg$c13 = function(v) {\n          return {\n            kind: 'NonEntryText',\n            loc: location(),\n            source: text(),\n            value: normalizeWhitespace(v),\n          }\n        },\n      peg$c14 = function(n) { return n; },\n      peg$c15 = \"{\",\n      peg$c16 = peg$literalExpectation(\"{\", false),\n      peg$c17 = /^[^{}]/,\n      peg$c18 = peg$classExpectation([\"{\", \"}\"], true, false),\n      peg$c19 = \"}\",\n      peg$c20 = peg$literalExpectation(\"}\", false),\n      peg$c21 = function(comment) { return '{' + comment.join('') + '}' },\n      peg$c22 = /^[A-Za-z]/,\n      peg$c23 = peg$classExpectation([[\"A\", \"Z\"], [\"a\", \"z\"]], false, false),\n      peg$c24 = /^[({]/,\n      peg$c25 = peg$classExpectation([\"(\", \"{\"], false, false),\n      peg$c26 = /^[})]/,\n      peg$c27 = peg$classExpectation([\"}\", \")\"], false, false),\n      peg$c28 = function(type, id, fields) {\n          return {\n            kind: 'Entry',\n            id: id || '',\n            type: type.toLowerCase(),\n            loc: location(),\n            source: text(),\n            fields: fields,\n          }\n        },\n      peg$c29 = \"preamble\",\n      peg$c30 = peg$literalExpectation(\"preamble\", true),\n      peg$c31 = function(opener, v, closer) {\n          switch (opener + closer) {\n            case '{}':\n            case '()':\n              break\n            default:\n              throw new Error(`Unbalanced opener-closer for preamble: ${opener}...${closer}`)\n              break\n          }\n          return {\n            kind: 'PreambleExpression',\n            loc: location(),\n            source: text(),\n            value: v.reduce((a, b) => a.concat(b), []),\n          }\n        },\n      peg$c32 = \"string\",\n      peg$c33 = peg$literalExpectation(\"string\", true),\n      peg$c34 = function(k, v) {\n          return {\n            kind: 'StringDeclaration',\n            loc: location(),\n            source: text(),\n            name: k,\n            value: v.reduce((a, b) => a.concat(b), []),\n          }\n        },\n      peg$c35 = /^[^ \\t\\r\\n,]/,\n      peg$c36 = peg$classExpectation([\" \", \"\\t\", \"\\r\", \"\\n\", \",\"], true, false),\n      peg$c37 = \",\",\n      peg$c38 = peg$literalExpectation(\",\", false),\n      peg$c39 = function(id) { return id; },\n      peg$c40 = function(name) { return isVerbatimField(name) && unnestFields.includes(name) },\n      peg$c41 = function(name, value) {\n          // because this was abused so much, many processors treat double-outer-braces as single\n          return {\n            kind: 'Field',\n            loc: location(),\n            source: text(),\n            name: name,\n            loc: location(),\n            value: [ protect(value) ]\n          }\n        },\n      peg$c42 = function(name) { return isVerbatimField(name) },\n      peg$c43 = function(name, value) {\n          return {\n            kind: 'Field',\n            loc: location(),\n            source: text(),\n            name: name,\n            loc: location(),\n            value: [ protect(value) ]\n          }\n        },\n      peg$c44 = function(name, value) {\n          // because this was abused so much, many processors treat double-outer-braces as single\n          if (unnestFields.includes(name) && Array.isArray(value) && value.length === 1 && value[0].kind === 'Block') {\n            if (options.unnestMode === 'preserve') {\n              value[0].case = 'preserve'\n            } else {\n              value = value[0].value\n            }\n          }\n\n          return handle_markup_switches({\n            kind: 'Field',\n            loc: location(),\n            source: text(),\n            name: name,\n            value: value,\n          })\n        },\n      peg$c45 = /^[_:a-zA-Z0-9\\-]/,\n      peg$c46 = peg$classExpectation([\"_\", \":\", [\"a\", \"z\"], [\"A\", \"Z\"], [\"0\", \"9\"], \"-\"], false, false),\n      peg$c47 = function(name) { return name.toLowerCase() },\n      peg$c48 = \"\\\"\",\n      peg$c49 = peg$literalExpectation(\"\\\"\", false),\n      peg$c50 = function(v) {\n          v = v || {\n            kind: 'Text',\n            loc: location(),\n            source: text(),\n            value: '',\n          }\n          v.mode = 'verbatim'\n          return basicTextConversions(v)\n        },\n      peg$c51 = function(v) {\n          return basicTextConversions({\n            kind: 'Text',\n            loc: location(),\n            source: text(),\n            value: v.join('').trim(),\n            mode: 'verbatim',\n          })\n        },\n      peg$c52 = function(v) { return v },\n      peg$c53 = function(v) { return '{' + v.join('') + '}' },\n      peg$c54 = function() { return math.set(false) },\n      peg$c55 = function(v) {\n          return v.reduce((a, b) => a.concat(b), []);\n        },\n      peg$c56 = function(v) { return v; },\n      peg$c57 = \"{\\\\verb\",\n      peg$c58 = peg$literalExpectation(\"{\\\\verb\", false),\n      peg$c59 = /^[a-zA-Z]/,\n      peg$c60 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"]], false, false),\n      peg$c61 = /^[^\\^_${}\\\\]/,\n      peg$c62 = peg$classExpectation([\"^\", \"_\", \"$\", \"{\", \"}\", \"\\\\\"], true, false),\n      peg$c63 = function(v) {\n          return basicTextConversions({\n            kind: 'Text',\n            loc: location(),\n            source: text(),\n            value: normalizeWhitespace(v),\n            mode: math.on ? 'math' : 'text',\n          })\n        },\n      peg$c64 = /^[^\\^_${}\"\\\\]/,\n      peg$c65 = peg$classExpectation([\"^\", \"_\", \"$\", \"{\", \"}\", \"\\\"\", \"\\\\\"], true, false),\n      peg$c66 = /^[0-9]/,\n      peg$c67 = peg$classExpectation([[\"0\", \"9\"]], false, false),\n      peg$c68 = function(v) {\n          return {\n            kind: 'Number',\n            loc: location(),\n            source: text(),\n            value: parseInt(v, 10),\n          }\n        },\n      peg$c69 = function(v) {\n          return {\n            kind: 'StringReference',\n            loc: location(),\n            source: text(),\n            name: v,\n          }\n        },\n      peg$c70 = \"\\\\begin{\",\n      peg$c71 = peg$literalExpectation(\"\\\\begin{\", false),\n      peg$c72 = /^[a-zA-Z0-9]/,\n      peg$c73 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"], [\"0\", \"9\"]], false, false),\n      peg$c74 = \"\\\\end{\",\n      peg$c75 = peg$literalExpectation(\"\\\\end{\", false),\n      peg$c76 = function(env, v, cenv) { return env === cenv },\n      peg$c77 = function(env, v, cenv) {\n          if (markup[env]) {\n            return {\n              kind: 'Block',\n              loc: location(),\n              source: text(),\n              value: v,\n              markup: { [markup[env]]: true },\n            }\n          } else {\n            return {\n              kind: 'Environment',\n              loc: location(),\n              source: text(),\n              value: v,\n              env: env,\n            }\n          }\n        },\n      peg$c78 = \"{\\\\\",\n      peg$c79 = peg$literalExpectation(\"{\\\\\", false),\n      peg$c80 = \"\\\\\",\n      peg$c81 = peg$literalExpectation(\"\\\\\", false),\n      peg$c82 = /^[ij]/,\n      peg$c83 = peg$classExpectation([\"i\", \"j\"], false, false),\n      peg$c84 = function(mark, char) {\n          return {\n            kind: 'DiacriticCommand',\n            loc: location(),\n            source: text(),\n            mark: mark,\n            dotless: !!char[1],\n            character: char[1] || char[0],\n          }\n        },\n      peg$c85 = function(v) {\n            return basicTextConversions({\n              kind: 'Text',\n              loc: location(),\n              source: text(),\n              value: v.join('').trim(),\n              mode: 'verbatim',\n            })\n        },\n      peg$c86 = function(v) {\n          const block = {\n            kind: 'Block',\n            loc: location(),\n            source: text(),\n            value: v,\n            markup: {},\n            case: 'protect',\n          }\n\n          let leadingcmd = block.value.length && (block.value[0].kind.endsWith('Command') || block.value[0].kind === 'Environment') ? block.value[0] : null\n          let leadingcmdblockarg = leadingcmd\n            && leadingcmd.kind === 'RegularCommand'\n            && leadingcmd.arguments.required.length\n            && leadingcmd.arguments.required[0].kind === 'Block'\n            && leadingcmd.arguments.required[0]\n\n          // https://github.com/retorquere/zotero-better-bibtex/issues/541#issuecomment-240156274\n          if (leadingcmd) {\n            delete block.case\n\n            // command with a block cancels out case protection with containing block\n            // if a smallcaps block has set case to 'preserve' we want to keep this\n            if (leadingcmdblockarg && leadingcmdblockarg.case === 'protect') delete leadingcmdblockarg.case\n\n            // \\sl, \\it etc\n            if (markup[leadingcmd.command]) {\n              block.markup[markup[leadingcmd.command]] = true\n              block.value.shift()\n            }\n          }\n\n          return handle_markup_switches(block)\n        },\n      peg$c87 = function() { return !math.on },\n      peg$c88 = \"$\",\n      peg$c89 = peg$literalExpectation(\"$\", false),\n      peg$c90 = \"$$\",\n      peg$c91 = peg$literalExpectation(\"$$\", false),\n      peg$c92 = function(mode) { return math.set(true) },\n      peg$c93 = function(mode, v) { return math.set(false) },\n      peg$c94 = function(mode, v) {\n          return {\n            kind: mode == '$$' ? 'DisplayMath' : 'InlineMath',\n            loc: location(),\n            source: text(),\n            value: v,\n            case: 'protect',\n            markup: {},\n          }\n        },\n      peg$c95 = \"%\",\n      peg$c96 = peg$literalExpectation(\"%\", false),\n      peg$c97 = /^[^\\r\\n]/,\n      peg$c98 = peg$classExpectation([\"\\r\", \"\\n\"], true, false),\n      peg$c99 = function(v) {\n          return {\n            kind: 'LineComment',\n            loc: location(),\n            source: text(),\n            value: v,\n          }\n        },\n      peg$c100 = /^[_\\^]/,\n      peg$c101 = peg$classExpectation([\"_\", \"^\"], false, false),\n      peg$c102 = function(mode, v) {\n          if (v.kind === 'Block') v = v.value\n\n          return {\n            kind: mode === '_' ? 'SubscriptCommand' : 'SuperscriptCommand',\n            loc: location(),\n            source: text(),\n            value: v,\n          }\n        },\n      peg$c103 = function(mark, v) {\n          return {\n            kind: 'RegularCommand',\n            loc: location(),\n            source: text(),\n            command: mark,\n            arguments: {\n              optional: [],\n              required: [ protect(v) ],\n            },\n          }\n        },\n      peg$c104 = /^[^A-Za-z0-9\\t\\r\\n]/,\n      peg$c105 = peg$classExpectation([[\"A\", \"Z\"], [\"a\", \"z\"], [\"0\", \"9\"], \"\\t\", \"\\r\", \"\\n\"], true, false),\n      peg$c106 = function(v) {\n          return {\n            kind: 'SymbolCommand',\n            loc: location(),\n            source: text(),\n            command: v,\n          }\n        },\n      peg$c107 = \"newcommand\",\n      peg$c108 = peg$literalExpectation(\"newcommand\", false),\n      peg$c109 = function(cmd, name) { return name.value.length == 1 && name.value[0].kind === 'RegularCommand' },\n      peg$c110 = function(cmd, name, optional, def) {\n          return {\n            kind: 'RegularCommand',\n            loc: location(),\n            source: text(),\n            command: cmd,\n            arguments: {\n              optional: [],\n              required: [name, def],\n            },\n          }\n        },\n      peg$c111 = \"begin\",\n      peg$c112 = peg$literalExpectation(\"begin\", false),\n      peg$c113 = \"end\",\n      peg$c114 = peg$literalExpectation(\"end\", false),\n      peg$c115 = function(cmd) { return verbatimCommands.includes(cmd) && (has_arguments[cmd] === 2) },\n      peg$c116 = function(cmd, optional, req1, req2) {\n          return {\n            kind: 'RegularCommand',\n            loc: location(),\n            source: text(),\n            command: cmd,\n            arguments: {\n              optional: optional,\n              required: [protect(req1), protect(req2)],\n            },\n          }\n        },\n      peg$c117 = function(cmd) { return verbatimCommands.includes(cmd) && (has_arguments[cmd] === 1) },\n      peg$c118 = function(cmd, optional, req) {\n          return {\n            kind: 'RegularCommand',\n            loc: location(),\n            source: text(),\n            command: cmd,\n            arguments: {\n              optional: optional,\n              required: [protect(req)],\n            },\n          }\n        },\n      peg$c119 = function(cmd) { return (has_arguments[cmd] === 2) },\n      peg$c120 = function(cmd, optional, req1, req2) {\n          return {\n            kind: 'RegularCommand',\n            loc: location(),\n            source: text(),\n            command: cmd,\n            arguments: {\n              optional: optional,\n              required: [req1, req2],\n            },\n          }\n        },\n      peg$c121 = function(cmd) { return (has_arguments[cmd] === 1) },\n      peg$c122 = function(cmd, optional, req) {\n          let m\n          if (req.kind === 'Block') {\n            switch (cmd) {\n              case 'textsuperscript':\n              case 'sp':\n                req.markup.sup = true\n                break\n              case 'textsubscript':\n              case 'sb':\n                req.markup.sub = true\n                break\n              case 'textsc':\n                req.markup.smallCaps = true\n                break\n              case 'enquote':\n              case 'mkbibquote':\n                req.markup.enquote = true\n                break\n              case 'textbf':\n              case 'mkbibbold':\n                req.markup.bold = true\n                break\n              case 'emph':\n              case 'textit':\n              case 'mkbibitalic':\n              case 'mkbibemph':\n                req.markup.italics = true\n                break\n              default:\n                if (m = cmd.match(/^((sub)*)section$/)) {\n                  req.markup[`h${(m[1].length / 3) + 1}`] = true\n                }\n            }\n          }\n\n          // ignore case stuff on bibcyr\n          if (cmd === 'bibcyr') delete req.case\n\n          return {\n            kind: 'RegularCommand',\n            loc: location(),\n            source: text(),\n            command: cmd,\n            arguments: {\n              optional: optional,\n              required: [req],\n            }\n          }\n        },\n      peg$c123 = function(cmd, optional) {\n          return {\n            kind: 'RegularCommand',\n            loc: location(),\n            source: text(),\n            command: cmd,\n            arguments: {\n              optional: optional,\n              required: [],\n            }\n          }\n        },\n      peg$c124 = \"[\",\n      peg$c125 = peg$literalExpectation(\"[\", false),\n      peg$c126 = /^[^\\]]/,\n      peg$c127 = peg$classExpectation([\"]\"], true, false),\n      peg$c128 = \"]\",\n      peg$c129 = peg$literalExpectation(\"]\", false),\n      peg$c130 = function(v) {\n          return basicTextConversions({\n            kind: 'Text', // this isn't really correct but I don't need these right now\n            loc: location(),\n            source: text(),\n            value: v,\n            mode: math.on ? 'math' : 'text',\n          })\n        },\n      peg$c131 = /^[^ \\t\\^_${}\\\\]/,\n      peg$c132 = peg$classExpectation([\" \", \"\\t\", \"^\", \"_\", \"$\", \"{\", \"}\", \"\\\\\"], true, false),\n      peg$c133 = function(v) {\n          return basicTextConversions({\n            kind: 'Text',\n            loc: location(),\n            source: text(),\n            value: normalizeWhitespace([v]),\n            mode: math.on ? 'math' : 'text',\n          })\n        },\n      peg$c134 = /^[a-zA-Z\\-_]/,\n      peg$c135 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"], \"-\", \"_\"], false, false),\n      peg$c136 = /^[a-zA-Z0-9\\-&_:]/,\n      peg$c137 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"], [\"0\", \"9\"], \"-\", \"&\", \"_\", \":\"], false, false),\n      peg$c138 = /^['`\"=~\\^.]/,\n      peg$c139 = peg$classExpectation([\"'\", \"`\", \"\\\"\", \"=\", \"~\", \"^\", \".\"], false, false),\n      peg$c140 = /^['`\"=~\\^.cbuvdrHk]/,\n      peg$c141 = peg$classExpectation([\"'\", \"`\", \"\\\"\", \"=\", \"~\", \"^\", \".\", \"c\", \"b\", \"u\", \"v\", \"d\", \"r\", \"H\", \"k\"], false, false),\n      peg$c142 = \"=\",\n      peg$c143 = peg$literalExpectation(\"=\", false),\n      peg$c144 = \"#\",\n      peg$c145 = peg$literalExpectation(\"#\", false),\n      peg$c146 = /^[\\r\\n]/,\n      peg$c147 = peg$classExpectation([\"\\r\", \"\\n\"], false, false),\n      peg$c148 = peg$otherExpectation(\"Mandatory Horizontal Whitespace\"),\n      peg$c149 = /^[ \\t]/,\n      peg$c150 = peg$classExpectation([\" \", \"\\t\"], false, false),\n      peg$c151 = peg$otherExpectation(\"Optional Horizontal Whitespace\"),\n      peg$c152 = peg$otherExpectation(\"Mandatory Vertical Whitespace\"),\n      peg$c153 = peg$otherExpectation(\"Optional Vertical Whitespace\"),\n      peg$c154 = peg$otherExpectation(\"Mandatory Whitespace\"),\n      peg$c155 = /^[ \\t\\n\\r]/,\n      peg$c156 = peg$classExpectation([\" \", \"\\t\", \"\\n\", \"\\r\"], false, false),\n      peg$c157 = peg$otherExpectation(\"Optional Whitespace\"),\n\n      peg$currPos          = 0,\n      peg$savedPos         = 0,\n      peg$posDetailsCache  = [{ line: 1, column: 1 }],\n      peg$maxFailPos       = 0,\n      peg$maxFailExpected  = [],\n      peg$silentFails      = 0,\n\n      peg$result;\n\n  if (\"startRule\" in options) {\n    if (!(options.startRule in peg$startRuleFunctions)) {\n      throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n    }\n\n    peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n  }\n\n  function text() {\n    return input.substring(peg$savedPos, peg$currPos);\n  }\n\n  function location() {\n    return peg$computeLocation(peg$savedPos, peg$currPos);\n  }\n\n  function expected(description, location) {\n    location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos)\n\n    throw peg$buildStructuredError(\n      [peg$otherExpectation(description)],\n      input.substring(peg$savedPos, peg$currPos),\n      location\n    );\n  }\n\n  function error(message, location) {\n    location = location !== void 0 ? location : peg$computeLocation(peg$savedPos, peg$currPos)\n\n    throw peg$buildSimpleError(message, location);\n  }\n\n  function peg$literalExpectation(text, ignoreCase) {\n    return { type: \"literal\", text: text, ignoreCase: ignoreCase };\n  }\n\n  function peg$classExpectation(parts, inverted, ignoreCase) {\n    return { type: \"class\", parts: parts, inverted: inverted, ignoreCase: ignoreCase };\n  }\n\n  function peg$anyExpectation() {\n    return { type: \"any\" };\n  }\n\n  function peg$endExpectation() {\n    return { type: \"end\" };\n  }\n\n  function peg$otherExpectation(description) {\n    return { type: \"other\", description: description };\n  }\n\n  function peg$computePosDetails(pos) {\n    var details = peg$posDetailsCache[pos], p;\n\n    if (details) {\n      return details;\n    } else {\n      p = pos - 1;\n      while (!peg$posDetailsCache[p]) {\n        p--;\n      }\n\n      details = peg$posDetailsCache[p];\n      details = {\n        line:   details.line,\n        column: details.column\n      };\n\n      while (p < pos) {\n        if (input.charCodeAt(p) === 10) {\n          details.line++;\n          details.column = 1;\n        } else {\n          details.column++;\n        }\n\n        p++;\n      }\n\n      peg$posDetailsCache[pos] = details;\n      return details;\n    }\n  }\n\n  function peg$computeLocation(startPos, endPos) {\n    var startPosDetails = peg$computePosDetails(startPos),\n        endPosDetails   = peg$computePosDetails(endPos);\n\n    return {\n      start: {\n        offset: startPos,\n        line:   startPosDetails.line,\n        column: startPosDetails.column\n      },\n      end: {\n        offset: endPos,\n        line:   endPosDetails.line,\n        column: endPosDetails.column\n      }\n    };\n  }\n\n  function peg$fail(expected) {\n    if (peg$currPos < peg$maxFailPos) { return; }\n\n    if (peg$currPos > peg$maxFailPos) {\n      peg$maxFailPos = peg$currPos;\n      peg$maxFailExpected = [];\n    }\n\n    peg$maxFailExpected.push(expected);\n  }\n\n  function peg$buildSimpleError(message, location) {\n    return new peg$SyntaxError(message, null, null, location);\n  }\n\n  function peg$buildStructuredError(expected, found, location) {\n    return new peg$SyntaxError(\n      peg$SyntaxError.buildMessage(expected, found),\n      expected,\n      found,\n      location\n    );\n  }\n\n  function peg$parseBibliography() {\n    var s0, s1, s2, s3;\n\n    s0 = peg$currPos;\n    s1 = peg$parse__();\n    if (s1 !== peg$FAILED) {\n      s2 = [];\n      s3 = peg$parseNode();\n      while (s3 !== peg$FAILED) {\n        s2.push(s3);\n        s3 = peg$parseNode();\n      }\n      if (s2 !== peg$FAILED) {\n        s3 = peg$parse__();\n        if (s3 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c0(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseComment() {\n    var s0, s1, s2, s3, s4, s5, s6, s7;\n\n    s0 = peg$currPos;\n    if (input.charCodeAt(peg$currPos) === 64) {\n      s1 = peg$c1;\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c2); }\n    }\n    if (s1 !== peg$FAILED) {\n      s2 = peg$parse__();\n      if (s2 !== peg$FAILED) {\n        if (input.substr(peg$currPos, 7).toLowerCase() === peg$c3) {\n          s3 = input.substr(peg$currPos, 7);\n          peg$currPos += 7;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c4); }\n        }\n        if (s3 !== peg$FAILED) {\n          s4 = peg$parse__h();\n          if (s4 !== peg$FAILED) {\n            s5 = peg$parseBracedComment();\n            if (s5 !== peg$FAILED) {\n              peg$savedPos = s0;\n              s1 = peg$c5(s5);\n              s0 = s1;\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n    if (s0 === peg$FAILED) {\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 64) {\n        s1 = peg$c1;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c2); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parse__();\n        if (s2 !== peg$FAILED) {\n          if (input.substr(peg$currPos, 7).toLowerCase() === peg$c3) {\n            s3 = input.substr(peg$currPos, 7);\n            peg$currPos += 7;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c4); }\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parse__h();\n            if (s4 !== peg$FAILED) {\n              s5 = [];\n              if (peg$c6.test(input.charAt(peg$currPos))) {\n                s6 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s6 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c7); }\n              }\n              while (s6 !== peg$FAILED) {\n                s5.push(s6);\n                if (peg$c6.test(input.charAt(peg$currPos))) {\n                  s6 = input.charAt(peg$currPos);\n                  peg$currPos++;\n                } else {\n                  s6 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c7); }\n                }\n              }\n              if (s5 !== peg$FAILED) {\n                s6 = [];\n                if (peg$c8.test(input.charAt(peg$currPos))) {\n                  s7 = input.charAt(peg$currPos);\n                  peg$currPos++;\n                } else {\n                  s7 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c9); }\n                }\n                while (s7 !== peg$FAILED) {\n                  s6.push(s7);\n                  if (peg$c8.test(input.charAt(peg$currPos))) {\n                    s7 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                  } else {\n                    s7 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c9); }\n                  }\n                }\n                if (s6 !== peg$FAILED) {\n                  peg$savedPos = s0;\n                  s1 = peg$c10(s5);\n                  s0 = s1;\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = peg$currPos;\n        if (peg$c11.test(input.charAt(peg$currPos))) {\n          s2 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c12); }\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = [];\n          if (peg$c6.test(input.charAt(peg$currPos))) {\n            s4 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s4 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c7); }\n          }\n          while (s4 !== peg$FAILED) {\n            s3.push(s4);\n            if (peg$c6.test(input.charAt(peg$currPos))) {\n              s4 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s4 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c7); }\n            }\n          }\n          if (s3 !== peg$FAILED) {\n            s2 = [s2, s3];\n            s1 = s2;\n          } else {\n            peg$currPos = s1;\n            s1 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s1;\n          s1 = peg$FAILED;\n        }\n        if (s1 !== peg$FAILED) {\n          s2 = [];\n          if (peg$c8.test(input.charAt(peg$currPos))) {\n            s3 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c9); }\n          }\n          while (s3 !== peg$FAILED) {\n            s2.push(s3);\n            if (peg$c8.test(input.charAt(peg$currPos))) {\n              s3 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s3 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c9); }\n            }\n          }\n          if (s2 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c13(s1);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      }\n    }\n\n    return s0;\n  }\n\n  function peg$parseNode() {\n    var s0, s1;\n\n    s0 = peg$currPos;\n    s1 = peg$parseComment();\n    if (s1 === peg$FAILED) {\n      s1 = peg$parsePreambleExpression();\n      if (s1 === peg$FAILED) {\n        s1 = peg$parseStringDeclaration();\n        if (s1 === peg$FAILED) {\n          s1 = peg$parseEntry();\n        }\n      }\n    }\n    if (s1 !== peg$FAILED) {\n      peg$savedPos = s0;\n      s1 = peg$c14(s1);\n    }\n    s0 = s1;\n\n    return s0;\n  }\n\n  function peg$parseBracedComment() {\n    var s0, s1, s2, s3;\n\n    s0 = peg$currPos;\n    if (input.charCodeAt(peg$currPos) === 123) {\n      s1 = peg$c15;\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c16); }\n    }\n    if (s1 !== peg$FAILED) {\n      s2 = [];\n      if (peg$c17.test(input.charAt(peg$currPos))) {\n        s3 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s3 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c18); }\n      }\n      if (s3 === peg$FAILED) {\n        s3 = peg$parseBracedComment();\n      }\n      while (s3 !== peg$FAILED) {\n        s2.push(s3);\n        if (peg$c17.test(input.charAt(peg$currPos))) {\n          s3 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c18); }\n        }\n        if (s3 === peg$FAILED) {\n          s3 = peg$parseBracedComment();\n        }\n      }\n      if (s2 !== peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 125) {\n          s3 = peg$c19;\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c20); }\n        }\n        if (s3 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c21(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseEntry() {\n    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;\n\n    s0 = peg$currPos;\n    if (input.charCodeAt(peg$currPos) === 64) {\n      s1 = peg$c1;\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c2); }\n    }\n    if (s1 !== peg$FAILED) {\n      s2 = peg$parse__();\n      if (s2 !== peg$FAILED) {\n        s3 = peg$currPos;\n        s4 = [];\n        if (peg$c22.test(input.charAt(peg$currPos))) {\n          s5 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s5 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c23); }\n        }\n        if (s5 !== peg$FAILED) {\n          while (s5 !== peg$FAILED) {\n            s4.push(s5);\n            if (peg$c22.test(input.charAt(peg$currPos))) {\n              s5 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c23); }\n            }\n          }\n        } else {\n          s4 = peg$FAILED;\n        }\n        if (s4 !== peg$FAILED) {\n          s3 = input.substring(s3, peg$currPos);\n        } else {\n          s3 = s4;\n        }\n        if (s3 !== peg$FAILED) {\n          s4 = peg$parse__();\n          if (s4 !== peg$FAILED) {\n            if (peg$c24.test(input.charAt(peg$currPos))) {\n              s5 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c25); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse__();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseEntryId();\n                if (s7 === peg$FAILED) {\n                  s7 = null;\n                }\n                if (s7 !== peg$FAILED) {\n                  s8 = peg$parse__();\n                  if (s8 !== peg$FAILED) {\n                    s9 = [];\n                    s10 = peg$parseField();\n                    while (s10 !== peg$FAILED) {\n                      s9.push(s10);\n                      s10 = peg$parseField();\n                    }\n                    if (s9 !== peg$FAILED) {\n                      s10 = peg$parse__();\n                      if (s10 !== peg$FAILED) {\n                        if (peg$c26.test(input.charAt(peg$currPos))) {\n                          s11 = input.charAt(peg$currPos);\n                          peg$currPos++;\n                        } else {\n                          s11 = peg$FAILED;\n                          if (peg$silentFails === 0) { peg$fail(peg$c27); }\n                        }\n                        if (s11 !== peg$FAILED) {\n                          s12 = peg$parse__();\n                          if (s12 !== peg$FAILED) {\n                            peg$savedPos = s0;\n                            s1 = peg$c28(s3, s7, s9);\n                            s0 = s1;\n                          } else {\n                            peg$currPos = s0;\n                            s0 = peg$FAILED;\n                          }\n                        } else {\n                          peg$currPos = s0;\n                          s0 = peg$FAILED;\n                        }\n                      } else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                      }\n                    } else {\n                      peg$currPos = s0;\n                      s0 = peg$FAILED;\n                    }\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parsePreambleExpression() {\n    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;\n\n    s0 = peg$currPos;\n    if (input.charCodeAt(peg$currPos) === 64) {\n      s1 = peg$c1;\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c2); }\n    }\n    if (s1 !== peg$FAILED) {\n      s2 = peg$parse__();\n      if (s2 !== peg$FAILED) {\n        if (input.substr(peg$currPos, 8).toLowerCase() === peg$c29) {\n          s3 = input.substr(peg$currPos, 8);\n          peg$currPos += 8;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c30); }\n        }\n        if (s3 !== peg$FAILED) {\n          s4 = peg$parse__();\n          if (s4 !== peg$FAILED) {\n            if (peg$c24.test(input.charAt(peg$currPos))) {\n              s5 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c25); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse__();\n              if (s6 !== peg$FAILED) {\n                s7 = [];\n                s8 = peg$parseEnvironment();\n                if (s8 === peg$FAILED) {\n                  s8 = peg$parseBlock();\n                  if (s8 === peg$FAILED) {\n                    s8 = peg$parseMath();\n                    if (s8 === peg$FAILED) {\n                      s8 = peg$parseCommand();\n                      if (s8 === peg$FAILED) {\n                        s8 = peg$parseText();\n                      }\n                    }\n                  }\n                }\n                while (s8 !== peg$FAILED) {\n                  s7.push(s8);\n                  s8 = peg$parseEnvironment();\n                  if (s8 === peg$FAILED) {\n                    s8 = peg$parseBlock();\n                    if (s8 === peg$FAILED) {\n                      s8 = peg$parseMath();\n                      if (s8 === peg$FAILED) {\n                        s8 = peg$parseCommand();\n                        if (s8 === peg$FAILED) {\n                          s8 = peg$parseText();\n                        }\n                      }\n                    }\n                  }\n                }\n                if (s7 !== peg$FAILED) {\n                  s8 = peg$parse__();\n                  if (s8 !== peg$FAILED) {\n                    if (peg$c26.test(input.charAt(peg$currPos))) {\n                      s9 = input.charAt(peg$currPos);\n                      peg$currPos++;\n                    } else {\n                      s9 = peg$FAILED;\n                      if (peg$silentFails === 0) { peg$fail(peg$c27); }\n                    }\n                    if (s9 !== peg$FAILED) {\n                      s10 = peg$parse__();\n                      if (s10 !== peg$FAILED) {\n                        peg$savedPos = s0;\n                        s1 = peg$c31(s5, s7, s9);\n                        s0 = s1;\n                      } else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                      }\n                    } else {\n                      peg$currPos = s0;\n                      s0 = peg$FAILED;\n                    }\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseStringDeclaration() {\n    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;\n\n    s0 = peg$currPos;\n    if (input.charCodeAt(peg$currPos) === 64) {\n      s1 = peg$c1;\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c2); }\n    }\n    if (s1 !== peg$FAILED) {\n      s2 = peg$parse__();\n      if (s2 !== peg$FAILED) {\n        if (input.substr(peg$currPos, 6).toLowerCase() === peg$c32) {\n          s3 = input.substr(peg$currPos, 6);\n          peg$currPos += 6;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c33); }\n        }\n        if (s3 !== peg$FAILED) {\n          s4 = peg$parse__();\n          if (s4 !== peg$FAILED) {\n            if (peg$c24.test(input.charAt(peg$currPos))) {\n              s5 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c25); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parse__();\n              if (s6 !== peg$FAILED) {\n                s7 = peg$parseVariableName();\n                if (s7 !== peg$FAILED) {\n                  s8 = peg$parseFieldSeparator();\n                  if (s8 !== peg$FAILED) {\n                    s9 = [];\n                    s10 = peg$parseRegularValue();\n                    if (s10 !== peg$FAILED) {\n                      while (s10 !== peg$FAILED) {\n                        s9.push(s10);\n                        s10 = peg$parseRegularValue();\n                      }\n                    } else {\n                      s9 = peg$FAILED;\n                    }\n                    if (s9 !== peg$FAILED) {\n                      s10 = peg$parse__();\n                      if (s10 !== peg$FAILED) {\n                        if (peg$c26.test(input.charAt(peg$currPos))) {\n                          s11 = input.charAt(peg$currPos);\n                          peg$currPos++;\n                        } else {\n                          s11 = peg$FAILED;\n                          if (peg$silentFails === 0) { peg$fail(peg$c27); }\n                        }\n                        if (s11 !== peg$FAILED) {\n                          s12 = peg$parse__();\n                          if (s12 !== peg$FAILED) {\n                            peg$savedPos = s0;\n                            s1 = peg$c34(s7, s9);\n                            s0 = s1;\n                          } else {\n                            peg$currPos = s0;\n                            s0 = peg$FAILED;\n                          }\n                        } else {\n                          peg$currPos = s0;\n                          s0 = peg$FAILED;\n                        }\n                      } else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                      }\n                    } else {\n                      peg$currPos = s0;\n                      s0 = peg$FAILED;\n                    }\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseEntryId() {\n    var s0, s1, s2, s3, s4;\n\n    s0 = peg$currPos;\n    s1 = peg$parse__();\n    if (s1 !== peg$FAILED) {\n      s2 = peg$currPos;\n      s3 = [];\n      if (peg$c35.test(input.charAt(peg$currPos))) {\n        s4 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s4 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c36); }\n      }\n      while (s4 !== peg$FAILED) {\n        s3.push(s4);\n        if (peg$c35.test(input.charAt(peg$currPos))) {\n          s4 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s4 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c36); }\n        }\n      }\n      if (s3 !== peg$FAILED) {\n        s2 = input.substring(s2, peg$currPos);\n      } else {\n        s2 = s3;\n      }\n      if (s2 !== peg$FAILED) {\n        s3 = peg$parse__();\n        if (s3 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 44) {\n            s4 = peg$c37;\n            peg$currPos++;\n          } else {\n            s4 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c38); }\n          }\n          if (s4 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c39(s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseField() {\n    var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n\n    s0 = peg$currPos;\n    s1 = peg$parseFieldName();\n    if (s1 !== peg$FAILED) {\n      peg$savedPos = peg$currPos;\n      s2 = peg$c40(s1);\n      if (s2) {\n        s2 = void 0;\n      } else {\n        s2 = peg$FAILED;\n      }\n      if (s2 !== peg$FAILED) {\n        s3 = peg$parseFieldSeparator();\n        if (s3 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 123) {\n            s4 = peg$c15;\n            peg$currPos++;\n          } else {\n            s4 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c16); }\n          }\n          if (s4 !== peg$FAILED) {\n            s5 = peg$currPos;\n            peg$silentFails++;\n            if (input.charCodeAt(peg$currPos) === 123) {\n              s6 = peg$c15;\n              peg$currPos++;\n            } else {\n              s6 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c16); }\n            }\n            peg$silentFails--;\n            if (s6 !== peg$FAILED) {\n              peg$currPos = s5;\n              s5 = void 0;\n            } else {\n              s5 = peg$FAILED;\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parseVerbatimFieldValue();\n              if (s6 !== peg$FAILED) {\n                if (input.charCodeAt(peg$currPos) === 125) {\n                  s7 = peg$c19;\n                  peg$currPos++;\n                } else {\n                  s7 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c20); }\n                }\n                if (s7 !== peg$FAILED) {\n                  s8 = peg$parseFieldTerminator();\n                  if (s8 !== peg$FAILED) {\n                    peg$savedPos = s0;\n                    s1 = peg$c41(s1, s6);\n                    s0 = s1;\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n    if (s0 === peg$FAILED) {\n      s0 = peg$currPos;\n      s1 = peg$parseFieldName();\n      if (s1 !== peg$FAILED) {\n        peg$savedPos = peg$currPos;\n        s2 = peg$c42(s1);\n        if (s2) {\n          s2 = void 0;\n        } else {\n          s2 = peg$FAILED;\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = peg$parseFieldSeparator();\n          if (s3 !== peg$FAILED) {\n            s4 = peg$parseVerbatimFieldValue();\n            if (s4 !== peg$FAILED) {\n              s5 = peg$parseFieldTerminator();\n              if (s5 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c43(s1, s4);\n                s0 = s1;\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        s1 = peg$parseFieldName();\n        if (s1 !== peg$FAILED) {\n          s2 = peg$parseFieldSeparator();\n          if (s2 !== peg$FAILED) {\n            s3 = peg$parseFieldValue();\n            if (s3 !== peg$FAILED) {\n              s4 = peg$parseFieldTerminator();\n              if (s4 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c44(s1, s3);\n                s0 = s1;\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      }\n    }\n\n    return s0;\n  }\n\n  function peg$parseFieldName() {\n    var s0, s1, s2, s3, s4;\n\n    s0 = peg$currPos;\n    s1 = peg$parse__();\n    if (s1 !== peg$FAILED) {\n      s2 = peg$currPos;\n      s3 = [];\n      if (peg$c45.test(input.charAt(peg$currPos))) {\n        s4 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s4 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c46); }\n      }\n      if (s4 !== peg$FAILED) {\n        while (s4 !== peg$FAILED) {\n          s3.push(s4);\n          if (peg$c45.test(input.charAt(peg$currPos))) {\n            s4 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s4 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c46); }\n          }\n        }\n      } else {\n        s3 = peg$FAILED;\n      }\n      if (s3 !== peg$FAILED) {\n        s2 = input.substring(s2, peg$currPos);\n      } else {\n        s2 = s3;\n      }\n      if (s2 !== peg$FAILED) {\n        peg$savedPos = s0;\n        s1 = peg$c47(s2);\n        s0 = s1;\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseVerbatimFieldValue() {\n    var s0, s1, s2, s3;\n\n    s0 = peg$currPos;\n    if (input.charCodeAt(peg$currPos) === 34) {\n      s1 = peg$c48;\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c49); }\n    }\n    if (s1 !== peg$FAILED) {\n      s2 = peg$parseTextNoQuotes();\n      if (s2 === peg$FAILED) {\n        s2 = null;\n      }\n      if (s2 !== peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 34) {\n          s3 = peg$c48;\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c49); }\n        }\n        if (s3 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c50(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n    if (s0 === peg$FAILED) {\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 123) {\n        s1 = peg$c15;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c16); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$parseVerbatimText();\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$parseVerbatimText();\n        }\n        if (s2 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 125) {\n            s3 = peg$c19;\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c20); }\n          }\n          if (s3 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c51(s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    }\n\n    return s0;\n  }\n\n  function peg$parseVerbatimText() {\n    var s0, s1, s2, s3;\n\n    s0 = peg$currPos;\n    s1 = peg$currPos;\n    s2 = [];\n    if (peg$c17.test(input.charAt(peg$currPos))) {\n      s3 = input.charAt(peg$currPos);\n      peg$currPos++;\n    } else {\n      s3 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c18); }\n    }\n    if (s3 !== peg$FAILED) {\n      while (s3 !== peg$FAILED) {\n        s2.push(s3);\n        if (peg$c17.test(input.charAt(peg$currPos))) {\n          s3 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c18); }\n        }\n      }\n    } else {\n      s2 = peg$FAILED;\n    }\n    if (s2 !== peg$FAILED) {\n      s1 = input.substring(s1, peg$currPos);\n    } else {\n      s1 = s2;\n    }\n    if (s1 !== peg$FAILED) {\n      peg$savedPos = s0;\n      s1 = peg$c52(s1);\n    }\n    s0 = s1;\n    if (s0 === peg$FAILED) {\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 123) {\n        s1 = peg$c15;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c16); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$parseVerbatimText();\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$parseVerbatimText();\n        }\n        if (s2 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 125) {\n            s3 = peg$c19;\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c20); }\n          }\n          if (s3 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c53(s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    }\n\n    return s0;\n  }\n\n  function peg$parseFieldValue() {\n    var s0, s1, s2, s3;\n\n    s0 = peg$parseNumber();\n    if (s0 === peg$FAILED) {\n      s0 = peg$currPos;\n      peg$savedPos = peg$currPos;\n      s1 = peg$c54();\n      if (s1) {\n        s1 = void 0;\n      } else {\n        s1 = peg$FAILED;\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = [];\n        s3 = peg$parseRegularValue();\n        if (s3 === peg$FAILED) {\n          s3 = peg$parseStringValue();\n        }\n        while (s3 !== peg$FAILED) {\n          s2.push(s3);\n          s3 = peg$parseRegularValue();\n          if (s3 === peg$FAILED) {\n            s3 = peg$parseStringValue();\n          }\n        }\n        if (s2 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c55(s2);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    }\n\n    return s0;\n  }\n\n  function peg$parseRegularValue() {\n    var s0, s1, s2, s3, s4, s5;\n\n    s0 = peg$currPos;\n    if (input.charCodeAt(peg$currPos) === 34) {\n      s1 = peg$c48;\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c49); }\n    }\n    if (s1 !== peg$FAILED) {\n      s2 = [];\n      s3 = peg$parseEnvironment();\n      if (s3 === peg$FAILED) {\n        s3 = peg$parseBlock();\n        if (s3 === peg$FAILED) {\n          s3 = peg$parseMath();\n          if (s3 === peg$FAILED) {\n            s3 = peg$parseCommand();\n            if (s3 === peg$FAILED) {\n              s3 = peg$parseTextNoQuotes();\n            }\n          }\n        }\n      }\n      while (s3 !== peg$FAILED) {\n        s2.push(s3);\n        s3 = peg$parseEnvironment();\n        if (s3 === peg$FAILED) {\n          s3 = peg$parseBlock();\n          if (s3 === peg$FAILED) {\n            s3 = peg$parseMath();\n            if (s3 === peg$FAILED) {\n              s3 = peg$parseCommand();\n              if (s3 === peg$FAILED) {\n                s3 = peg$parseTextNoQuotes();\n              }\n            }\n          }\n        }\n      }\n      if (s2 !== peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 34) {\n          s3 = peg$c48;\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c49); }\n        }\n        if (s3 !== peg$FAILED) {\n          s4 = peg$parseConcat();\n          if (s4 === peg$FAILED) {\n            s4 = null;\n          }\n          if (s4 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c56(s2);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n    if (s0 === peg$FAILED) {\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 6) === peg$c57) {\n        s1 = peg$c57;\n        peg$currPos += 6;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c58); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$currPos;\n        peg$silentFails++;\n        if (peg$c59.test(input.charAt(peg$currPos))) {\n          s3 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c60); }\n        }\n        peg$silentFails--;\n        if (s3 === peg$FAILED) {\n          s2 = void 0;\n        } else {\n          peg$currPos = s2;\n          s2 = peg$FAILED;\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = [];\n          s4 = peg$parseVerbatimText();\n          while (s4 !== peg$FAILED) {\n            s3.push(s4);\n            s4 = peg$parseVerbatimText();\n          }\n          if (s3 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 125) {\n              s4 = peg$c19;\n              peg$currPos++;\n            } else {\n              s4 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c20); }\n            }\n            if (s4 !== peg$FAILED) {\n              s5 = peg$parseConcat();\n              if (s5 === peg$FAILED) {\n                s5 = null;\n              }\n              if (s5 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c51(s3);\n                s0 = s1;\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 123) {\n          s1 = peg$c15;\n          peg$currPos++;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c16); }\n        }\n        if (s1 !== peg$FAILED) {\n          s2 = [];\n          s3 = peg$parseEnvironment();\n          if (s3 === peg$FAILED) {\n            s3 = peg$parseBlock();\n            if (s3 === peg$FAILED) {\n              s3 = peg$parseMath();\n              if (s3 === peg$FAILED) {\n                s3 = peg$parseCommand();\n                if (s3 === peg$FAILED) {\n                  s3 = peg$parseText();\n                }\n              }\n            }\n          }\n          while (s3 !== peg$FAILED) {\n            s2.push(s3);\n            s3 = peg$parseEnvironment();\n            if (s3 === peg$FAILED) {\n              s3 = peg$parseBlock();\n              if (s3 === peg$FAILED) {\n                s3 = peg$parseMath();\n                if (s3 === peg$FAILED) {\n                  s3 = peg$parseCommand();\n                  if (s3 === peg$FAILED) {\n                    s3 = peg$parseText();\n                  }\n                }\n              }\n            }\n          }\n          if (s2 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 125) {\n              s3 = peg$c19;\n              peg$currPos++;\n            } else {\n              s3 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c20); }\n            }\n            if (s3 !== peg$FAILED) {\n              s4 = peg$parseConcat();\n              if (s4 === peg$FAILED) {\n                s4 = null;\n              }\n              if (s4 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c56(s2);\n                s0 = s1;\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n        if (s0 === peg$FAILED) {\n          s0 = peg$currPos;\n          s1 = peg$parseStringReference();\n          if (s1 !== peg$FAILED) {\n            s2 = peg$parseConcat();\n            if (s2 === peg$FAILED) {\n              s2 = null;\n            }\n            if (s2 !== peg$FAILED) {\n              peg$savedPos = s0;\n              s1 = peg$c56(s1);\n              s0 = s1;\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        }\n      }\n    }\n\n    return s0;\n  }\n\n  function peg$parseStringValue() {\n    var s0, s1, s2;\n\n    s0 = peg$currPos;\n    s1 = peg$parseStringReference();\n    if (s1 !== peg$FAILED) {\n      s2 = peg$parseConcat();\n      if (s2 === peg$FAILED) {\n        s2 = null;\n      }\n      if (s2 !== peg$FAILED) {\n        peg$savedPos = s0;\n        s1 = peg$c56(s1);\n        s0 = s1;\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseText() {\n    var s0, s1, s2;\n\n    s0 = peg$currPos;\n    s1 = [];\n    if (peg$c61.test(input.charAt(peg$currPos))) {\n      s2 = input.charAt(peg$currPos);\n      peg$currPos++;\n    } else {\n      s2 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c62); }\n    }\n    if (s2 !== peg$FAILED) {\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        if (peg$c61.test(input.charAt(peg$currPos))) {\n          s2 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c62); }\n        }\n      }\n    } else {\n      s1 = peg$FAILED;\n    }\n    if (s1 !== peg$FAILED) {\n      peg$savedPos = s0;\n      s1 = peg$c63(s1);\n    }\n    s0 = s1;\n\n    return s0;\n  }\n\n  function peg$parseTextNoQuotes() {\n    var s0, s1, s2;\n\n    s0 = peg$currPos;\n    s1 = [];\n    if (peg$c64.test(input.charAt(peg$currPos))) {\n      s2 = input.charAt(peg$currPos);\n      peg$currPos++;\n    } else {\n      s2 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c65); }\n    }\n    if (s2 !== peg$FAILED) {\n      while (s2 !== peg$FAILED) {\n        s1.push(s2);\n        if (peg$c64.test(input.charAt(peg$currPos))) {\n          s2 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c65); }\n        }\n      }\n    } else {\n      s1 = peg$FAILED;\n    }\n    if (s1 !== peg$FAILED) {\n      peg$savedPos = s0;\n      s1 = peg$c63(s1);\n    }\n    s0 = s1;\n\n    return s0;\n  }\n\n  function peg$parseNumber() {\n    var s0, s1, s2, s3;\n\n    s0 = peg$currPos;\n    s1 = peg$currPos;\n    s2 = [];\n    if (peg$c66.test(input.charAt(peg$currPos))) {\n      s3 = input.charAt(peg$currPos);\n      peg$currPos++;\n    } else {\n      s3 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c67); }\n    }\n    if (s3 !== peg$FAILED) {\n      while (s3 !== peg$FAILED) {\n        s2.push(s3);\n        if (peg$c66.test(input.charAt(peg$currPos))) {\n          s3 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c67); }\n        }\n      }\n    } else {\n      s2 = peg$FAILED;\n    }\n    if (s2 !== peg$FAILED) {\n      s1 = input.substring(s1, peg$currPos);\n    } else {\n      s1 = s2;\n    }\n    if (s1 !== peg$FAILED) {\n      peg$savedPos = s0;\n      s1 = peg$c68(s1);\n    }\n    s0 = s1;\n\n    return s0;\n  }\n\n  function peg$parseStringReference() {\n    var s0, s1;\n\n    s0 = peg$currPos;\n    s1 = peg$parseVariableName();\n    if (s1 !== peg$FAILED) {\n      peg$savedPos = s0;\n      s1 = peg$c69(s1);\n    }\n    s0 = s1;\n\n    return s0;\n  }\n\n  function peg$parseEnvironment() {\n    var s0, s1, s2, s3, s4, s5, s6, s7, s8;\n\n    s0 = peg$currPos;\n    if (input.substr(peg$currPos, 7) === peg$c70) {\n      s1 = peg$c70;\n      peg$currPos += 7;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c71); }\n    }\n    if (s1 !== peg$FAILED) {\n      s2 = peg$currPos;\n      s3 = [];\n      if (peg$c72.test(input.charAt(peg$currPos))) {\n        s4 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s4 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c73); }\n      }\n      if (s4 !== peg$FAILED) {\n        while (s4 !== peg$FAILED) {\n          s3.push(s4);\n          if (peg$c72.test(input.charAt(peg$currPos))) {\n            s4 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s4 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c73); }\n          }\n        }\n      } else {\n        s3 = peg$FAILED;\n      }\n      if (s3 !== peg$FAILED) {\n        s2 = input.substring(s2, peg$currPos);\n      } else {\n        s2 = s3;\n      }\n      if (s2 !== peg$FAILED) {\n        if (input.charCodeAt(peg$currPos) === 125) {\n          s3 = peg$c19;\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c20); }\n        }\n        if (s3 !== peg$FAILED) {\n          s4 = [];\n          s5 = peg$parseEnvironment();\n          if (s5 === peg$FAILED) {\n            s5 = peg$parseBlock();\n            if (s5 === peg$FAILED) {\n              s5 = peg$parseCommand();\n              if (s5 === peg$FAILED) {\n                s5 = peg$parseMath();\n                if (s5 === peg$FAILED) {\n                  s5 = peg$parseText();\n                }\n              }\n            }\n          }\n          while (s5 !== peg$FAILED) {\n            s4.push(s5);\n            s5 = peg$parseEnvironment();\n            if (s5 === peg$FAILED) {\n              s5 = peg$parseBlock();\n              if (s5 === peg$FAILED) {\n                s5 = peg$parseCommand();\n                if (s5 === peg$FAILED) {\n                  s5 = peg$parseMath();\n                  if (s5 === peg$FAILED) {\n                    s5 = peg$parseText();\n                  }\n                }\n              }\n            }\n          }\n          if (s4 !== peg$FAILED) {\n            if (input.substr(peg$currPos, 5) === peg$c74) {\n              s5 = peg$c74;\n              peg$currPos += 5;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c75); }\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$currPos;\n              s7 = [];\n              if (peg$c72.test(input.charAt(peg$currPos))) {\n                s8 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s8 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c73); }\n              }\n              if (s8 !== peg$FAILED) {\n                while (s8 !== peg$FAILED) {\n                  s7.push(s8);\n                  if (peg$c72.test(input.charAt(peg$currPos))) {\n                    s8 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                  } else {\n                    s8 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c73); }\n                  }\n                }\n              } else {\n                s7 = peg$FAILED;\n              }\n              if (s7 !== peg$FAILED) {\n                s6 = input.substring(s6, peg$currPos);\n              } else {\n                s6 = s7;\n              }\n              if (s6 !== peg$FAILED) {\n                if (input.charCodeAt(peg$currPos) === 125) {\n                  s7 = peg$c19;\n                  peg$currPos++;\n                } else {\n                  s7 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c20); }\n                }\n                if (s7 !== peg$FAILED) {\n                  peg$savedPos = peg$currPos;\n                  s8 = peg$c76(s2, s4, s6);\n                  if (s8) {\n                    s8 = void 0;\n                  } else {\n                    s8 = peg$FAILED;\n                  }\n                  if (s8 !== peg$FAILED) {\n                    peg$savedPos = s0;\n                    s1 = peg$c77(s2, s4, s6);\n                    s0 = s1;\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseBlock() {\n    var s0, s1, s2, s3, s4, s5, s6;\n\n    s0 = peg$currPos;\n    if (input.substr(peg$currPos, 2) === peg$c78) {\n      s1 = peg$c78;\n      peg$currPos += 2;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c79); }\n    }\n    if (s1 !== peg$FAILED) {\n      s2 = peg$parseExtendedDiacritic();\n      if (s2 !== peg$FAILED) {\n        s3 = peg$parse__();\n        if (s3 !== peg$FAILED) {\n          if (peg$c72.test(input.charAt(peg$currPos))) {\n            s4 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s4 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c73); }\n          }\n          if (s4 === peg$FAILED) {\n            s4 = peg$currPos;\n            if (input.charCodeAt(peg$currPos) === 92) {\n              s5 = peg$c80;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c81); }\n            }\n            if (s5 !== peg$FAILED) {\n              if (peg$c82.test(input.charAt(peg$currPos))) {\n                s6 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s6 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c83); }\n              }\n              if (s6 !== peg$FAILED) {\n                s5 = [s5, s6];\n                s4 = s5;\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n          }\n          if (s4 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 125) {\n              s5 = peg$c19;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c20); }\n            }\n            if (s5 !== peg$FAILED) {\n              peg$savedPos = s0;\n              s1 = peg$c84(s2, s4);\n              s0 = s1;\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n    if (s0 === peg$FAILED) {\n      s0 = peg$currPos;\n      if (input.substr(peg$currPos, 6) === peg$c57) {\n        s1 = peg$c57;\n        peg$currPos += 6;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c58); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$currPos;\n        peg$silentFails++;\n        if (peg$c59.test(input.charAt(peg$currPos))) {\n          s3 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c60); }\n        }\n        peg$silentFails--;\n        if (s3 === peg$FAILED) {\n          s2 = void 0;\n        } else {\n          peg$currPos = s2;\n          s2 = peg$FAILED;\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = [];\n          s4 = peg$parseVerbatimText();\n          while (s4 !== peg$FAILED) {\n            s3.push(s4);\n            s4 = peg$parseVerbatimText();\n          }\n          if (s3 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 125) {\n              s4 = peg$c19;\n              peg$currPos++;\n            } else {\n              s4 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c20); }\n            }\n            if (s4 !== peg$FAILED) {\n              peg$savedPos = s0;\n              s1 = peg$c85(s3);\n              s0 = s1;\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 123) {\n          s1 = peg$c15;\n          peg$currPos++;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c16); }\n        }\n        if (s1 !== peg$FAILED) {\n          s2 = [];\n          s3 = peg$parseEnvironment();\n          if (s3 === peg$FAILED) {\n            s3 = peg$parseBlock();\n            if (s3 === peg$FAILED) {\n              s3 = peg$parseCommand();\n              if (s3 === peg$FAILED) {\n                s3 = peg$parseMath();\n                if (s3 === peg$FAILED) {\n                  s3 = peg$parseText();\n                }\n              }\n            }\n          }\n          while (s3 !== peg$FAILED) {\n            s2.push(s3);\n            s3 = peg$parseEnvironment();\n            if (s3 === peg$FAILED) {\n              s3 = peg$parseBlock();\n              if (s3 === peg$FAILED) {\n                s3 = peg$parseCommand();\n                if (s3 === peg$FAILED) {\n                  s3 = peg$parseMath();\n                  if (s3 === peg$FAILED) {\n                    s3 = peg$parseText();\n                  }\n                }\n              }\n            }\n          }\n          if (s2 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 125) {\n              s3 = peg$c19;\n              peg$currPos++;\n            } else {\n              s3 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c20); }\n            }\n            if (s3 !== peg$FAILED) {\n              peg$savedPos = s0;\n              s1 = peg$c86(s2);\n              s0 = s1;\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      }\n    }\n\n    return s0;\n  }\n\n  function peg$parseMath() {\n    var s0, s1, s2, s3, s4, s5, s6;\n\n    s0 = peg$currPos;\n    peg$savedPos = peg$currPos;\n    s1 = peg$c87();\n    if (s1) {\n      s1 = void 0;\n    } else {\n      s1 = peg$FAILED;\n    }\n    if (s1 !== peg$FAILED) {\n      if (input.charCodeAt(peg$currPos) === 36) {\n        s2 = peg$c88;\n        peg$currPos++;\n      } else {\n        s2 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c89); }\n      }\n      if (s2 === peg$FAILED) {\n        if (input.substr(peg$currPos, 2) === peg$c90) {\n          s2 = peg$c90;\n          peg$currPos += 2;\n        } else {\n          s2 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c91); }\n        }\n      }\n      if (s2 !== peg$FAILED) {\n        peg$savedPos = peg$currPos;\n        s3 = peg$c92(s2);\n        if (s3) {\n          s3 = void 0;\n        } else {\n          s3 = peg$FAILED;\n        }\n        if (s3 !== peg$FAILED) {\n          s4 = [];\n          s5 = peg$parseBlock();\n          if (s5 === peg$FAILED) {\n            s5 = peg$parseCommand();\n            if (s5 === peg$FAILED) {\n              s5 = peg$parseText();\n            }\n          }\n          while (s5 !== peg$FAILED) {\n            s4.push(s5);\n            s5 = peg$parseBlock();\n            if (s5 === peg$FAILED) {\n              s5 = peg$parseCommand();\n              if (s5 === peg$FAILED) {\n                s5 = peg$parseText();\n              }\n            }\n          }\n          if (s4 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 36) {\n              s5 = peg$c88;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c89); }\n            }\n            if (s5 === peg$FAILED) {\n              if (input.substr(peg$currPos, 2) === peg$c90) {\n                s5 = peg$c90;\n                peg$currPos += 2;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c91); }\n              }\n            }\n            if (s5 !== peg$FAILED) {\n              peg$savedPos = peg$currPos;\n              s6 = peg$c93(s2, s4);\n              if (s6) {\n                s6 = void 0;\n              } else {\n                s6 = peg$FAILED;\n              }\n              if (s6 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c94(s2, s4);\n                s0 = s1;\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseLineComment() {\n    var s0, s1, s2, s3, s4, s5;\n\n    s0 = peg$currPos;\n    if (input.charCodeAt(peg$currPos) === 37) {\n      s1 = peg$c95;\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c96); }\n    }\n    if (s1 !== peg$FAILED) {\n      s2 = peg$parse__h();\n      if (s2 !== peg$FAILED) {\n        s3 = peg$currPos;\n        s4 = [];\n        if (peg$c97.test(input.charAt(peg$currPos))) {\n          s5 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s5 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c98); }\n        }\n        if (s5 !== peg$FAILED) {\n          while (s5 !== peg$FAILED) {\n            s4.push(s5);\n            if (peg$c97.test(input.charAt(peg$currPos))) {\n              s5 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c98); }\n            }\n          }\n        } else {\n          s4 = peg$FAILED;\n        }\n        if (s4 !== peg$FAILED) {\n          s3 = input.substring(s3, peg$currPos);\n        } else {\n          s3 = s4;\n        }\n        if (s3 !== peg$FAILED) {\n          s4 = [];\n          s5 = peg$parseEOL();\n          if (s5 !== peg$FAILED) {\n            while (s5 !== peg$FAILED) {\n              s4.push(s5);\n              s5 = peg$parseEOL();\n            }\n          } else {\n            s4 = peg$FAILED;\n          }\n          if (s4 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c99(s3);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseCommand() {\n    var s0;\n\n    s0 = peg$parseScriptCommand();\n    if (s0 === peg$FAILED) {\n      s0 = peg$parseDiacriticCommand();\n      if (s0 === peg$FAILED) {\n        s0 = peg$parseRegularCommand();\n        if (s0 === peg$FAILED) {\n          s0 = peg$parseSymbolCommand();\n        }\n      }\n    }\n\n    return s0;\n  }\n\n  function peg$parseScriptCommand() {\n    var s0, s1, s2, s3;\n\n    s0 = peg$currPos;\n    if (peg$c100.test(input.charAt(peg$currPos))) {\n      s1 = input.charAt(peg$currPos);\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c101); }\n    }\n    if (s1 !== peg$FAILED) {\n      s2 = peg$parse__h();\n      if (s2 !== peg$FAILED) {\n        s3 = peg$parseRequiredArgument();\n        if (s3 !== peg$FAILED) {\n          peg$savedPos = s0;\n          s1 = peg$c102(s1, s3);\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseDiacriticCommand() {\n    var s0, s1, s2, s3, s4, s5, s6;\n\n    s0 = peg$currPos;\n    if (input.charCodeAt(peg$currPos) === 92) {\n      s1 = peg$c80;\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c81); }\n    }\n    if (s1 !== peg$FAILED) {\n      s2 = peg$parseSimpleDiacritic();\n      if (s2 !== peg$FAILED) {\n        s3 = peg$parse__();\n        if (s3 !== peg$FAILED) {\n          if (peg$c72.test(input.charAt(peg$currPos))) {\n            s4 = input.charAt(peg$currPos);\n            peg$currPos++;\n          } else {\n            s4 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c73); }\n          }\n          if (s4 === peg$FAILED) {\n            s4 = peg$currPos;\n            if (input.charCodeAt(peg$currPos) === 92) {\n              s5 = peg$c80;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c81); }\n            }\n            if (s5 !== peg$FAILED) {\n              if (peg$c82.test(input.charAt(peg$currPos))) {\n                s6 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s6 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c83); }\n              }\n              if (s6 !== peg$FAILED) {\n                s5 = [s5, s6];\n                s4 = s5;\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s4;\n              s4 = peg$FAILED;\n            }\n          }\n          if (s4 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$c84(s2, s4);\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n    if (s0 === peg$FAILED) {\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 92) {\n        s1 = peg$c80;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c81); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$parseExtendedDiacritic();\n        if (s2 !== peg$FAILED) {\n          if (input.charCodeAt(peg$currPos) === 123) {\n            s3 = peg$c15;\n            peg$currPos++;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c16); }\n          }\n          if (s3 !== peg$FAILED) {\n            if (peg$c72.test(input.charAt(peg$currPos))) {\n              s4 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s4 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c73); }\n            }\n            if (s4 === peg$FAILED) {\n              s4 = peg$currPos;\n              if (input.charCodeAt(peg$currPos) === 92) {\n                s5 = peg$c80;\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c81); }\n              }\n              if (s5 !== peg$FAILED) {\n                if (peg$c82.test(input.charAt(peg$currPos))) {\n                  s6 = input.charAt(peg$currPos);\n                  peg$currPos++;\n                } else {\n                  s6 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c83); }\n                }\n                if (s6 !== peg$FAILED) {\n                  s5 = [s5, s6];\n                  s4 = s5;\n                } else {\n                  peg$currPos = s4;\n                  s4 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s4;\n                s4 = peg$FAILED;\n              }\n            }\n            if (s4 !== peg$FAILED) {\n              if (input.charCodeAt(peg$currPos) === 125) {\n                s5 = peg$c19;\n                peg$currPos++;\n              } else {\n                s5 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c20); }\n              }\n              if (s5 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c84(s2, s4);\n                s0 = s1;\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 92) {\n          s1 = peg$c80;\n          peg$currPos++;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c81); }\n        }\n        if (s1 !== peg$FAILED) {\n          s2 = peg$parseExtendedDiacritic();\n          if (s2 !== peg$FAILED) {\n            s3 = peg$currPos;\n            peg$silentFails++;\n            if (input.charCodeAt(peg$currPos) === 123) {\n              s4 = peg$c15;\n              peg$currPos++;\n            } else {\n              s4 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c16); }\n            }\n            peg$silentFails--;\n            if (s4 !== peg$FAILED) {\n              peg$currPos = s3;\n              s3 = void 0;\n            } else {\n              s3 = peg$FAILED;\n            }\n            if (s3 !== peg$FAILED) {\n              s4 = peg$parseRegularValue();\n              if (s4 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c103(s2, s4);\n                s0 = s1;\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      }\n    }\n\n    return s0;\n  }\n\n  function peg$parseSymbolCommand() {\n    var s0, s1, s2, s3;\n\n    s0 = peg$currPos;\n    if (input.charCodeAt(peg$currPos) === 92) {\n      s1 = peg$c80;\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c81); }\n    }\n    if (s1 !== peg$FAILED) {\n      s2 = peg$currPos;\n      if (peg$c104.test(input.charAt(peg$currPos))) {\n        s3 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s3 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c105); }\n      }\n      if (s3 !== peg$FAILED) {\n        s2 = input.substring(s2, peg$currPos);\n      } else {\n        s2 = s3;\n      }\n      if (s2 !== peg$FAILED) {\n        peg$savedPos = s0;\n        s1 = peg$c106(s2);\n        s0 = s1;\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseRegularCommand() {\n    var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;\n\n    s0 = peg$currPos;\n    if (input.charCodeAt(peg$currPos) === 92) {\n      s1 = peg$c80;\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c81); }\n    }\n    if (s1 !== peg$FAILED) {\n      if (input.substr(peg$currPos, 10) === peg$c107) {\n        s2 = peg$c107;\n        peg$currPos += 10;\n      } else {\n        s2 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c108); }\n      }\n      if (s2 !== peg$FAILED) {\n        s3 = peg$parseBlock();\n        if (s3 !== peg$FAILED) {\n          peg$savedPos = peg$currPos;\n          s4 = peg$c109(s2, s3);\n          if (s4) {\n            s4 = void 0;\n          } else {\n            s4 = peg$FAILED;\n          }\n          if (s4 !== peg$FAILED) {\n            s5 = [];\n            s6 = peg$parseOptionalArgument();\n            while (s6 !== peg$FAILED) {\n              s5.push(s6);\n              s6 = peg$parseOptionalArgument();\n            }\n            if (s5 !== peg$FAILED) {\n              s6 = peg$parseRequiredArgument();\n              if (s6 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s1 = peg$c110(s2, s3, s5, s6);\n                s0 = s1;\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n    if (s0 === peg$FAILED) {\n      s0 = peg$currPos;\n      if (input.charCodeAt(peg$currPos) === 92) {\n        s1 = peg$c80;\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c81); }\n      }\n      if (s1 !== peg$FAILED) {\n        s2 = peg$currPos;\n        peg$silentFails++;\n        if (input.substr(peg$currPos, 5) === peg$c111) {\n          s3 = peg$c111;\n          peg$currPos += 5;\n        } else {\n          s3 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c112); }\n        }\n        peg$silentFails--;\n        if (s3 === peg$FAILED) {\n          s2 = void 0;\n        } else {\n          peg$currPos = s2;\n          s2 = peg$FAILED;\n        }\n        if (s2 !== peg$FAILED) {\n          s3 = peg$currPos;\n          peg$silentFails++;\n          if (input.substr(peg$currPos, 3) === peg$c113) {\n            s4 = peg$c113;\n            peg$currPos += 3;\n          } else {\n            s4 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c114); }\n          }\n          peg$silentFails--;\n          if (s4 === peg$FAILED) {\n            s3 = void 0;\n          } else {\n            peg$currPos = s3;\n            s3 = peg$FAILED;\n          }\n          if (s3 !== peg$FAILED) {\n            s4 = peg$currPos;\n            s5 = [];\n            if (peg$c22.test(input.charAt(peg$currPos))) {\n              s6 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s6 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c23); }\n            }\n            if (s6 !== peg$FAILED) {\n              while (s6 !== peg$FAILED) {\n                s5.push(s6);\n                if (peg$c22.test(input.charAt(peg$currPos))) {\n                  s6 = input.charAt(peg$currPos);\n                  peg$currPos++;\n                } else {\n                  s6 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c23); }\n                }\n              }\n            } else {\n              s5 = peg$FAILED;\n            }\n            if (s5 !== peg$FAILED) {\n              s4 = input.substring(s4, peg$currPos);\n            } else {\n              s4 = s5;\n            }\n            if (s4 !== peg$FAILED) {\n              peg$savedPos = peg$currPos;\n              s5 = peg$c115(s4);\n              if (s5) {\n                s5 = void 0;\n              } else {\n                s5 = peg$FAILED;\n              }\n              if (s5 !== peg$FAILED) {\n                s6 = [];\n                s7 = peg$parseOptionalArgument();\n                while (s7 !== peg$FAILED) {\n                  s6.push(s7);\n                  s7 = peg$parseOptionalArgument();\n                }\n                if (s6 !== peg$FAILED) {\n                  s7 = peg$parse__h();\n                  if (s7 !== peg$FAILED) {\n                    s8 = peg$currPos;\n                    peg$silentFails++;\n                    if (input.charCodeAt(peg$currPos) === 123) {\n                      s9 = peg$c15;\n                      peg$currPos++;\n                    } else {\n                      s9 = peg$FAILED;\n                      if (peg$silentFails === 0) { peg$fail(peg$c16); }\n                    }\n                    peg$silentFails--;\n                    if (s9 !== peg$FAILED) {\n                      peg$currPos = s8;\n                      s8 = void 0;\n                    } else {\n                      s8 = peg$FAILED;\n                    }\n                    if (s8 !== peg$FAILED) {\n                      s9 = peg$parseVerbatimFieldValue();\n                      if (s9 !== peg$FAILED) {\n                        s10 = peg$parseVerbatimFieldValue();\n                        if (s10 !== peg$FAILED) {\n                          peg$savedPos = s0;\n                          s1 = peg$c116(s4, s6, s9, s10);\n                          s0 = s1;\n                        } else {\n                          peg$currPos = s0;\n                          s0 = peg$FAILED;\n                        }\n                      } else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                      }\n                    } else {\n                      peg$currPos = s0;\n                      s0 = peg$FAILED;\n                    }\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n      if (s0 === peg$FAILED) {\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 92) {\n          s1 = peg$c80;\n          peg$currPos++;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c81); }\n        }\n        if (s1 !== peg$FAILED) {\n          s2 = peg$currPos;\n          peg$silentFails++;\n          if (input.substr(peg$currPos, 5) === peg$c111) {\n            s3 = peg$c111;\n            peg$currPos += 5;\n          } else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c112); }\n          }\n          peg$silentFails--;\n          if (s3 === peg$FAILED) {\n            s2 = void 0;\n          } else {\n            peg$currPos = s2;\n            s2 = peg$FAILED;\n          }\n          if (s2 !== peg$FAILED) {\n            s3 = peg$currPos;\n            peg$silentFails++;\n            if (input.substr(peg$currPos, 3) === peg$c113) {\n              s4 = peg$c113;\n              peg$currPos += 3;\n            } else {\n              s4 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c114); }\n            }\n            peg$silentFails--;\n            if (s4 === peg$FAILED) {\n              s3 = void 0;\n            } else {\n              peg$currPos = s3;\n              s3 = peg$FAILED;\n            }\n            if (s3 !== peg$FAILED) {\n              s4 = peg$currPos;\n              s5 = [];\n              if (peg$c22.test(input.charAt(peg$currPos))) {\n                s6 = input.charAt(peg$currPos);\n                peg$currPos++;\n              } else {\n                s6 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c23); }\n              }\n              if (s6 !== peg$FAILED) {\n                while (s6 !== peg$FAILED) {\n                  s5.push(s6);\n                  if (peg$c22.test(input.charAt(peg$currPos))) {\n                    s6 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                  } else {\n                    s6 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c23); }\n                  }\n                }\n              } else {\n                s5 = peg$FAILED;\n              }\n              if (s5 !== peg$FAILED) {\n                s4 = input.substring(s4, peg$currPos);\n              } else {\n                s4 = s5;\n              }\n              if (s4 !== peg$FAILED) {\n                peg$savedPos = peg$currPos;\n                s5 = peg$c117(s4);\n                if (s5) {\n                  s5 = void 0;\n                } else {\n                  s5 = peg$FAILED;\n                }\n                if (s5 !== peg$FAILED) {\n                  s6 = [];\n                  s7 = peg$parseOptionalArgument();\n                  while (s7 !== peg$FAILED) {\n                    s6.push(s7);\n                    s7 = peg$parseOptionalArgument();\n                  }\n                  if (s6 !== peg$FAILED) {\n                    s7 = peg$parse__h();\n                    if (s7 !== peg$FAILED) {\n                      s8 = peg$currPos;\n                      peg$silentFails++;\n                      if (input.charCodeAt(peg$currPos) === 123) {\n                        s9 = peg$c15;\n                        peg$currPos++;\n                      } else {\n                        s9 = peg$FAILED;\n                        if (peg$silentFails === 0) { peg$fail(peg$c16); }\n                      }\n                      peg$silentFails--;\n                      if (s9 !== peg$FAILED) {\n                        peg$currPos = s8;\n                        s8 = void 0;\n                      } else {\n                        s8 = peg$FAILED;\n                      }\n                      if (s8 !== peg$FAILED) {\n                        s9 = peg$parseVerbatimFieldValue();\n                        if (s9 !== peg$FAILED) {\n                          peg$savedPos = s0;\n                          s1 = peg$c118(s4, s6, s9);\n                          s0 = s1;\n                        } else {\n                          peg$currPos = s0;\n                          s0 = peg$FAILED;\n                        }\n                      } else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                      }\n                    } else {\n                      peg$currPos = s0;\n                      s0 = peg$FAILED;\n                    }\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n        if (s0 === peg$FAILED) {\n          s0 = peg$currPos;\n          if (input.charCodeAt(peg$currPos) === 92) {\n            s1 = peg$c80;\n            peg$currPos++;\n          } else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) { peg$fail(peg$c81); }\n          }\n          if (s1 !== peg$FAILED) {\n            s2 = peg$currPos;\n            peg$silentFails++;\n            if (input.substr(peg$currPos, 5) === peg$c111) {\n              s3 = peg$c111;\n              peg$currPos += 5;\n            } else {\n              s3 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c112); }\n            }\n            peg$silentFails--;\n            if (s3 === peg$FAILED) {\n              s2 = void 0;\n            } else {\n              peg$currPos = s2;\n              s2 = peg$FAILED;\n            }\n            if (s2 !== peg$FAILED) {\n              s3 = peg$currPos;\n              peg$silentFails++;\n              if (input.substr(peg$currPos, 3) === peg$c113) {\n                s4 = peg$c113;\n                peg$currPos += 3;\n              } else {\n                s4 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c114); }\n              }\n              peg$silentFails--;\n              if (s4 === peg$FAILED) {\n                s3 = void 0;\n              } else {\n                peg$currPos = s3;\n                s3 = peg$FAILED;\n              }\n              if (s3 !== peg$FAILED) {\n                s4 = peg$currPos;\n                s5 = [];\n                if (peg$c22.test(input.charAt(peg$currPos))) {\n                  s6 = input.charAt(peg$currPos);\n                  peg$currPos++;\n                } else {\n                  s6 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c23); }\n                }\n                if (s6 !== peg$FAILED) {\n                  while (s6 !== peg$FAILED) {\n                    s5.push(s6);\n                    if (peg$c22.test(input.charAt(peg$currPos))) {\n                      s6 = input.charAt(peg$currPos);\n                      peg$currPos++;\n                    } else {\n                      s6 = peg$FAILED;\n                      if (peg$silentFails === 0) { peg$fail(peg$c23); }\n                    }\n                  }\n                } else {\n                  s5 = peg$FAILED;\n                }\n                if (s5 !== peg$FAILED) {\n                  s4 = input.substring(s4, peg$currPos);\n                } else {\n                  s4 = s5;\n                }\n                if (s4 !== peg$FAILED) {\n                  peg$savedPos = peg$currPos;\n                  s5 = peg$c119(s4);\n                  if (s5) {\n                    s5 = void 0;\n                  } else {\n                    s5 = peg$FAILED;\n                  }\n                  if (s5 !== peg$FAILED) {\n                    s6 = [];\n                    s7 = peg$parseOptionalArgument();\n                    while (s7 !== peg$FAILED) {\n                      s6.push(s7);\n                      s7 = peg$parseOptionalArgument();\n                    }\n                    if (s6 !== peg$FAILED) {\n                      s7 = peg$parse__h();\n                      if (s7 !== peg$FAILED) {\n                        s8 = peg$parseRequiredArgument();\n                        if (s8 !== peg$FAILED) {\n                          s9 = peg$parseRequiredArgument();\n                          if (s9 !== peg$FAILED) {\n                            peg$savedPos = s0;\n                            s1 = peg$c120(s4, s6, s8, s9);\n                            s0 = s1;\n                          } else {\n                            peg$currPos = s0;\n                            s0 = peg$FAILED;\n                          }\n                        } else {\n                          peg$currPos = s0;\n                          s0 = peg$FAILED;\n                        }\n                      } else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                      }\n                    } else {\n                      peg$currPos = s0;\n                      s0 = peg$FAILED;\n                    }\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n          if (s0 === peg$FAILED) {\n            s0 = peg$currPos;\n            if (input.charCodeAt(peg$currPos) === 92) {\n              s1 = peg$c80;\n              peg$currPos++;\n            } else {\n              s1 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c81); }\n            }\n            if (s1 !== peg$FAILED) {\n              s2 = peg$currPos;\n              peg$silentFails++;\n              if (input.substr(peg$currPos, 5) === peg$c111) {\n                s3 = peg$c111;\n                peg$currPos += 5;\n              } else {\n                s3 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c112); }\n              }\n              peg$silentFails--;\n              if (s3 === peg$FAILED) {\n                s2 = void 0;\n              } else {\n                peg$currPos = s2;\n                s2 = peg$FAILED;\n              }\n              if (s2 !== peg$FAILED) {\n                s3 = peg$currPos;\n                peg$silentFails++;\n                if (input.substr(peg$currPos, 3) === peg$c113) {\n                  s4 = peg$c113;\n                  peg$currPos += 3;\n                } else {\n                  s4 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c114); }\n                }\n                peg$silentFails--;\n                if (s4 === peg$FAILED) {\n                  s3 = void 0;\n                } else {\n                  peg$currPos = s3;\n                  s3 = peg$FAILED;\n                }\n                if (s3 !== peg$FAILED) {\n                  s4 = peg$currPos;\n                  s5 = [];\n                  if (peg$c22.test(input.charAt(peg$currPos))) {\n                    s6 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                  } else {\n                    s6 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c23); }\n                  }\n                  if (s6 !== peg$FAILED) {\n                    while (s6 !== peg$FAILED) {\n                      s5.push(s6);\n                      if (peg$c22.test(input.charAt(peg$currPos))) {\n                        s6 = input.charAt(peg$currPos);\n                        peg$currPos++;\n                      } else {\n                        s6 = peg$FAILED;\n                        if (peg$silentFails === 0) { peg$fail(peg$c23); }\n                      }\n                    }\n                  } else {\n                    s5 = peg$FAILED;\n                  }\n                  if (s5 !== peg$FAILED) {\n                    s4 = input.substring(s4, peg$currPos);\n                  } else {\n                    s4 = s5;\n                  }\n                  if (s4 !== peg$FAILED) {\n                    peg$savedPos = peg$currPos;\n                    s5 = peg$c121(s4);\n                    if (s5) {\n                      s5 = void 0;\n                    } else {\n                      s5 = peg$FAILED;\n                    }\n                    if (s5 !== peg$FAILED) {\n                      s6 = [];\n                      s7 = peg$parseOptionalArgument();\n                      while (s7 !== peg$FAILED) {\n                        s6.push(s7);\n                        s7 = peg$parseOptionalArgument();\n                      }\n                      if (s6 !== peg$FAILED) {\n                        s7 = peg$parse__h();\n                        if (s7 !== peg$FAILED) {\n                          s8 = peg$parseRequiredArgument();\n                          if (s8 !== peg$FAILED) {\n                            peg$savedPos = s0;\n                            s1 = peg$c122(s4, s6, s8);\n                            s0 = s1;\n                          } else {\n                            peg$currPos = s0;\n                            s0 = peg$FAILED;\n                          }\n                        } else {\n                          peg$currPos = s0;\n                          s0 = peg$FAILED;\n                        }\n                      } else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                      }\n                    } else {\n                      peg$currPos = s0;\n                      s0 = peg$FAILED;\n                    }\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n            if (s0 === peg$FAILED) {\n              s0 = peg$currPos;\n              if (input.charCodeAt(peg$currPos) === 92) {\n                s1 = peg$c80;\n                peg$currPos++;\n              } else {\n                s1 = peg$FAILED;\n                if (peg$silentFails === 0) { peg$fail(peg$c81); }\n              }\n              if (s1 !== peg$FAILED) {\n                s2 = peg$currPos;\n                peg$silentFails++;\n                if (input.substr(peg$currPos, 5) === peg$c111) {\n                  s3 = peg$c111;\n                  peg$currPos += 5;\n                } else {\n                  s3 = peg$FAILED;\n                  if (peg$silentFails === 0) { peg$fail(peg$c112); }\n                }\n                peg$silentFails--;\n                if (s3 === peg$FAILED) {\n                  s2 = void 0;\n                } else {\n                  peg$currPos = s2;\n                  s2 = peg$FAILED;\n                }\n                if (s2 !== peg$FAILED) {\n                  s3 = peg$currPos;\n                  peg$silentFails++;\n                  if (input.substr(peg$currPos, 3) === peg$c113) {\n                    s4 = peg$c113;\n                    peg$currPos += 3;\n                  } else {\n                    s4 = peg$FAILED;\n                    if (peg$silentFails === 0) { peg$fail(peg$c114); }\n                  }\n                  peg$silentFails--;\n                  if (s4 === peg$FAILED) {\n                    s3 = void 0;\n                  } else {\n                    peg$currPos = s3;\n                    s3 = peg$FAILED;\n                  }\n                  if (s3 !== peg$FAILED) {\n                    s4 = peg$currPos;\n                    s5 = [];\n                    if (peg$c22.test(input.charAt(peg$currPos))) {\n                      s6 = input.charAt(peg$currPos);\n                      peg$currPos++;\n                    } else {\n                      s6 = peg$FAILED;\n                      if (peg$silentFails === 0) { peg$fail(peg$c23); }\n                    }\n                    if (s6 !== peg$FAILED) {\n                      while (s6 !== peg$FAILED) {\n                        s5.push(s6);\n                        if (peg$c22.test(input.charAt(peg$currPos))) {\n                          s6 = input.charAt(peg$currPos);\n                          peg$currPos++;\n                        } else {\n                          s6 = peg$FAILED;\n                          if (peg$silentFails === 0) { peg$fail(peg$c23); }\n                        }\n                      }\n                    } else {\n                      s5 = peg$FAILED;\n                    }\n                    if (s5 !== peg$FAILED) {\n                      s4 = input.substring(s4, peg$currPos);\n                    } else {\n                      s4 = s5;\n                    }\n                    if (s4 !== peg$FAILED) {\n                      s5 = [];\n                      s6 = peg$parseOptionalArgument();\n                      while (s6 !== peg$FAILED) {\n                        s5.push(s6);\n                        s6 = peg$parseOptionalArgument();\n                      }\n                      if (s5 !== peg$FAILED) {\n                        s6 = peg$parse__();\n                        if (s6 !== peg$FAILED) {\n                          peg$savedPos = s0;\n                          s1 = peg$c123(s4, s5);\n                          s0 = s1;\n                        } else {\n                          peg$currPos = s0;\n                          s0 = peg$FAILED;\n                        }\n                      } else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                      }\n                    } else {\n                      peg$currPos = s0;\n                      s0 = peg$FAILED;\n                    }\n                  } else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                  }\n                } else {\n                  peg$currPos = s0;\n                  s0 = peg$FAILED;\n                }\n              } else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n              }\n            }\n          }\n        }\n      }\n    }\n\n    return s0;\n  }\n\n  function peg$parseOptionalArgument() {\n    var s0, s1, s2, s3, s4, s5;\n\n    s0 = peg$currPos;\n    if (input.charCodeAt(peg$currPos) === 91) {\n      s1 = peg$c124;\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c125); }\n    }\n    if (s1 !== peg$FAILED) {\n      s2 = peg$parse__h();\n      if (s2 !== peg$FAILED) {\n        s3 = peg$currPos;\n        s4 = [];\n        if (peg$c126.test(input.charAt(peg$currPos))) {\n          s5 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s5 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c127); }\n        }\n        if (s5 !== peg$FAILED) {\n          while (s5 !== peg$FAILED) {\n            s4.push(s5);\n            if (peg$c126.test(input.charAt(peg$currPos))) {\n              s5 = input.charAt(peg$currPos);\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c127); }\n            }\n          }\n        } else {\n          s4 = peg$FAILED;\n        }\n        if (s4 !== peg$FAILED) {\n          s3 = input.substring(s3, peg$currPos);\n        } else {\n          s3 = s4;\n        }\n        if (s3 !== peg$FAILED) {\n          s4 = peg$parse__h();\n          if (s4 !== peg$FAILED) {\n            if (input.charCodeAt(peg$currPos) === 93) {\n              s5 = peg$c128;\n              peg$currPos++;\n            } else {\n              s5 = peg$FAILED;\n              if (peg$silentFails === 0) { peg$fail(peg$c129); }\n            }\n            if (s5 !== peg$FAILED) {\n              peg$savedPos = s0;\n              s1 = peg$c130(s3);\n              s0 = s1;\n            } else {\n              peg$currPos = s0;\n              s0 = peg$FAILED;\n            }\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseRequiredArgument() {\n    var s0, s1, s2;\n\n    s0 = peg$currPos;\n    s1 = peg$parse__h();\n    if (s1 !== peg$FAILED) {\n      if (peg$c131.test(input.charAt(peg$currPos))) {\n        s2 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s2 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c132); }\n      }\n      if (s2 !== peg$FAILED) {\n        peg$savedPos = s0;\n        s1 = peg$c133(s2);\n        s0 = s1;\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n    if (s0 === peg$FAILED) {\n      s0 = peg$currPos;\n      s1 = peg$parseBlock();\n      if (s1 === peg$FAILED) {\n        s1 = peg$parseCommand();\n      }\n      if (s1 !== peg$FAILED) {\n        peg$savedPos = s0;\n        s1 = peg$c52(s1);\n      }\n      s0 = s1;\n    }\n\n    return s0;\n  }\n\n  function peg$parseVariableName() {\n    var s0, s1, s2, s3, s4;\n\n    s0 = peg$currPos;\n    s1 = peg$currPos;\n    if (peg$c134.test(input.charAt(peg$currPos))) {\n      s2 = input.charAt(peg$currPos);\n      peg$currPos++;\n    } else {\n      s2 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c135); }\n    }\n    if (s2 !== peg$FAILED) {\n      s3 = [];\n      if (peg$c136.test(input.charAt(peg$currPos))) {\n        s4 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s4 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c137); }\n      }\n      while (s4 !== peg$FAILED) {\n        s3.push(s4);\n        if (peg$c136.test(input.charAt(peg$currPos))) {\n          s4 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s4 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c137); }\n        }\n      }\n      if (s3 !== peg$FAILED) {\n        s2 = [s2, s3];\n        s1 = s2;\n      } else {\n        peg$currPos = s1;\n        s1 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s1;\n      s1 = peg$FAILED;\n    }\n    if (s1 !== peg$FAILED) {\n      s0 = input.substring(s0, peg$currPos);\n    } else {\n      s0 = s1;\n    }\n\n    return s0;\n  }\n\n  function peg$parseSimpleDiacritic() {\n    var s0;\n\n    if (peg$c138.test(input.charAt(peg$currPos))) {\n      s0 = input.charAt(peg$currPos);\n      peg$currPos++;\n    } else {\n      s0 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c139); }\n    }\n\n    return s0;\n  }\n\n  function peg$parseExtendedDiacritic() {\n    var s0;\n\n    if (peg$c140.test(input.charAt(peg$currPos))) {\n      s0 = input.charAt(peg$currPos);\n      peg$currPos++;\n    } else {\n      s0 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c141); }\n    }\n\n    return s0;\n  }\n\n  function peg$parseFieldSeparator() {\n    var s0, s1, s2, s3;\n\n    s0 = peg$currPos;\n    s1 = peg$parse__();\n    if (s1 !== peg$FAILED) {\n      if (input.charCodeAt(peg$currPos) === 61) {\n        s2 = peg$c142;\n        peg$currPos++;\n      } else {\n        s2 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c143); }\n      }\n      if (s2 !== peg$FAILED) {\n        s3 = peg$parse__();\n        if (s3 !== peg$FAILED) {\n          s1 = [s1, s2, s3];\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseFieldTerminator() {\n    var s0, s1, s2, s3, s4, s5;\n\n    s0 = peg$currPos;\n    s1 = peg$parse__();\n    if (s1 !== peg$FAILED) {\n      if (input.charCodeAt(peg$currPos) === 44) {\n        s2 = peg$c37;\n        peg$currPos++;\n      } else {\n        s2 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c38); }\n      }\n      if (s2 === peg$FAILED) {\n        s2 = null;\n      }\n      if (s2 !== peg$FAILED) {\n        s3 = peg$parse__h();\n        if (s3 !== peg$FAILED) {\n          s4 = [];\n          s5 = peg$parseLineComment();\n          if (s5 === peg$FAILED) {\n            s5 = peg$parseEOL();\n          }\n          while (s5 !== peg$FAILED) {\n            s4.push(s5);\n            s5 = peg$parseLineComment();\n            if (s5 === peg$FAILED) {\n              s5 = peg$parseEOL();\n            }\n          }\n          if (s4 !== peg$FAILED) {\n            s1 = [s1, s2, s3, s4];\n            s0 = s1;\n          } else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n          }\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseConcat() {\n    var s0, s1, s2, s3;\n\n    s0 = peg$currPos;\n    s1 = peg$parse__();\n    if (s1 !== peg$FAILED) {\n      if (input.charCodeAt(peg$currPos) === 35) {\n        s2 = peg$c144;\n        peg$currPos++;\n      } else {\n        s2 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c145); }\n      }\n      if (s2 !== peg$FAILED) {\n        s3 = peg$parse__();\n        if (s3 !== peg$FAILED) {\n          s1 = [s1, s2, s3];\n          s0 = s1;\n        } else {\n          peg$currPos = s0;\n          s0 = peg$FAILED;\n        }\n      } else {\n        peg$currPos = s0;\n        s0 = peg$FAILED;\n      }\n    } else {\n      peg$currPos = s0;\n      s0 = peg$FAILED;\n    }\n\n    return s0;\n  }\n\n  function peg$parseEOL() {\n    var s0;\n\n    if (peg$c146.test(input.charAt(peg$currPos))) {\n      s0 = input.charAt(peg$currPos);\n      peg$currPos++;\n    } else {\n      s0 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c147); }\n    }\n\n    return s0;\n  }\n\n  function peg$parse_h() {\n    var s0, s1;\n\n    peg$silentFails++;\n    s0 = [];\n    if (peg$c149.test(input.charAt(peg$currPos))) {\n      s1 = input.charAt(peg$currPos);\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c150); }\n    }\n    if (s1 !== peg$FAILED) {\n      while (s1 !== peg$FAILED) {\n        s0.push(s1);\n        if (peg$c149.test(input.charAt(peg$currPos))) {\n          s1 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c150); }\n        }\n      }\n    } else {\n      s0 = peg$FAILED;\n    }\n    peg$silentFails--;\n    if (s0 === peg$FAILED) {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c148); }\n    }\n\n    return s0;\n  }\n\n  function peg$parse__h() {\n    var s0, s1;\n\n    peg$silentFails++;\n    s0 = [];\n    if (peg$c149.test(input.charAt(peg$currPos))) {\n      s1 = input.charAt(peg$currPos);\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c150); }\n    }\n    while (s1 !== peg$FAILED) {\n      s0.push(s1);\n      if (peg$c149.test(input.charAt(peg$currPos))) {\n        s1 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c150); }\n      }\n    }\n    peg$silentFails--;\n    if (s0 === peg$FAILED) {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c151); }\n    }\n\n    return s0;\n  }\n\n  function peg$parse_v() {\n    var s0, s1;\n\n    peg$silentFails++;\n    s0 = [];\n    if (peg$c146.test(input.charAt(peg$currPos))) {\n      s1 = input.charAt(peg$currPos);\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c147); }\n    }\n    if (s1 !== peg$FAILED) {\n      while (s1 !== peg$FAILED) {\n        s0.push(s1);\n        if (peg$c146.test(input.charAt(peg$currPos))) {\n          s1 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c147); }\n        }\n      }\n    } else {\n      s0 = peg$FAILED;\n    }\n    peg$silentFails--;\n    if (s0 === peg$FAILED) {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c152); }\n    }\n\n    return s0;\n  }\n\n  function peg$parse__v() {\n    var s0, s1;\n\n    peg$silentFails++;\n    s0 = [];\n    if (peg$c146.test(input.charAt(peg$currPos))) {\n      s1 = input.charAt(peg$currPos);\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c147); }\n    }\n    while (s1 !== peg$FAILED) {\n      s0.push(s1);\n      if (peg$c146.test(input.charAt(peg$currPos))) {\n        s1 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c147); }\n      }\n    }\n    peg$silentFails--;\n    if (s0 === peg$FAILED) {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c153); }\n    }\n\n    return s0;\n  }\n\n  function peg$parse_() {\n    var s0, s1;\n\n    peg$silentFails++;\n    s0 = [];\n    if (peg$c155.test(input.charAt(peg$currPos))) {\n      s1 = input.charAt(peg$currPos);\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c156); }\n    }\n    if (s1 !== peg$FAILED) {\n      while (s1 !== peg$FAILED) {\n        s0.push(s1);\n        if (peg$c155.test(input.charAt(peg$currPos))) {\n          s1 = input.charAt(peg$currPos);\n          peg$currPos++;\n        } else {\n          s1 = peg$FAILED;\n          if (peg$silentFails === 0) { peg$fail(peg$c156); }\n        }\n      }\n    } else {\n      s0 = peg$FAILED;\n    }\n    peg$silentFails--;\n    if (s0 === peg$FAILED) {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c154); }\n    }\n\n    return s0;\n  }\n\n  function peg$parse__() {\n    var s0, s1;\n\n    peg$silentFails++;\n    s0 = [];\n    if (peg$c155.test(input.charAt(peg$currPos))) {\n      s1 = input.charAt(peg$currPos);\n      peg$currPos++;\n    } else {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c156); }\n    }\n    while (s1 !== peg$FAILED) {\n      s0.push(s1);\n      if (peg$c155.test(input.charAt(peg$currPos))) {\n        s1 = input.charAt(peg$currPos);\n        peg$currPos++;\n      } else {\n        s1 = peg$FAILED;\n        if (peg$silentFails === 0) { peg$fail(peg$c156); }\n      }\n    }\n    peg$silentFails--;\n    if (s0 === peg$FAILED) {\n      s1 = peg$FAILED;\n      if (peg$silentFails === 0) { peg$fail(peg$c157); }\n    }\n\n    return s0;\n  }\n\n\n    /*\n      MIT License\n\n      Copyright (c) 2017 Derek P Sifford, parts copyright (c) 2019 by Emiliano Heyns\n\n      Permission is hereby granted, free of charge, to any person obtaining a copy\n      of this software and associated documentation files (the \"Software\"), to deal\n      in the Software without restriction, including without limitation the rights\n      to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n      copies of the Software, and to permit persons to whom the Software is\n      furnished to do so, subject to the following conditions:\n\n      The above copyright notice and this permission notice shall be included in all\n      copies or substantial portions of the Software.\n\n      THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n      IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n      FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n      AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n      LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n      OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n      SOFTWARE.\n    */\n\n    const markup = {\n      sl: 'italics',\n      em: 'italics',\n      it: 'italics',\n      itshape: 'italics',\n\n      bf: 'bold',\n      bfseries: 'bold',\n\n      sc: 'smallCaps',\n      scshape: 'smallCaps',\n\n      tt: 'fixedWidth',\n      rm: 'roman',\n      sf: 'sansSerif',\n      verb: 'verbatim',\n    }\n\n    const unnestFields = (options.unnestFields || []).map(field => field.toLowerCase())\n    const verbatimFields = (options.verbatimFields || [ 'urlraw', 'url', 'doi', 'file', 'files', 'eprint', 'verba', 'verbb', 'verbc' ]).map(field => typeof field === 'string' ? field.toLowerCase() : field)\n    const verbatimCommands = (options.verbatimCommands || ['texttt', 'url', 'href'])\n\n    function isVerbatimField(name) {\n      return verbatimFields.find(p => (typeof p === 'string') ? name === p : name.match(p))\n    }\n\n    function normalizeWhitespace(textArr) {\n      return textArr.reduce((prev, curr) => {\n        if (/\\s/.test(curr)) {\n          if (/\\s/.test(prev[prev.length - 1])) {\n            return prev;\n          } else {\n            return prev + ' ';\n          }\n        }\n        return prev + curr;\n      }, '');\n    }\n\n    const has_arguments = {\n      ElsevierGlyph: 1,\n      end: 1,\n      begin: 1,\n      bibcyr: 1,\n      bibstring: 1,\n      chsf: 1,\n      cite: 1,\n      cyrchar: 1,\n      ding: 1,\n      emph: 1,\n      enquote: 1,\n      frac: 2,\n      href: 2,\n      hspace: 1,\n      mathrm: 1,\n      mbox: 1,\n      mkbibbold: 1,\n      mkbibemph: 1,\n      mkbibitalic: 1,\n      mkbibquote: 1,\n      newcommand: 2,\n      noopsort: 1,\n      ocirc: 1,\n      section: 1,\n      sb: 1,\n      sp: 1,\n      subsection: 1,\n      subsubsection: 1,\n      subsubsubsection: 1,\n      t: 1,\n      textbf: 1,\n      textit: 1,\n      textrm: 1,\n      textsc: 1,\n      textsubscript: 1,\n      textsuperscript: 1,\n      texttt: 1,\n      url: 1,\n      vphantom: 1,\n      vspace: 1,\n    }\n\n    if (options.combiningDiacritics) {\n      for (const cmd of options.combiningDiacritics) {\n        has_arguments[cmd] = 1\n      }\n    }\n\n    function say() {\n      console.log(JSON.stringify(Array.from(arguments), null, 2))\n      return true\n    }\n\n    function peek(n) {\n      return input.substr(peg$savedPos, n)\n    }\n\n    const math = {\n      on: false,\n\n      set: function(state) {\n        this.on = state\n        return true\n      }\n    }\n\n    function basicTextConversions(node) {\n      if (node.kind !== 'Text') throw new Error(node.kind + ' is not a Text node')\n\n      switch (node.mode) {\n        case 'verbatim':\n          break\n\n        case 'math':\n          node.value = node.value.replace(/~/g, '\\u00A0')\n          break\n\n        case 'text':\n          node.value = node.value\n            .replace(/---/g, '\\u2014')\n            .replace(/--/g, '\\u2013')\n            .replace(/</g, '\\u00A1')\n            .replace(/>/g, '\\u00BF')\n            .replace(/~/g, '\\u00A0')\n            .replace(/``/g, options.markup.enquote.open)\n            .replace(/''/g, options.markup.enquote.close)\n          break\n\n        default:\n          throw new Error(`Unexpected text mode ${node.mode}`)\n      }\n\n      return node\n    }\n\n    function protect(v) {\n      let source\n      if (Array.isArray(v)) {\n        source = v.map(e => e.source).join('')\n      } else {\n        v = [ v ]\n        source = v.source\n      }\n\n      return {\n        kind: 'Block',\n        value: v,\n        markup: {},\n        case: 'protect',\n        source: source,\n      }\n    }\n\n    function handle_markup_switches(block) {\n      const value = block.value\n      if (!Array.isArray(value)) return block\n\n      block.value = []\n\n      const pseudo = {\n        block: null,\n        markup: {},\n      }\n      function pseudo_block() {\n        pseudo.block = {\n          kind: 'Block',\n          loc: location(),\n          source: '',\n          value: [],\n          markup: JSON.parse(JSON.stringify(pseudo.markup)),\n          pseudo: true,\n        }\n        block.value.push(pseudo.block)\n      }\n      for (const node of value) {\n        if (node.kind === 'Environment' || node.kind === 'Block') {\n          block.value.push(node)\n\n          if (Object.keys(pseudo.markup).length) {\n            pseudo_block()\n          } else {\n            pseudo.block = null\n          }\n          continue\n        }\n\n        if (node.kind === 'RegularCommand' && markup[node.command]) {\n          if (pseudo.markup.italics) { // https://github.com/citation-js/bibtex-parser-experiments/commit/cae475f075a05d1c074485a061b08ed245170c7e\n            delete pseudo.markup.italics\n            if (markup[node.command] !== 'italics') pseudo.markup[markup[node.command]] = true\n          } else {\n            pseudo.markup[markup[node.command]] = true\n          }\n\n          if (Object.keys(pseudo.markup).length) {\n            pseudo_block()\n          } else {\n             pseudo.block = null\n          }\n        }\n\n        if (pseudo.block) {\n          pseudo.block.source += node.source\n          pseudo.block.value.push(node)\n\n        } else {\n          block.value.push(node)\n\n        }\n      }\n\n      block.value = block.value.filter(node => !(node.pseudo && node.value.length === 0))\n\n      return block\n    }\n\n\n  peg$result = peg$startRuleFunction();\n\n  if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n    return peg$result;\n  } else {\n    if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n      peg$fail(peg$endExpectation());\n    }\n\n    throw peg$buildStructuredError(\n      peg$maxFailExpected,\n      peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null,\n      peg$maxFailPos < input.length\n        ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)\n        : peg$computeLocation(peg$maxFailPos, peg$maxFailPos)\n    );\n  }\n}\n\nmodule.exports = {\n  SyntaxError: peg$SyntaxError,\n  parse:       peg$parse\n};\n","\"use strict\";\n// Original work by Henrik Muehe (c) 2010\n//\n// CommonJS port by Mikola Lysenko 2013\n//\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parse = void 0;\nclass ParseError extends Error {\n    constructor(message, parser) {\n        message += ` @ ${parser.pos}`;\n        if (parser.parsing)\n            message += ` in ${JSON.stringify(parser.parsing)}`;\n        super(message);\n        this.name = 'ParseError';\n    }\n}\n// tslint:disable-next-line prefer-template\nconst letter = new RegExp('[' + [\n    // Letter, Uppercase\n    /\\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,\n    // Letter, Titlecase\n    /\\u01C5\\u01C8\\u01CB\\u01F2\\u1F88-\\u1F8F\\u1F98-\\u1F9F\\u1FA8-\\u1FAF\\u1FBC\\u1FCC\\u1FFC/.source,\n    // Letter, Lowercase\n    /\\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,\n    // Letter, Modifier\n    /\\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,\n    // Letter, Other\n    /\\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,\n].join('') + ']');\nclass BibtexParser {\n    parse(input, options = {}) {\n        // this._progress = 0\n        this.pos = 0;\n        this.input = input;\n        this.max_entries = options.max_entries || 0;\n        this.entries = 0;\n        this.parsing = null;\n        this.chunks = [];\n        if (options.async) {\n            return this.bibtexAsync().then(() => this.chunks);\n        }\n        else {\n            this.bibtex();\n            return this.chunks;\n        }\n    }\n    isWhitespace(s, horizontalOnly = false) {\n        return (s === ' ' || s === '\\t' || (!horizontalOnly && (s === '\\r' || s === '\\n')));\n    }\n    match(s) {\n        this.skipWhitespace();\n        if (this.input.substr(this.pos, s.length) !== s) {\n            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\n        }\n        this.pos += s.length;\n        this.skipWhitespace();\n    }\n    tryMatch(s) {\n        this.skipWhitespace();\n        return (this.input.substr(this.pos, s.length) === s);\n        // this.skipWhitespace()\n    }\n    skipWhitespace() {\n        while (this.pos < this.input.length && this.isWhitespace(this.input[this.pos]))\n            this.pos++;\n        // shady\n        if (this.input[this.pos] === '%') {\n            while (this.pos < this.input.length && this.input[this.pos] !== '\\n')\n                this.pos++;\n            while (this.pos < this.input.length && this.isWhitespace(this.input[this.pos]))\n                this.pos++;\n        }\n    }\n    value_braces() {\n        let bracecount = 0;\n        this.match('{');\n        const start = this.pos;\n        let math = false;\n        while (true) {\n            switch (this.input[this.pos]) {\n                case '\\\\':\n                    this.pos += 1;\n                    break;\n                case '{':\n                    bracecount++;\n                    break;\n                case '}':\n                    if (bracecount === 0) {\n                        if (math)\n                            throw new ParseError('Unclosed math section', this);\n                        this.pos++;\n                        return this.input.substring(start, this.pos - 1);\n                    }\n                    bracecount--;\n                    break;\n                case '$':\n                    math = !math;\n                    break;\n            }\n            this.pos++;\n            if (this.pos >= this.input.length) {\n                throw new ParseError(`Unterminated brace-value ${JSON.stringify(this.input.substr(start, 20))}`, this); // tslint:disable-line no-magic-numbers\n            }\n        }\n    }\n    value_quotes() {\n        this.match('\"');\n        const start = this.pos;\n        let bracecount = 0;\n        while (true) {\n            switch (this.input[this.pos]) {\n                case '\\\\':\n                    this.pos += 1;\n                    break;\n                case '{':\n                    bracecount++;\n                    break;\n                case '}':\n                    bracecount--;\n                    break;\n                case '\"':\n                    if (bracecount <= 0) {\n                        this.pos++;\n                        return this.input.substring(start, this.pos - 1);\n                    }\n            }\n            this.pos++;\n            if (this.pos >= this.input.length) {\n                throw new ParseError(`Unterminated quote-value ${JSON.stringify(this.input.substr(start, 20))}`, this); // tslint:disable-line no-magic-numbers\n            }\n        }\n    }\n    single_value() {\n        if (this.tryMatch('{')) {\n            return this.value_braces();\n        }\n        else if (this.tryMatch('\"')) {\n            return this.value_quotes();\n        }\n        else {\n            return this.key();\n        }\n    }\n    value() {\n        const values = [];\n        values.push(this.single_value());\n        while (this.tryMatch('#')) {\n            this.match('#');\n            values.push(this.single_value());\n        }\n        return values.join('');\n    }\n    key(allowUnicode = false) {\n        const start = this.pos;\n        while (true) {\n            if (this.pos === this.input.length) {\n                throw new ParseError('Runaway key', this);\n            }\n            if (this.input[this.pos].match(/['a-zA-Z0-9&;_:\\\\./-]/)) {\n                this.pos++;\n            }\n            else if (allowUnicode && this.input[this.pos].match(letter)) {\n                this.pos++;\n            }\n            else {\n                return this.input.substring(start, this.pos);\n            }\n        }\n    }\n    key_equals_value() {\n        const key = this.key();\n        if (!this.tryMatch('=')) {\n            throw new ParseError(`... = value expected, equals sign missing: ${JSON.stringify(this.input.substr(this.pos, 20))}...`, this); // tslint:disable-line no-magic-numbers\n        }\n        this.match('=');\n        const val = this.value();\n        return [key, val];\n    }\n    key_value_list() {\n        this.key_equals_value();\n        while (this.tryMatch(',')) {\n            this.match(',');\n            // fixes problems with commas at the end of a list\n            if (this.tryMatch('}')) {\n                break;\n            }\n            this.key_equals_value();\n        }\n    }\n    entry(d) {\n        this.parsing = this.key(true);\n        this.match(',');\n        this.key_value_list();\n    }\n    directive() {\n        this.match('@');\n        return `@${this.key()}`.toLowerCase();\n    }\n    string() {\n        this.key_equals_value();\n    }\n    preamble() {\n        this.value();\n    }\n    comment() {\n        while (this.isWhitespace(this.input[this.pos], true))\n            this.pos++;\n        if (this.input[this.pos] === '{') {\n            this.value_braces();\n            return;\n        }\n        while (this.input[this.pos] !== '\\n' && this.pos < this.input.length)\n            this.pos++;\n    }\n    /*\n    private progress() {\n      const progress = Math.round((this.pos / this.input.length * 100) / 5) * 5 // tslint:disable-line no-magic-numbers\n      if (this._progress !== progress) {\n        this._progress = progress\n        process.stdout.write(` (${this._progress}%) `)\n      }\n    }\n    */\n    hasMore() {\n        if (this.max_entries && this.entries >= this.max_entries)\n            return false;\n        return (this.pos < this.input.length);\n    }\n    bibtex() {\n        while (this.hasMore()) {\n            this.parseNext();\n        }\n    }\n    bibtexAsync() {\n        return this.hasMore() ? (new Promise(resolve => resolve(this.parseNext()))).then(() => this.bibtexAsync()) : Promise.resolve(null);\n    }\n    parseNext() {\n        // this.progress()\n        const chunk = {\n            offset: {\n                pos: this.pos,\n                line: this.input.substring(0, this.pos).split('\\n').length - 1,\n            },\n            error: null,\n            text: null,\n        };\n        this.skipWhitespace();\n        if (this.pos >= this.input.length)\n            return;\n        let guard = '';\n        try {\n            const d = this.directive();\n            switch (d) {\n                case '@string':\n                    this.match('{');\n                    this.string();\n                    this.match('}');\n                    chunk.stringDeclaration = true;\n                    break;\n                case '@preamble':\n                    this.match('{');\n                    this.preamble();\n                    this.match('}');\n                    chunk.preamble = true;\n                    break;\n                case '@comment':\n                    this.comment();\n                    chunk.comment = true;\n                    break;\n                default:\n                    if (this.tryMatch('{')) {\n                        guard = '{}';\n                    }\n                    else if (this.tryMatch('(')) {\n                        guard = '()';\n                    }\n                    else {\n                        throw new ParseError(`Token mismatch, expected '{' or '(', found ${JSON.stringify(this.input.substr(this.pos, 20))}...`, this); // tslint:disable-line no-magic-numbers\n                    }\n                    this.match(guard[0]);\n                    this.entry(d);\n                    this.match(guard[1]);\n                    chunk.entry = true;\n                    this.entries++;\n                    break;\n            }\n        }\n        catch (err) {\n            if (err.name !== 'ParseError')\n                throw err;\n            chunk.error = err.message,\n                // skip ahead to the next @ and try again\n                this.pos = chunk.offset.pos + 1;\n            while (this.pos < this.input.length && this.input[this.pos] !== '@')\n                this.pos++;\n        }\n        const text = this.input.substring(chunk.offset.pos, this.pos);\n        const last = this.chunks.length - 1;\n        if (chunk.error && this.chunks.length && this.chunks[last].error) {\n            this.chunks[last].text += text;\n        }\n        else {\n            chunk.text = text;\n            this.chunks.push(chunk);\n        }\n    }\n}\n/**\n * 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\n * make the more sophisticated [[bibtex.parse]] reject the whole file\n *\n * @returns array of chunks, with markers for type and errors (if any) found.\n */\nfunction parse(input, options = {}) {\n    return (new BibtexParser).parse(input, options);\n}\nexports.parse = parse;\n//# sourceMappingURL=chunker.js.map","module.exports = {\n  ascii: require('./tables/ascii.json'),\n  ascii_bibtex_creator: require('./tables/ascii-bibtex-creator.json'),\n  unicode: require('./tables/unicode.json'),\n  latex: require('./tables/latex.json'),\n  diacritics: require('./tables/diacritics.json'),\n};\n","module.exports = [\n    {\n        'name': 'C',\n        'alias': 'Other',\n        'isBmpLast': true,\n        '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',\n        '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]'\n    },\n    {\n        'name': 'Cc',\n        'alias': 'Control',\n        'bmp': '\\0-\\x1F\\x7F-\\x9F'\n    },\n    {\n        'name': 'Cf',\n        'alias': 'Format',\n        'bmp': '\\xAD\\u0600-\\u0605\\u061C\\u06DD\\u070F\\u08E2\\u180E\\u200B-\\u200F\\u202A-\\u202E\\u2060-\\u2064\\u2066-\\u206F\\uFEFF\\uFFF9-\\uFFFB',\n        'astral': '\\uD804[\\uDCBD\\uDCCD]|\\uD80D[\\uDC30-\\uDC38]|\\uD82F[\\uDCA0-\\uDCA3]|\\uD834[\\uDD73-\\uDD7A]|\\uDB40[\\uDC01\\uDC20-\\uDC7F]'\n    },\n    {\n        'name': 'Cn',\n        'alias': 'Unassigned',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'Co',\n        'alias': 'Private_Use',\n        'bmp': '\\uE000-\\uF8FF',\n        'astral': '[\\uDB80-\\uDBBE\\uDBC0-\\uDBFE][\\uDC00-\\uDFFF]|[\\uDBBF\\uDBFF][\\uDC00-\\uDFFD]'\n    },\n    {\n        'name': 'Cs',\n        'alias': 'Surrogate',\n        'bmp': '\\uD800-\\uDFFF'\n    },\n    {\n        'name': 'L',\n        'alias': 'Letter',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'LC',\n        'alias': 'Cased_Letter',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'Ll',\n        'alias': 'Lowercase_Letter',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'Lm',\n        'alias': 'Modifier_Letter',\n        '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',\n        'astral': '\\uD81A[\\uDF40-\\uDF43]|\\uD81B[\\uDF93-\\uDF9F\\uDFE0\\uDFE1\\uDFE3]|\\uD838[\\uDD37-\\uDD3D]|\\uD83A\\uDD4B'\n    },\n    {\n        'name': 'Lo',\n        'alias': 'Other_Letter',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'Lt',\n        'alias': 'Titlecase_Letter',\n        'bmp': '\\u01C5\\u01C8\\u01CB\\u01F2\\u1F88-\\u1F8F\\u1F98-\\u1F9F\\u1FA8-\\u1FAF\\u1FBC\\u1FCC\\u1FFC'\n    },\n    {\n        'name': 'Lu',\n        'alias': 'Uppercase_Letter',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'M',\n        'alias': 'Mark',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'Mc',\n        'alias': 'Spacing_Mark',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'Me',\n        'alias': 'Enclosing_Mark',\n        'bmp': '\\u0488\\u0489\\u1ABE\\u20DD-\\u20E0\\u20E2-\\u20E4\\uA670-\\uA672'\n    },\n    {\n        'name': 'Mn',\n        'alias': 'Nonspacing_Mark',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'N',\n        'alias': 'Number',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'Nd',\n        'alias': 'Decimal_Number',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'Nl',\n        'alias': 'Letter_Number',\n        'bmp': '\\u16EE-\\u16F0\\u2160-\\u2182\\u2185-\\u2188\\u3007\\u3021-\\u3029\\u3038-\\u303A\\uA6E6-\\uA6EF',\n        'astral': '\\uD800[\\uDD40-\\uDD74\\uDF41\\uDF4A\\uDFD1-\\uDFD5]|\\uD809[\\uDC00-\\uDC6E]'\n    },\n    {\n        'name': 'No',\n        'alias': 'Other_Number',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'P',\n        'alias': 'Punctuation',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'Pc',\n        'alias': 'Connector_Punctuation',\n        'bmp': '_\\u203F\\u2040\\u2054\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF3F'\n    },\n    {\n        'name': 'Pd',\n        'alias': 'Dash_Punctuation',\n        'bmp': '\\\\-\\u058A\\u05BE\\u1400\\u1806\\u2010-\\u2015\\u2E17\\u2E1A\\u2E3A\\u2E3B\\u2E40\\u301C\\u3030\\u30A0\\uFE31\\uFE32\\uFE58\\uFE63\\uFF0D',\n        'astral': '\\uD803\\uDEAD'\n    },\n    {\n        'name': 'Pe',\n        'alias': 'Close_Punctuation',\n        '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'\n    },\n    {\n        'name': 'Pf',\n        'alias': 'Final_Punctuation',\n        'bmp': '\\xBB\\u2019\\u201D\\u203A\\u2E03\\u2E05\\u2E0A\\u2E0D\\u2E1D\\u2E21'\n    },\n    {\n        'name': 'Pi',\n        'alias': 'Initial_Punctuation',\n        'bmp': '\\xAB\\u2018\\u201B\\u201C\\u201F\\u2039\\u2E02\\u2E04\\u2E09\\u2E0C\\u2E1C\\u2E20'\n    },\n    {\n        'name': 'Po',\n        'alias': 'Other_Punctuation',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'Ps',\n        'alias': 'Open_Punctuation',\n        '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'\n    },\n    {\n        'name': 'S',\n        'alias': 'Symbol',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'Sc',\n        'alias': 'Currency_Symbol',\n        'bmp': '\\\\$\\xA2-\\xA5\\u058F\\u060B\\u07FE\\u07FF\\u09F2\\u09F3\\u09FB\\u0AF1\\u0BF9\\u0E3F\\u17DB\\u20A0-\\u20BF\\uA838\\uFDFC\\uFE69\\uFF04\\uFFE0\\uFFE1\\uFFE5\\uFFE6',\n        'astral': '\\uD807[\\uDFDD-\\uDFE0]|\\uD838\\uDEFF|\\uD83B\\uDCB0'\n    },\n    {\n        'name': 'Sk',\n        'alias': 'Modifier_Symbol',\n        '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',\n        'astral': '\\uD83C[\\uDFFB-\\uDFFF]'\n    },\n    {\n        'name': 'Sm',\n        'alias': 'Math_Symbol',\n        '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',\n        'astral': '\\uD835[\\uDEC1\\uDEDB\\uDEFB\\uDF15\\uDF35\\uDF4F\\uDF6F\\uDF89\\uDFA9\\uDFC3]|\\uD83B[\\uDEF0\\uDEF1]'\n    },\n    {\n        'name': 'So',\n        'alias': 'Other_Symbol',\n        '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',\n        '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]'\n    },\n    {\n        'name': 'Z',\n        'alias': 'Separator',\n        'bmp': ' \\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000'\n    },\n    {\n        'name': 'Zl',\n        'alias': 'Line_Separator',\n        'bmp': '\\u2028'\n    },\n    {\n        'name': 'Zp',\n        'alias': 'Paragraph_Separator',\n        'bmp': '\\u2029'\n    },\n    {\n        'name': 'Zs',\n        'alias': 'Space_Separator',\n        'bmp': ' \\xA0\\u1680\\u2000-\\u200A\\u202F\\u205F\\u3000'\n    }\n];\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parse = void 0;\nfunction decode(s, sep = ';') {\n    s = s.replace(/\\n/g, '');\n    let pos = 0;\n    const records = [''];\n    while (pos < s.length) {\n        switch (s[pos]) {\n            case '\\\\':\n                pos++;\n                records[0] += s[pos];\n                break;\n            case sep:\n                records.unshift('');\n                break;\n            default:\n                records[0] += s[pos];\n        }\n        pos++;\n    }\n    return records.reverse().filter(record => record);\n}\nconst prefixes = {\n    fileDirectory: 'jabref-meta: fileDirectory:',\n    groupsversion: 'jabref-meta: groupsversion:',\n    groupstree: 'jabref-meta: groupstree:',\n    grouping: 'jabref-meta: grouping:',\n};\n/**\n * 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.\n *\n * JabRef knows several group types, and this parser parses most, but not all of them:\n *\n * * independent group: the keys listed in the group are the entries that are considered to belong to it\n * * intersection: the keys listed in the group are considered to belong to the group if they're also in the parent group\n * * union: the keys listed in the group are considered to belong to the group, and also the keys that are in the parent group\n * * query: not supported by this parser\n */\nfunction parse(comments) {\n    const result = {\n        root: [],\n        groups: {},\n        fileDirectory: '',\n        version: '',\n    };\n    const levels = [];\n    const decoded = {\n        fileDirectory: null,\n        groupsversion: null,\n        groupstree: null,\n        grouping: null,\n    };\n    for (const comment of comments) {\n        for (const [meta, prefix] of Object.entries(prefixes)) {\n            if (comment.startsWith(prefix)) {\n                decoded[meta] = decode(comment.substring(prefix.length));\n            }\n        }\n    }\n    result.version = decoded.groupsversion && decoded.groupsversion[0];\n    result.fileDirectory = decoded.fileDirectory && decoded.fileDirectory[0];\n    for (const tree of ['groupstree', 'grouping']) {\n        if (!decoded[tree])\n            continue;\n        for (const encoded of decoded[tree]) {\n            const fields = decode(encoded);\n            const level_type_name = decode(fields.shift(), ':');\n            const m = /^([0-9]+) (.+)/.exec(level_type_name[0]);\n            if (!m)\n                break;\n            const level = parseInt(m[1]);\n            const type = m[2]; // test for StaticGroup?\n            if (type === 'AllEntriesGroup')\n                continue; // root\n            const name = level_type_name[1];\n            const intersection = decode(fields.shift())[0];\n            const keys = tree === 'grouping' ? [] : fields.map(field => decode(field)[0]);\n            const group = {\n                name,\n                entries: keys,\n                groups: [],\n            };\n            result.groups[name] = result.groups[name] || group;\n            if (levels.length < level) {\n                levels.push(group);\n            }\n            else {\n                levels[level - 1] = group;\n            }\n            if (level === 1) {\n                result.root.push(group);\n            }\n            else {\n                const parent = levels[level - 2];\n                switch (intersection) {\n                    case '0': // independent\n                        break;\n                    case '1': // intersect\n                        group.entries = group.entries.filter(key => parent.entries.includes(key));\n                        break;\n                    case '2': // union\n                        group.entries = group.entries.concat(parent.entries.filter(key => !group.entries.includes(key)));\n                        break;\n                }\n                levels[level - 2].groups.push(group);\n            }\n        }\n    }\n    return result;\n}\nexports.parse = parse;\n//# sourceMappingURL=jabref.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.jabref = exports.chunker = exports.ast = exports.parse = void 0;\nconst bibtex = require(\"./grammar\");\nconst chunker_1 = require(\"./chunker\");\nconst unicode2latex_1 = require(\"unicode2latex\");\nclass ParserError extends Error {\n    constructor(message, node) {\n        super(message); // 'Error' breaks prototype chain here\n        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain\n        this.name = this.constructor.name;\n        this.node = node;\n    }\n}\nclass TeXError extends Error {\n    constructor(message, node, text) {\n        super(message); // 'Error' breaks prototype chain here\n        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain\n        this.name = this.constructor.name;\n        this.node = node;\n        this.text = text;\n    }\n}\nconst charCategories = require(\"xregexp/tools/output/categories\");\nconst charClass = {\n    Lu: charCategories.filter(cat => ['Uppercase_Letter', 'Titlecase_Letter'].includes(cat.alias)).map(cat => cat.bmp).join(''),\n    Ll: charCategories.find(cat => cat.alias === 'Lowercase_Letter').bmp,\n    LnotLu: charCategories.filter(cat => ['Lowercase_Letter', 'Modifier_Letter', 'Other_Letter', 'Nonspacing_Mark', 'Spacing_Mark', 'Decimal_Number', 'Letter_Number'].includes(cat.alias)).map(cat => cat.bmp).join(''),\n    P: charCategories.find(cat => cat.alias === 'Punctuation').bmp,\n    L: charCategories.find(cat => cat.alias === 'Letter').bmp,\n    N: charCategories.filter(cat => ['Decimal_Number', 'Letter_Number'].includes(cat.alias)).map(cat => cat.bmp).join(''),\n    AlphaNum: charCategories.filter(cat => ['Letter', 'Decimal_Number', 'Letter_Number'].includes(cat.alias)).map(cat => cat.bmp).join(''),\n    LC: charCategories.find(cat => cat.alias === 'Cased_Letter').bmp,\n};\nconst marker = {\n    and: '\\u0001',\n    comma: '\\u0002',\n    space: '\\u0003',\n    literal: '\\u0004',\n    markup: '\\u0005',\n    re: {\n        and: /./,\n        comma: /./,\n        space: /./,\n        literal: /./,\n        literalName: /./,\n    },\n    clean(s) {\n        return s.replace(marker.re.space, ' ').replace(marker.re.comma, ', ').replace(marker.re.literal, '');\n    },\n};\nmarker.re = {\n    and: new RegExp(marker.and, 'g'),\n    comma: new RegExp(marker.comma, 'g'),\n    space: new RegExp(marker.space, 'g'),\n    literal: new RegExp(marker.literal, 'g'),\n    literalName: new RegExp(`^${marker.literal}([^${marker.literal}]*)${marker.literal}$`),\n};\nconst preserveCase = {\n    leadingCap: new RegExp(`^[${charClass.Lu}][${charClass.LnotLu}]+[${charClass.P}]?$`),\n    allCaps: new RegExp(`^[${charClass.Lu}${charClass.N}]{2,}$`),\n    allLower: new RegExp(`^[${charClass.Ll}${charClass.N}]{2,}$`),\n    joined: new RegExp(`^[${charClass.Lu}][${charClass.LnotLu}]*([-+][${charClass.L}${charClass.N}]+)*[${charClass.P}]*$`),\n    hasUpper: new RegExp(`[${charClass.Lu}]`),\n    hasLower: new RegExp(`[${charClass.Ll}]`),\n    isNumber: /^[0-9]+$/,\n    hasAlpha: new RegExp(`[${charClass.L}]`),\n    hasAlphaNum: new RegExp(`[${charClass.AlphaNum}]`),\n    notAlphaNum: new RegExp(`[^${charClass.AlphaNum}]`, 'g'),\n    sentenceStart: new RegExp(`(^|([\\u2014:?!.]\\\\s+))[${charClass.Lu}]`, 'g'),\n    markup: /<\\/?span[^>]*>/g,\n    acronym: new RegExp(`.*\\\\.${marker.markup}*[${charClass.Lu}]${marker.markup}*\\\\.$`),\n    notCaseSensitive: new RegExp(`[^${charClass.LC}]`),\n    isCaseSensitive: new RegExp(`[${charClass.LC}]`),\n    quoted: /(\"[^\"]+\")|(“[^“]+“)/g,\n};\nconst fields = {\n    creator: [\n        'author',\n        'bookauthor',\n        'collaborator',\n        'commentator',\n        'director',\n        'editor',\n        'editora',\n        'editorb',\n        'editors',\n        'holder',\n        'scriptwriter',\n        'translator',\n    ],\n    title: [\n        'title',\n        'series',\n        'shorttitle',\n        'booktitle',\n        'type',\n        'origtitle',\n        'maintitle',\n        'eventtitle',\n    ],\n    unnest: [\n        'publisher',\n        'location',\n    ],\n    verbatim: [\n        'url',\n        'doi',\n        'file',\n        'files',\n        'eprint',\n        'verba',\n        'verbb',\n        'verbc',\n        'groups',\n    ],\n    html: [\n        'annotation',\n        'comment',\n        'annote',\n        'review',\n        'notes',\n        'note',\n    ],\n    unabbrev: [\n        'journal',\n        'journaltitle',\n        'journal-full',\n    ],\n};\nconst english = [\n    'american',\n    'british',\n    'canadian',\n    'english',\n    'australian',\n    'newzealand',\n    'usenglish',\n    'ukenglish',\n    'en',\n    'eng',\n    'en-au',\n    'en-bz',\n    'en-ca',\n    'en-cb',\n    'en-gb',\n    'en-ie',\n    'en-jm',\n    'en-nz',\n    'en-ph',\n    'en-tt',\n    'en-us',\n    'en-za',\n    'en-zw',\n    'anglais',\n];\nclass Parser {\n    constructor(options = {}) {\n        this.in_preamble = false;\n        this.preamble = [];\n        this.log = function (str) { }; // tslint:disable-line variable-name only-arrow-functions no-empty\n        for (const [option, value] of Object.entries(options)) {\n            if (typeof value === 'undefined')\n                delete options[option];\n        }\n        if (options.errorHandler === false) {\n            // tslint:disable-next-line only-arrow-functions no-empty\n            options.errorHandler = function (err) { };\n        }\n        else if (options.errorHandler === undefined) {\n            // tslint:disable-next-line only-arrow-functions\n            options.errorHandler = function (err) { throw err; };\n        }\n        if (typeof options.sentenceCase === 'boolean') {\n            options.sentenceCase = options.sentenceCase ? english : [];\n        }\n        else {\n            options.sentenceCase = options.sentenceCase || english;\n        }\n        if (!options.strings)\n            options.strings = {};\n        if (!options.unabbreviate)\n            options.unabbreviate = {};\n        if (options.raw) {\n            options.sentenceCase = false;\n            options.caseProtection = false;\n        }\n        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);\n        const markup_defaults = {\n            enquote: { open: '\\u201c', close: '\\u201d' },\n            sub: { open: '<sub>', close: '</sub>' },\n            sup: { open: '<sup>', close: '</sup>' },\n            bold: { open: '<b>', close: '</b>' },\n            italics: { open: '<i>', close: '</i>' },\n            smallCaps: { open: '<span style=\"font-variant:small-caps;\">', close: '</span>' },\n            caseProtect: { open: '<span class=\"nocase\">', close: '</span>' },\n            roman: { open: '', close: '' },\n            fixedWidth: { open: '', close: '' },\n        };\n        // patch in because the options will likely not have enquote and case-protect\n        for (const [markup, { open, close }] of Object.entries(markup_defaults)) {\n            this.options.markup[markup] = this.options.markup[markup] || { open, close };\n        }\n        for (const i of [1, 2, 3, 4]) { // tslint:disable-line:no-magic-numbers\n            this.options.markup[`h${i}`] = this.options.markup[`h${i}`] || { open: `<h${i}>`, close: `</h${i}>` };\n        }\n        this.unresolvedStrings = {};\n        this.errors = [];\n        this.comments = [];\n        this.entries = [];\n        this.strings = {};\n        this.newcommands = {};\n        this.default_strings = {\n            JAN: [this.text('01')],\n            FEB: [this.text('02')],\n            MAR: [this.text('03')],\n            APR: [this.text('04')],\n            MAY: [this.text('05')],\n            JUN: [this.text('06')],\n            JUL: [this.text('07')],\n            AUG: [this.text('08')],\n            SEP: [this.text('09')],\n            OCT: [this.text('10')],\n            NOV: [this.text('11')],\n            DEC: [this.text('12')],\n            ACMCS: [this.text('ACM Computing Surveys')],\n            ACTA: [this.text('Acta Informatica')],\n            CACM: [this.text('Communications of the ACM')],\n            IBMJRD: [this.text('IBM Journal of Research and Development')],\n            IBMSJ: [this.text('IBM Systems Journal')],\n            IEEESE: [this.text('IEEE Transactions on Software Engineering')],\n            IEEETC: [this.text('IEEE Transactions on Computers')],\n            IEEETCAD: [this.text('IEEE Transactions on Computer-Aided Design of Integrated Circuits')],\n            IPL: [this.text('Information Processing Letters')],\n            JACM: [this.text('Journal of the ACM')],\n            JCSS: [this.text('Journal of Computer and System Sciences')],\n            SCP: [this.text('Science of Computer Programming')],\n            SICOMP: [this.text('SIAM Journal on Computing')],\n            TOCS: [this.text('ACM Transactions on Computer Systems')],\n            TODS: [this.text('ACM Transactions on Database Systems')],\n            TOG: [this.text('ACM Transactions on Graphics')],\n            TOMS: [this.text('ACM Transactions on Mathematical Software')],\n            TOOIS: [this.text('ACM Transactions on Office Information Systems')],\n            TOPLAS: [this.text('ACM Transactions on Programming Languages and Systems')],\n            TCS: [this.text('Theoretical Computer Science')],\n        };\n    }\n    ast(input, clean = true) {\n        const _ast = [];\n        for (const chunk of chunker_1.parse(input)) {\n            let chunk_ast = bibtex.parse(chunk.text, Object.assign(Object.assign({}, this.options), { combiningDiacritics: unicode2latex_1.diacritics.commands }));\n            if (clean)\n                chunk_ast = this.clean(chunk_ast);\n            _ast.push(chunk_ast);\n        }\n        return _ast;\n    }\n    parse(input) {\n        return this.options.async ? this.parseAsync(input) : this.parseSync(input);\n    }\n    parseSync(input) {\n        for (const chunk of chunker_1.parse(input)) {\n            this.parseChunk(chunk);\n        }\n        return this.parsed();\n    }\n    async parseAsync(input) {\n        for (const chunk of await chunker_1.parse(input, { async: true })) {\n            this.parseChunk(chunk);\n        }\n        return this.parsed();\n    }\n    parsed() {\n        this.field = null;\n        const strings = {};\n        this.cleaning = { type: 'other' };\n        for (const [key, value] of Object.entries(this.strings)) {\n            this.field = {\n                name: '@string',\n                text: '',\n                level: 0,\n                preserveRanges: null,\n                words: {\n                    upper: 0,\n                    lower: 0,\n                    other: 0,\n                },\n            };\n            this.convert(this.clean(value));\n            strings[key] = this.field.text;\n        }\n        return {\n            errors: this.errors,\n            entries: this.entries,\n            comments: this.comments,\n            strings,\n            preamble: this.preamble,\n        };\n    }\n    preserve(start, end, reason) {\n        if (!this.field.preserveRanges)\n            return;\n        if (!end) {\n            this.field.preserveRanges = null;\n            return;\n        }\n        /*\n        this.field.preserveRanges = this.field.preserveRanges.filter(range => range.start < start || range.end > end)\n        if (this.field.preserveRanges.find(range => range.start <= start && range.end >= end)) return\n        */\n        /*\n        if (this.field.preserveRanges && this.field.preserveRanges.length) {\n          const last = this.field.preserveRanges[this.field.preserveRanges.length - 1]\n          if (start < last.start) throw new Error(JSON.stringify({...last, new: { start, end, reason }, text: this.field.text}))\n        }\n        */\n        this.field.preserveRanges.push({ start, end, reason });\n    }\n    parseChunk(chunk) {\n        this.chunk = chunk.text;\n        try {\n            let bib = bibtex.parse(chunk.text, Object.assign(Object.assign({}, this.options), { combiningDiacritics: unicode2latex_1.diacritics.commands }));\n            if (bib.kind !== 'Bibliography')\n                throw new Error(this.show(bib));\n            bib = this.clean(bib);\n            for (const entity of bib.children) {\n                switch (entity.kind) {\n                    case 'Entry':\n                    case 'BracedComment':\n                    case 'LineComment':\n                    case 'PreambleExpression':\n                        this.convert(entity);\n                        break;\n                    case 'StringDeclaration':\n                    case 'NonEntryText':\n                        break;\n                }\n            }\n            return bib;\n        }\n        catch (err) {\n            if (!err.location)\n                throw err;\n            this.errors.push({\n                message: err.message,\n                line: err.location.start.line + chunk.offset.line,\n                column: err.location.start.column,\n                source: this.chunk,\n            });\n            return null;\n        }\n    }\n    show(o) {\n        // tslint:disable-next-line prefer-template\n        let text = JSON.stringify(o);\n        if (this.chunk)\n            text += '\\n' + this.chunk.trim();\n        return text;\n    }\n    text(value = '') {\n        return { kind: 'Text', value, mode: 'text' };\n    }\n    error(err, returnvalue) {\n        if (typeof this.options.errorHandler === 'function')\n            this.options.errorHandler(err);\n        return returnvalue;\n    }\n    condense(node) {\n        // apply cleaning to resulting children\n        node.value = node.value.map(child => this.clean(child));\n        // unpack redundant blocks\n        node.value = node.value.reduce((acc, child, i) => {\n            if (child.kind === 'Block' && !child.case && Object.keys(child.markup).length === 0) {\n                acc = acc.concat(child.value);\n            }\n            else {\n                acc.push(child);\n            }\n            return acc;\n        }, []);\n        // condense text nodes to make whole words for sentence casing\n        node.value = node.value.reduce((acc, child, i) => {\n            if (acc.length === 0) {\n                acc.push(child);\n                return acc;\n            }\n            const last = acc[acc.length - 1];\n            const next = node.value[i + 1];\n            if (this.options.caseProtection === 'strict' && this.onlyCaseProtected(last) && child.kind === 'Text' && !child.value.match(preserveCase.isCaseSensitive) && this.onlyCaseProtected(next)) {\n                last.value.push(child);\n                delete last.source;\n                return acc;\n            }\n            if (last.kind === 'Block' && child.kind === 'Block' && Object.keys(last.markup).sort().join('/') === Object.keys(child.markup).sort().join('/')) {\n                last.value = last.value.concat(child.value);\n                delete last.source;\n                return acc;\n            }\n            if (last.kind === 'Text' && child.kind === 'Text' && last.mode === child.mode) {\n                last.value += child.value;\n                delete last.source;\n                return acc;\n            }\n            acc.push(child);\n            return acc;\n        }, []);\n    }\n    onlyCaseProtected(node) {\n        return (node === null || node === void 0 ? void 0 : node.kind) === 'Block' && node.case === 'protect' && Object.keys(node.markup).join('/') === '';\n    }\n    argument(node, kind) {\n        if (!node.arguments || !node.arguments.required.length)\n            return (kind === 'none');\n        // expect 'n' text arguments\n        if (typeof kind === 'number') {\n            if (node.arguments.required.length !== kind)\n                return false;\n            return node.arguments.required;\n        }\n        // return first argument if it's the only one\n        if (node.arguments.required.length !== 1)\n            return false;\n        // loose checking for text\n        if (kind === 'text') {\n            const first = node.arguments.required[0];\n            if (first.kind === 'Block' && first.value.length === 1) {\n                if (first.value[0].kind === 'Text')\n                    return first.value[0].value;\n            }\n            // fall back to strict kind check\n            kind = 'Text';\n        }\n        // return first argument if it's the only one and is of the specified kind\n        if (node.arguments.required.length !== 1 || node.arguments.required[0].kind !== kind)\n            return false;\n        switch (kind) {\n            case 'Text':\n                return node.arguments.required[0].value;\n            case 'RegularCommand':\n            case 'Block':\n                return node.arguments.required[0];\n        }\n        return false;\n    }\n    clean(node) {\n        if (Array.isArray(node))\n            return node.map(child => this.clean(child));\n        delete node.loc;\n        switch (node.kind) {\n            case 'InlineMath':\n            case 'DisplayMath':\n                return this.clean_block(node);\n            case 'Environment':\n                return this.clean_environment(node);\n            case 'Block':\n                return this.clean_block(node);\n            case 'Bibliography':\n                return this.clean_bib(node);\n            case 'RegularCommand':\n                return this.clean_command(node);\n            case 'DiacriticCommand':\n                return this.clean_diacritic(node);\n            case 'Entry':\n                return this.clean_entry(node);\n            case 'Field':\n                return this.options.raw ? node : this.clean_field(node);\n            case 'StringDeclaration':\n                return this.clean_stringdecl(node);\n            case 'StringReference':\n                return this.clean_stringref(node);\n            case 'SubscriptCommand':\n            case 'SuperscriptCommand':\n                return this.clean_script(node);\n            case 'SymbolCommand':\n                return this.clean_symbol(node);\n            case 'PreambleExpression':\n                return this.clean_preamble(node);\n            case 'Number':\n            case 'Text':\n            case 'BracedComment':\n            case 'LineComment':\n                return node;\n            default:\n                return this.error(new ParserError(`no cleanup method for ${this.show(node)}`, node), this.text());\n        }\n    }\n    clean_preamble(node) {\n        this.in_preamble = true;\n        const clean = this.clean(node.value);\n        this.in_preamble = false;\n        return clean;\n    }\n    clean_bib(node) {\n        node.children = node.children.filter(child => child.kind !== 'NonEntryText').map(child => this.clean(child));\n        return node;\n    }\n    clean_stringdecl(node) {\n        this.strings[node.name.toUpperCase()] = node.value;\n        return node;\n    }\n    clean_stringref(node) {\n        var _a;\n        const name = node.name.toUpperCase();\n        const _string = this.strings[name]\n            || this.options.strings[name]\n            || this.default_strings[name]\n            || (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)]);\n        if (!_string) {\n            if (!this.unresolvedStrings[name])\n                this.errors.push({ message: `Unresolved @string reference ${JSON.stringify(node.name)}` });\n            this.unresolvedStrings[name] = true;\n        }\n        return this.clean({\n            kind: 'Block',\n            // if the string isn't found, add it as-is but exempt it from sentence casing\n            case: _string ? undefined : 'preserve',\n            markup: {},\n            value: _string ? JSON.parse(JSON.stringify(_string)) : [this.text(node.name)],\n        });\n    }\n    clean_entry(node) {\n        const shortjournals = [];\n        for (const field of node.fields) {\n            if (fields.unabbrev.includes(field.name) && Array.isArray(field.value)) {\n                const abbr = field.value.map(v => v.source).join('');\n                const journal = this.options.unabbreviate[abbr];\n                if (journal) {\n                    shortjournals.push(Object.assign(Object.assign({}, JSON.parse(JSON.stringify(field))), { name: 'shortjournal' }));\n                    field.value = JSON.parse(JSON.stringify(journal.ast));\n                }\n            }\n        }\n        node.fields = node.fields.concat(shortjournals).map(child => this.clean(child));\n        return node;\n    }\n    startCleaning(name) {\n        name = name.toLowerCase();\n        if (fields.title.includes(name)) {\n            this.cleaning = { type: 'title', name };\n        }\n        else if (fields.creator.includes(name.replace(/s$/, ''))) {\n            this.cleaning = { type: 'creator', name: name.replace(/s$/, '') };\n        }\n        else {\n            this.cleaning = { type: 'other', name };\n        }\n    }\n    stripNoCase(node, strip, preserve) {\n        switch (node.kind) {\n            case 'RegularCommand':\n                // a bit cheaty to assume these to be nocased, but it's just more likely to be what people want\n                if (['chsf', 'bibstring', 'cite'].includes(node.command))\n                    strip = true;\n                node.arguments.required.map(arg => this.stripNoCase(arg, strip, preserve));\n                break;\n            case 'Block':\n            case 'InlineMath':\n            case 'DisplayMath':\n                if (strip && node.case === 'protect') {\n                    if (preserve) {\n                        node.case = 'preserve';\n                    }\n                    else {\n                        delete node.case;\n                    }\n                }\n                node.value.map(v => this.stripNoCase(v, strip || node.case === 'protect', preserve));\n                break;\n            case 'Field':\n                if (Array.isArray(node.value))\n                    node.value.map(v => this.stripNoCase(v, strip, preserve));\n                break;\n        }\n    }\n    isVerbatimField(name) {\n        return !!this.options.verbatimFields.find(p => (typeof p === 'string') ? name === p : name.match(p));\n    }\n    clean_field(node) {\n        this.startCleaning(node.name);\n        this.stripNoCase(node, !this.options.caseProtection || this.isVerbatimField(node.name), this.options.sentenceCase.length === 0);\n        if (Array.isArray(node.value))\n            this.condense(node);\n        return node;\n    }\n    clean_script(node) {\n        let m, value, singlechar;\n        // recognize combined forms like \\^\\circ\n        if (singlechar = unicode2latex_1.latex[node.source])\n            return this.text(singlechar);\n        if ((m = node.source.match(/^([\\^_])([^{}]+)$/)) && ((singlechar = unicode2latex_1.latex[`${m[1]}${m[2]}`]) || (singlechar = unicode2latex_1.latex[`${m[1]}{${m[2]}}`])))\n            return this.text(singlechar);\n        if ((m = node.source.match(/^([\\^_])\\{([^{}]+)\\}$/)) && ((singlechar = unicode2latex_1.latex[`${m[1]}${m[2]}`]) || (singlechar = unicode2latex_1.latex[`${m[1]}{${m[2]}}`])))\n            return this.text(singlechar);\n        const cmd = node.kind === 'SuperscriptCommand' ? '^' : '_';\n        if (typeof node.value === 'string' && (singlechar = unicode2latex_1.latex[`${cmd}${node.value}`] || unicode2latex_1.latex[`${cmd}{${node.value}}`])) {\n            return this.text(singlechar);\n        }\n        if (typeof node.value === 'string') {\n            value = [this.text(node.value)];\n        }\n        else if (!Array.isArray(node.value)) {\n            value = [node.value];\n        }\n        else {\n            value = node.value;\n        }\n        const mode = node.kind === 'SuperscriptCommand' ? 'sup' : 'sub';\n        return this.clean({\n            kind: 'Block',\n            markup: { [mode]: true },\n            value,\n        });\n    }\n    clean_environment(node) {\n        this.condense(node);\n        return node;\n    }\n    needsProtection(word) {\n        return !word.match(preserveCase.hasUpper) && word.match(preserveCase.hasLower);\n    }\n    clean_block(node) {\n        var _a;\n        this.condense(node);\n        if (this.options.caseProtection !== 'strict' && ((_a = this.cleaning) === null || _a === void 0 ? void 0 : _a.type) === 'title' && node.case === 'protect') {\n            // 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\n            let preserve = true;\n            for (const child of node.value) {\n                if (child.kind === 'Text') {\n                    const value = child.value.trim();\n                    preserve = !value.match(preserveCase.isCaseSensitive) || !value.split(/\\s+/).find(word => this.needsProtection(word));\n                }\n                else {\n                    preserve = false;\n                }\n                if (!preserve)\n                    break;\n            }\n            if (preserve)\n                node.case = 'preserve';\n        }\n        if (node.kind === 'Block') {\n            for (const [markup, on] of Object.entries(node.markup)) {\n                if (!on)\n                    delete node.markup[markup];\n            }\n        }\n        return node;\n    }\n    clean_diacritic(node) {\n        const char = node.dotless ? `\\\\${node.character}` : node.character;\n        let unicode = unicode2latex_1.latex[`\\\\${node.mark}{${char}}`]\n            || unicode2latex_1.latex[`\\\\${node.mark}${char}`]\n            || unicode2latex_1.latex[`{\\\\${node.mark} ${char}}`]\n            || unicode2latex_1.latex[`{\\\\${node.mark}${char}}`]\n            || unicode2latex_1.latex[`\\\\${node.mark} ${char}`];\n        if (!unicode && !node.dotless && node.character.length === 1 && unicode2latex_1.diacritics.tounicode[node.mark])\n            unicode = node.character + unicode2latex_1.diacritics.tounicode[node.mark];\n        if (!unicode && !this.in_preamble)\n            return this.error(new TeXError(`Unhandled \\\\${node.mark}{${char}}`, node, this.chunk), this.text());\n        return this.text(unicode);\n    }\n    clean_symbol(node) {\n        if (node.command === '\\\\')\n            return this.text('\\n');\n        return this.text(unicode2latex_1.latex[`\\\\${node.command}`] || node.command);\n    }\n    first_text_block(node) {\n        if (!node)\n            return null;\n        if (node.kind === 'Block') {\n            for (const child of node.value) {\n                switch (child.kind) {\n                    case 'Text':\n                        return child.value ? node : null;\n                    case 'Block':\n                        const candidate = this.first_text_block(child);\n                        if (candidate)\n                            return candidate;\n                        break;\n                    default:\n                        return null;\n                }\n            }\n        }\n        else {\n            return null;\n        }\n    }\n    clean_command(node) {\n        var _a;\n        let arg, unicode;\n        if (unicode = unicode2latex_1.latex[node.source])\n            return this.text(unicode);\n        switch (node.command) {\n            case 'newcommand':\n                if (((_a = node.arguments) === null || _a === void 0 ? void 0 : _a.required.length) === 2\n                    && node.arguments.required[0].kind === 'Block'\n                    && node.arguments.required[0].value.length === 1\n                    && node.arguments.required[0].value[0].kind === 'RegularCommand'\n                    && node.arguments.required[1].kind === 'Block') {\n                    this.newcommands[node.arguments.required[0].value[0].command] = node.arguments.required[1].value;\n                    return this.text();\n                }\n                // console.log('newcommand?', JSON.stringify(node, null, 2))\n                break;\n            case 'item':\n                return { kind: 'Markup', value: '<li>', source: node.source };\n            case 'frac':\n                if (arg = this.argument(node, 2)) {\n                    if (arg[0].kind === 'Text' && arg[1].kind === 'Text' && (unicode = unicode2latex_1.latex[`\\\\frac{${arg[0].value}}{${arg[1].value}}`]))\n                        return this.text(unicode);\n                    return this.clean({\n                        kind: 'Block',\n                        case: 'protect',\n                        markup: {},\n                        value: [\n                            { kind: 'Block', markup: { sup: true }, value: [arg[0]] },\n                            this.text('\\u2044'),\n                            { kind: 'Block', markup: { sub: true }, value: [arg[1]] },\n                        ],\n                    });\n                }\n                break;\n            // ignore\n            case 'vspace':\n            case 'vphantom':\n            case 'path':\n            case 'aftergroup':\n            case 'ignorespaces':\n            case 'relax':\n            case 'noopsort':\n            case 'ifdefined':\n            case 'DeclarePrefChars':\n            case 'else':\n            case 'fi':\n            case 'makeatletter':\n                return this.text();\n            case 'ElsevierGlyph':\n                if (arg = this.argument(node, 'Text')) {\n                    if (unicode = unicode2latex_1.latex[`\\\\${node.command}{${arg}}`])\n                        return this.text(unicode);\n                    return this.text(String.fromCharCode(parseInt(arg, 16)));\n                }\n                break;\n            case 'chsf':\n                if (this.argument(node, 'none'))\n                    return this.text();\n                if (arg = this.argument(node, 'Block'))\n                    return this.clean(arg);\n                break;\n            case 'bibstring':\n                if (arg = this.argument(node, 'Block'))\n                    return this.clean(arg);\n                break;\n            case 'cite':\n                if (arg = this.argument(node, 'Block'))\n                    return this.clean(arg);\n                break;\n            case 'textsuperscript':\n            case 'sp':\n                if ((arg = this.argument(node, 'Text')) && (unicode = unicode2latex_1.latex[`^{${arg}}`]))\n                    return this.text(unicode);\n                if (arg = this.argument(node, 'Block'))\n                    return this.clean(arg);\n                break;\n            case 'textsubscript':\n            case 'sb':\n                if ((arg = this.argument(node, 'Text')) && (unicode = unicode2latex_1.latex[`_{${arg}}`]))\n                    return this.text(unicode);\n                if (arg = this.argument(node, 'Block'))\n                    return this.clean(arg);\n                break;\n            case 'textsc':\n                if (arg = this.argument(node, 'Block'))\n                    return this.clean(arg);\n                break;\n            case 'enquote':\n            case 'mkbibquote':\n                if (arg = this.argument(node, 'Block'))\n                    return this.clean(arg);\n                break;\n            case 'textbf':\n            case 'mkbibbold':\n                if (arg = this.argument(node, 'Block'))\n                    return this.clean(arg);\n                break;\n            case 'section':\n            case 'subsection':\n            case 'subsubsection':\n            case 'subsubsubsection':\n                if (arg = this.argument(node, 'Block'))\n                    return this.clean(arg);\n                break;\n            case 'mkbibitalic':\n            case 'mkbibemph':\n            case 'textit':\n            case 'emph':\n                if (arg = this.argument(node, 'Block'))\n                    return this.clean(arg);\n                if (arg = this.argument(node, 'Text'))\n                    return this.clean({ kind: 'Block', markup: { italics: true }, value: [this.text(arg)] });\n                break;\n            case 'bibcyr':\n                if (this.argument(node, 'none'))\n                    return this.text();\n                if (arg = this.argument(node, 'Block'))\n                    return this.clean(arg);\n                break;\n            case 'hspace':\n            case 'mathrm':\n            case 'textrm':\n            case 'ocirc':\n            case 'mbox':\n                if (arg = this.argument(node, 'text')) {\n                    unicode = unicode2latex_1.latex[`\\\\${node.command}{${arg}}`];\n                    return this.text(unicode || (node.command === 'hspace' ? ' ' : arg));\n                }\n                else if (!node.arguments.required.length) {\n                    return this.text();\n                }\n                else if (arg = this.argument(node, 'Block')) {\n                    return this.clean(arg);\n                }\n                break;\n            // just take the URL? Not the label?\n            case 'href':\n                if (arg = this.argument(node, 2))\n                    return this.clean(arg[0]);\n                break;\n            case 'url':\n                if (arg = this.argument(node, 'Text'))\n                    return this.text(arg);\n                if (arg = this.argument(node, 'Block'))\n                    return this.clean(arg);\n                break;\n            case 'sl':\n            case 'em':\n            case 'it':\n            case 'itshape':\n            case 'bf':\n            case 'bfseries':\n            case 'sc':\n            case 'scshape':\n            case 'tt':\n            case 'rm':\n            case 'sf':\n            case 'verb':\n                // handled in the grammar\n                return this.text();\n            // wouldn't know what to do with these\n            case 'left':\n            case 'right':\n                return this.text();\n            case 'par':\n                return this.text('\\n\\n');\n            case 'cyr':\n                if (this.argument(node, 'none'))\n                    return this.text();\n                break;\n            case 'polhk':\n                if (unicode = this.argument(node, 'text')) {\n                    if (unicode.length === 1)\n                        return this.text(unicode + '\\u0328');\n                }\n                if (this.argument(node, 'none'))\n                    return this.text('\\u0328');\n                break;\n            default:\n                if (node.kind === 'RegularCommand' && this.newcommands[node.command]) {\n                    return this.clean({\n                        kind: 'Block',\n                        markup: {},\n                        value: JSON.parse(JSON.stringify(this.newcommands[node.command])),\n                    });\n                }\n                if (unicode2latex_1.diacritics.tounicode[node.command]) {\n                    node.arguments.required = this.clean(node.arguments.required);\n                    let block;\n                    if (node.arguments.required.length === 1 && node.arguments.required[0].kind === 'Text') {\n                        // no idea why I can't just straight return this but typescript just won't shut up\n                        block = {\n                            kind: 'Block',\n                            markup: {},\n                            value: [{\n                                    kind: 'DiacriticCommand',\n                                    mark: node.command,\n                                    character: node.arguments.required[0].value,\n                                    dotless: false,\n                                    loc: node.arguments.required[0].loc,\n                                    source: node.arguments.required[0].source,\n                                }],\n                        };\n                        return this.clean(block);\n                    }\n                    else if (block = this.first_text_block(node.arguments.required[0])) {\n                        let fixed = false;\n                        block.value = block.value.reduce((value, child) => {\n                            if (!fixed && child.kind === 'Text') {\n                                fixed = true;\n                                value.push({ kind: 'DiacriticCommand', mark: node.command, character: child.value[0] });\n                                value.push(Object.assign(Object.assign({}, child), { value: child.value.substring(1) }));\n                            }\n                            else {\n                                value.push(child);\n                            }\n                            return value;\n                        }, []);\n                        return this.clean({\n                            kind: 'Block',\n                            markup: {},\n                            value: node.arguments.required,\n                        });\n                    }\n                    else {\n                        // overline without arguments doesn't seem to render in LaTeX\n                        if (node.command === 'overline')\n                            return this.text(' ');\n                        return this.clean({\n                            kind: 'Block',\n                            markup: {},\n                            value: [this.text(' ' + unicode2latex_1.diacritics.tounicode[node.command])].concat(node.arguments.required),\n                        });\n                    }\n                }\n                if (unicode = unicode2latex_1.latex[node.source] || unicode2latex_1.latex[`${node.source}{}`])\n                    return this.text(unicode);\n                if ((unicode = unicode2latex_1.latex[`\\\\${node.command}`] || unicode2latex_1.latex[`\\\\${node.command}{}`]) && this.argument(node, 'none'))\n                    return this.text(unicode);\n                if ((arg = this.argument(node, 'Text')) && (unicode = unicode2latex_1.latex[`\\\\${node.command}{${arg}}`]))\n                    return this.text(unicode);\n                break;\n        }\n        if (this.in_preamble)\n            return this.text(node.source);\n        return this.error(new TeXError(`Unhandled command: ${node.command}` + this.show(node), node, this.chunk), this.text());\n    }\n    preserveCase(word) {\n        // word = word.replace(new RegExp(`\"[${this.markup.enquote.open}${this.markup.enquote.close}:()]`, 'g'), '')\n        var _a, _b;\n        if (!word.trim())\n            return false;\n        if (!word.match(preserveCase.hasAlphaNum))\n            return true;\n        word = word.replace(/[\\/’'”:()]/g, '');\n        if (word === 'I')\n            return true;\n        if (word.length === 1)\n            return false;\n        if (word.replace(preserveCase.notCaseSensitive) === '')\n            return false;\n        // word = word.replace(preserveCase.notAlphaNum, '')\n        // simple cap at start of field\n        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)\n            return false;\n        if (word.match(preserveCase.allCaps))\n            return true;\n        if (word.length > 1 && word.match(preserveCase.joined))\n            return false;\n        if (word.match(preserveCase.hasUpper))\n            return true;\n        if (word.match(preserveCase.isNumber))\n            return true;\n        return false;\n    }\n    convert(node) {\n        if (Array.isArray(node))\n            return node.map(child => this.convert(child));\n        if (this.options.raw && this.field)\n            node = this.text(node.source);\n        switch (node.kind) {\n            case 'Markup':\n                if (this.field)\n                    this.field.text += node.value;\n                break;\n            case 'BracedComment':\n            case 'LineComment':\n                this.comments.push(node.value);\n                break;\n            case 'Entry':\n                this.convert_entry(node);\n                break;\n            case 'Number':\n                this.convert_number(node);\n                break;\n            case 'Text':\n                this.convert_text(node);\n                break;\n            case 'Block':\n            case 'InlineMath':\n            case 'DisplayMath':\n                const start = this.field ? this.field.text.length : null;\n                const preserve = typeof start === 'number' && this.field.preserveRanges;\n                this.convert_block(node);\n                if (preserve && (node.case || node.kind.endsWith('Math')))\n                    this.preserve(start, this.field.text.length); // , `convert-block: case=${node.case}, math=${node.kind.endsWith('Math')}`)\n                break;\n            case 'Environment':\n                this.convert_environment(node);\n                break;\n            case 'PreambleExpression':\n                this.preamble.push(node.value.map(preamble => preamble.source).join('\\n\\n'));\n                break;\n            case 'DisplayMath':\n            case 'InlineMath':\n            case 'StringDeclaration':\n                break;\n            default:\n                return this.error(new ParserError(`no converter for ${node.kind}: ${this.show(node)}`, node), undefined);\n        }\n    }\n    splitOnce(s, sep, fromEnd = false) {\n        const split = fromEnd ? s.lastIndexOf(sep) : s.indexOf(sep);\n        return (split < 0) ? [s, ''] : [s.substr(0, split), s.substr(split + 1)];\n    }\n    parseName(name) {\n        let parsed = null;\n        const parts = name.split(marker.comma);\n        if (parts.length && !parts.find(p => !p.match(/^[a-z]+(-i)?=/i))) { // extended name format\n            for (const part of parts) {\n                parsed = parsed || {};\n                const [attr, value] = this.splitOnce(part.replace(marker.re.space, ''), '=').map(v => v.trim());\n                if (!value) {\n                    parsed = null;\n                    break;\n                }\n                switch (attr.toLowerCase()) {\n                    case 'family':\n                        parsed.lastName = value;\n                        break;\n                    case 'given-i':\n                        parsed.initial = value;\n                        break;\n                    case 'given':\n                        parsed.firstName = value;\n                        break;\n                    case 'prefix':\n                        parsed.prefix = value;\n                        break;\n                    case 'suffix':\n                        parsed.suffix = value;\n                        break;\n                    case 'useprefix':\n                        parsed.useprefix = value.toLowerCase() === 'true';\n                        break;\n                    case 'juniorcomma':\n                        parsed.useprefix = value.toLowerCase() === 'true';\n                        break;\n                    default:\n                        parsed[attr.toLowerCase()] = value;\n                        break;\n                }\n            }\n        }\n        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+(.+)/;\n        let m;\n        switch (parsed ? 0 : parts.length) {\n            case 0:\n                // already parsed\n                break;\n            case 1: // name without commas\n                // literal\n                if (marker.re.literalName.test(parts[0])) {\n                    parsed = { literal: parts[0] };\n                }\n                else if (m = parts[0].replace(marker.re.space, ' ').match(prefix)) { // split on prefix\n                    parsed = {\n                        firstName: m[1],\n                        prefix: m[2],\n                        lastName: m[3],\n                    };\n                }\n                else {\n                    // top-level \"firstname lastname\"\n                    const [firstName, lastName] = this.splitOnce(parts[0], marker.space, true);\n                    if (lastName) {\n                        parsed = { firstName, lastName };\n                    }\n                    else {\n                        parsed = { lastName: firstName };\n                    }\n                }\n                break;\n            case 2: // lastname, firstname\n                parsed = {\n                    lastName: parts[0],\n                    firstName: parts[1],\n                };\n                break;\n            default: // lastname, suffix, firstname\n                parsed = {\n                    lastName: parts[0],\n                    suffix: parts[1],\n                    firstName: parts.slice(2).join(marker.comma),\n                };\n        }\n        for (const [k, v] of Object.entries(parsed)) {\n            if (typeof v !== 'string')\n                continue;\n            parsed[k] = marker.clean(v).trim();\n        }\n        return parsed;\n    }\n    convert_entry(node) {\n        var _a;\n        this.entry = {\n            key: node.id,\n            type: node.type,\n            fields: {},\n            creators: {},\n        };\n        this.entries.push(this.entry);\n        // order these first for language-dependent sentence casing\n        const order = ['langid', 'hyphenation', 'language'];\n        node.fields.sort((a, b) => {\n            const ia = order.indexOf(a.name);\n            const ib = order.indexOf(b.name);\n            if (ia === -1 && ib === -1)\n                return a.name.localeCompare(b.name); // doesn't matter really\n            if (ia === -1)\n                return 1;\n            if (ib === -1)\n                return -1;\n            return ia - ib;\n        });\n        let sentenceCase = !!this.options.sentenceCase.length; // if sentenceCase is empty, no sentence casing\n        for (const field of node.fields) {\n            if (field.kind !== 'Field')\n                return this.error(new ParserError(`Expected Field, got ${field.kind}`, node), undefined);\n            this.startCleaning(field.name);\n            /*\n            if (this.options.raw && this.fieldType !== 'creator') {\n              this.entry.fields[field.name] = [ field.value.map(v => v.source).join('') ]\n              continue\n            }\n            */\n            this.field = {\n                name: field.name,\n                text: '',\n                level: 0,\n                words: {\n                    upper: 0,\n                    lower: 0,\n                    other: 0,\n                },\n                preserveRanges: (sentenceCase && fields.title.includes(field.name)) ? [] : null,\n                html: this.options.htmlFields.includes(field.name),\n            };\n            this.entry.fields[this.field.name] = this.entry.fields[this.field.name] || [];\n            // special case for 'title = 2020'\n            if (field.value.kind === 'Number') {\n                this.entry.fields[this.field.name].push(field.value.value);\n                this.field = null;\n                continue;\n            }\n            this.convert(field.value);\n            this.field.text = this.field.text.trim();\n            this.field.text = this.field.text.replace(/<\\/([a-z])><\\1>/g, '');\n            this.field.text = this.field.text.replace(/<([a-z])>(\\s*)<\\/\\1>/g, '$1');\n            if (!this.field.text)\n                continue;\n            // disable sentenceCasing if not an english\n            switch (this.field.name) {\n                case 'langid':\n                case 'hyphenation':\n                    sentenceCase = sentenceCase && this.options.sentenceCase.includes(this.field.text.toLowerCase());\n                    break;\n                case 'language':\n                    sentenceCase = sentenceCase && !!(this.field.text.toLowerCase().trim().split(/\\s*,\\s*/).find(lang => this.options.sentenceCase.includes(lang)));\n                    break;\n            }\n            // \"groups\" is a jabref 3.8+ monstrosity\n            if (this.field.name.match(/^(keywords?|groups)$/)) {\n                for (let text of this.field.text.split(marker.comma)) {\n                    text = text.trim();\n                    if (text)\n                        this.entry.fields[this.field.name].push(text);\n                }\n            }\n            else if (this.cleaning.type === 'creator') {\n                if (!this.entry.creators[this.field.name])\n                    this.entry.creators[this.field.name] = [];\n                // {M. Halle, J. Bresnan, and G. Miller}\n                if (this.field.text.includes(`${marker.comma}${marker.and}`)) { //\n                    this.field.text = this.field.text.replace(new RegExp(`${marker.comma}${marker.and}`, 'g'), marker.and).replace(new RegExp(marker.comma), marker.and);\n                }\n                for (const creator of this.field.text.split(marker.and)) {\n                    this.entry.fields[this.field.name].push(marker.clean(creator));\n                    this.entry.creators[this.field.name].push(this.parseName(creator));\n                }\n            }\n            else if (fields.unabbrev.includes(field.name)) { // doesn't get sentence casing anyhow TODO: booktitle does!\n                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'));\n            }\n            else {\n                if (this.field.preserveRanges) {\n                    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))) {\n                        this.preserve(null, null); // , 'mostly sentence cased already')\n                    }\n                    else {\n                        const txt = this.field.text.replace(preserveCase.markup, markup => marker.markup.repeat(markup.length));\n                        let match;\n                        preserveCase.sentenceStart.lastIndex = 0;\n                        while ((match = preserveCase.sentenceStart.exec(txt))) {\n                            // exclude stuff like \"U.S. Taxes\"\n                            if (match.index > 2 && txt.substr(0, match.index + 1).match(preserveCase.acronym))\n                                continue;\n                            this.preserve(match.index, match.index + match[0].length); // , `sentenceStart: ${match[0]} at ${match.index}..${match.index + match[0].length}`)\n                        }\n                        preserveCase.quoted.lastIndex = 0;\n                        while ((match = preserveCase.quoted.exec(this.field.text))) {\n                            this.preserve(match.index, match.index + match[0].length); // , 'quoted')\n                        }\n                    }\n                }\n                this.entry.fields[this.field.name].push(this.convertToSentenceCase(this.field.text).normalize('NFC'));\n            }\n        }\n        this.field = null;\n    }\n    convertToSentenceCase(text) {\n        if (!this.field.preserveRanges)\n            return text;\n        // always keep the leading char, but skip markup\n        const lead = text.match(/^(<[^>]+>)*./);\n        if (lead) {\n            this.preserve(lead[0].length - 1, lead[0].length);\n        }\n        else {\n            this.preserve(0, 1);\n        }\n        let sentenceCased = text.toLowerCase().replace(/(([\\?!]\\s*|^)([\\'\\\"¡¿“‘„«\\s]+)?[^\\s])/g, x => x.toUpperCase());\n        for (const { start, end } of this.field.preserveRanges) {\n            sentenceCased = sentenceCased.substring(0, start) + text.substring(start, end) + sentenceCased.substring(end);\n        }\n        if (text !== sentenceCased)\n            this.entry.sentenceCased = true;\n        return sentenceCased;\n    }\n    convert_number(node) {\n        this.field.text += `${node.value}`;\n    }\n    convert_text(node) {\n        if (node.mode === 'verbatim') {\n            this.field.text += node.value.trim();\n            return;\n        }\n        // heuristic to detect pre-sentencecased text\n        for (const word of node.value.split(/\\b/)) {\n            if (word.match(preserveCase.allLower)) {\n                this.field.words.lower++;\n            }\n            else if (word.match(preserveCase.allCaps)) {\n                this.field.words.upper++;\n            }\n            else if (word.match(preserveCase.hasAlpha)) {\n                this.field.words.other++;\n            }\n        }\n        if (this.field.level === 0 && this.cleaning.type === 'creator') {\n            this.field.text += node.value.replace(/\\s+and\\s+/ig, marker.and).replace(/\\s*,\\s*/g, marker.comma).replace(/\\s+/g, marker.space);\n            return;\n        }\n        if (this.field.level === 0 && this.field.name.match(/^(keywords?|groups)$/)) {\n            this.field.text += node.value.replace(/\\s*[;,]\\s*/g, marker.comma);\n            return;\n        }\n        if (this.field.html) {\n            this.field.text += node.value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\n        }\n        else if (this.field.preserveRanges) {\n            const words = node.value.split(/(\\s+)/);\n            for (const word of words) {\n                const start = this.field.text.length;\n                this.field.text += word;\n                if (this.preserveCase(word))\n                    this.preserve(start, this.field.text.length); // , `word: ${JSON.stringify(word)}`)\n            }\n        }\n        else {\n            this.field.text += node.value;\n        }\n    }\n    convert_environment(node) {\n        this.field.text += { enumerate: '<ol>', itemize: '<ul>' }[node.env];\n        this.convert_block(Object.assign(Object.assign({}, node), { kind: 'Block', markup: {} }));\n        this.field.text += { enumerate: '</ol>', itemize: '</ul>' }[node.env];\n    }\n    convert_block(node) {\n        const start = this.field.text.length;\n        let prefix = '';\n        let postfix = '';\n        if (this.options.caseProtection !== 'strict' && this.cleaning.type === 'other')\n            delete node.case;\n        if (this.cleaning.type === 'creator' && node.case === 'protect') {\n            prefix += marker.literal;\n            postfix = marker.literal + postfix;\n            delete node.case;\n        }\n        if (node.case === 'protect') {\n            prefix += this.options.markup.caseProtect.open;\n            postfix = this.options.markup.caseProtect.close + postfix;\n        }\n        if (node.kind === 'Block') {\n            for (const markup of Object.keys(node.markup)) {\n                if (!this.options.markup[markup])\n                    return this.error(new ParserError(`markup: ${markup}`, node), undefined);\n                prefix += this.options.markup[markup].open;\n                postfix = this.options.markup[markup].close + postfix;\n            }\n        }\n        const end = {\n            withoutPrefix: this.field.text.length,\n            withPrefix: this.field.text.length + prefix.length,\n        };\n        this.field.text += prefix;\n        this.field.level++;\n        this.convert(node.value);\n        this.field.level--;\n        const added = this.field.text.substring(end.withPrefix);\n        const added_text = added.replace(/<\\/?[^>]+>/g, '');\n        const needsProtection = added_text && ((this.options.caseProtection === 'strict' && added_text.match(preserveCase.isCaseSensitive))\n            ||\n                (this.options.caseProtection === 'as-needed' && added_text.split(/\\s+/).find(word => this.needsProtection(word))));\n        if (!added) { // nothing was added, so remove prefix\n            this.field.text = this.field.text.substring(0, end.withoutPrefix);\n        }\n        else if (this.field.preserveRanges && prefix === this.options.markup.caseProtect.open && !needsProtection) {\n            // something was added that didn't actually need case protection\n            this.field.text = this.field.text.substring(0, end.withoutPrefix) + added;\n            this.field.preserveRanges = this.field.preserveRanges.filter(range => range.start < end.withoutPrefix);\n        }\n        else {\n            this.field.text += postfix;\n        }\n        this.field.text = this.field.text.replace(/<(sup|sub)>([^<>]+)<\\/\\1>$/i, (m, mode, chars) => {\n            const cmd = mode === 'sup' ? '^' : '_';\n            let script = '';\n            for (const char of chars) {\n                const unicode = unicode2latex_1.latex[`${cmd}${char}`] || unicode2latex_1.latex[`${cmd}{${char}}`];\n                script += unicode ? unicode : `<${mode}>${char}</${mode}>`;\n            }\n            script = script.replace(new RegExp(`</${mode}><${mode}>`, 'g'), '');\n            return script.length < m.length ? script : m;\n        });\n        if (node.case && this.field.preserveRanges)\n            this.preserve(start, this.field.text.length); // , 'in convert-block ' + node.source || '<source>')\n    }\n}\n/**\n * parse bibtex. This will try to convert TeX commands into unicode equivalents, and apply `@string` expansion\n */\nfunction parse(input, options = {}) {\n    const parser = new Parser(options);\n    return parser.parse(input);\n}\nexports.parse = parse;\nfunction ast(input, options = {}, clean = true) {\n    const parser = new Parser(options);\n    return parser.ast(input, clean);\n}\nexports.ast = ast;\nvar chunker_2 = require(\"./chunker\");\nObject.defineProperty(exports, \"chunker\", { enumerable: true, get: function () { return chunker_2.parse; } });\nvar jabref_1 = require(\"./jabref\");\nObject.defineProperty(exports, \"jabref\", { enumerable: true, get: function () { return jabref_1.parse; } });\n//# sourceMappingURL=index.js.map","import * as BibTeXParser from '@retorquere/bibtex-parser';\nimport { Entry as EntryDataBibLaTeX } from '@retorquere/bibtex-parser';\n// Also make EntryDataBibLaTeX available to other modules\nexport { Entry as EntryDataBibLaTeX } from '@retorquere/bibtex-parser';\n\n// Trick: allow string indexing onto object properties\nexport interface IIndexable {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [key: string]: any;\n}\n\nconst databaseTypes = ['csl-json', 'biblatex'] as const;\nexport type DatabaseType = typeof databaseTypes[number];\n\nexport const TEMPLATE_VARIABLES = {\n  citekey: 'Unique citekey',\n  abstract: '',\n  authorString: 'Comma-separated list of author names',\n  containerTitle:\n    'Title of the container holding the reference (e.g. book title for a book chapter, or the journal title for a journal article)',\n  DOI: '',\n  eprint: '',\n  eprinttype: '',\n  eventPlace: 'Location of event',\n  note: '',\n  page: 'Page or page range',\n  publisher: '',\n  publisherPlace: 'Location of publisher',\n  title: '',\n  titleShort: '',\n  URL: '',\n  year: 'Publication year',\n  zoteroSelectURI: 'URI to open the reference in Zotero',\n};\n\nexport class Library {\n  constructor(public entries: { [citekey: string]: Entry }) {}\n\n  get size(): number {\n    return Object.keys(this.entries).length;\n  }\n\n  /**\n   * For the given citekey, find the corresponding `Entry` and return a\n   * collection of template variable assignments.\n   */\n  getTemplateVariablesForCitekey(citekey: string): Record<string, any> {\n    const entry: Entry = this.entries[citekey];\n    const shortcuts = {\n      citekey: citekey,\n\n      abstract: entry.abstract,\n      authorString: entry.authorString,\n      containerTitle: entry.containerTitle,\n      DOI: entry.DOI,\n      eprint: entry.eprint,\n      eprinttype: entry.eprinttype,\n      eventPlace: entry.eventPlace,\n      note: entry.note,\n      page: entry.page,\n      publisher: entry.publisher,\n      publisherPlace: entry.publisherPlace,\n      title: entry.title,\n      titleShort: entry.titleShort,\n      URL: entry.URL,\n      year: entry.year?.toString(),\n      zoteroSelectURI: entry.zoteroSelectURI,\n    };\n\n    return { entry: entry.toJSON(), ...shortcuts };\n  }\n}\n\n/**\n * Load reference entries from the given raw database data.\n *\n * Returns a list of `EntryData`, which should be wrapped with the relevant\n * adapter and used to instantiate a `Library`.\n */\nexport function loadEntries(\n  databaseRaw: string,\n  databaseType: DatabaseType,\n): EntryData[] {\n  let libraryArray: EntryData[];\n\n  if (databaseType == 'csl-json') {\n    libraryArray = JSON.parse(databaseRaw);\n  } else if (databaseType == 'biblatex') {\n    const options: BibTeXParser.ParserOptions = {\n      errorHandler: (err) => {\n        console.warn(\n          'Citation plugin: non-fatal error loading BibLaTeX entry:',\n          err,\n        );\n      },\n    };\n\n    const parsed = BibTeXParser.parse(\n      databaseRaw,\n      options,\n    ) as BibTeXParser.Bibliography;\n\n    parsed.errors.forEach((error) => {\n      console.error(\n        `Citation plugin: fatal error loading BibLaTeX entry` +\n          ` (line ${error.line}, column ${error.column}):`,\n        error.message,\n      );\n    });\n\n    libraryArray = parsed.entries;\n  }\n\n  return libraryArray;\n}\n\nexport interface Author {\n  given?: string;\n  family?: string;\n}\n\n/**\n * An `Entry` represents a single reference in a reference database.\n * Each entry has a unique identifier, known in most reference managers as its\n * \"citekey.\"\n */\nexport abstract class Entry {\n  /**\n   * Unique identifier for the entry (also the citekey).\n   */\n  public abstract id: string;\n\n  public abstract type: string;\n\n  public abstract abstract?: string;\n  public abstract author?: Author[];\n\n  /**\n   * A comma-separated list of authors, each of the format `<firstname> <lastname>`.\n   */\n  public abstract authorString?: string;\n\n  /**\n   * The name of the container for this reference -- in the case of a book\n   * chapter reference, the name of the book; in the case of a journal article,\n   * the name of the journal.\n   */\n  public abstract containerTitle?: string;\n\n  public abstract DOI?: string;\n  public abstract files?: string[];\n\n  /**\n   * The date of issue. Many references do not contain information about month\n   * and day of issue; in this case, the `issuedDate` will contain dummy minimum\n   * values for those elements. (A reference which is only encoded as being\n   * issued in 2001 is represented here with a date 2001-01-01 00:00:00 UTC.)\n   */\n  public abstract issuedDate?: Date;\n\n  /**\n   * Page or page range of the reference.\n   */\n  public abstract page?: string;\n  public abstract title?: string;\n  public abstract titleShort?: string;\n  public abstract URL?: string;\n\n  public abstract eventPlace?: string;\n\n  public abstract publisher?: string;\n  public abstract publisherPlace?: string;\n\n  /**\n   * BibLaTeX-specific properties\n   */\n  public abstract eprint?: string;\n  public abstract eprinttype?: string;\n\n  protected _year?: string;\n  public get year(): number {\n    return this._year\n      ? parseInt(this._year)\n      : this.issuedDate?.getUTCFullYear();\n  }\n\n  protected _note?: string[];\n\n  public get note(): string {\n    return this._note\n      ?.map((el) => el.replace(/(zotero:\\/\\/.+)/g, '[Link]($1)'))\n      .join('\\n\\n');\n  }\n\n  /**\n   * A URI which will open the relevant entry in the Zotero client.\n   */\n  public get zoteroSelectURI(): string {\n    return `zotero://select/items/@${this.id}`;\n  }\n\n  toJSON(): Record<string, unknown> {\n    const jsonObj: Record<string, unknown> = Object.assign({}, this);\n\n    // add getter values\n    const proto = Object.getPrototypeOf(this);\n    Object.entries(Object.getOwnPropertyDescriptors(proto))\n      .filter(([, descriptor]) => typeof descriptor.get == 'function')\n      .forEach(([key, descriptor]) => {\n        if (descriptor && key[0] !== '_') {\n          try {\n            const val = (this as IIndexable)[key];\n            jsonObj[key] = val;\n          } catch (error) {\n            return;\n          }\n        }\n      });\n\n    return jsonObj;\n  }\n}\n\nexport type EntryData = EntryDataCSL | EntryDataBibLaTeX;\n\nexport interface EntryDataCSL {\n  id: string;\n  type: string;\n\n  abstract?: string;\n  author?: Author[];\n  'container-title'?: string;\n  DOI?: string;\n  'event-place'?: string;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  issued?: { 'date-parts': [any[]] };\n  page?: string;\n  publisher?: string;\n  'publisher-place'?: string;\n  title?: string;\n  'title-short'?: string;\n  URL?: string;\n}\n\nexport class EntryCSLAdapter extends Entry {\n  constructor(private data: EntryDataCSL) {\n    super();\n  }\n\n  eprint: string = null;\n  eprinttype: string = null;\n  files: string[] = null;\n\n  get id() {\n    return this.data.id;\n  }\n  get type() {\n    return this.data.type;\n  }\n\n  get abstract() {\n    return this.data.abstract;\n  }\n  get author() {\n    return this.data.author;\n  }\n\n  get authorString(): string | null {\n    return this.data.author\n      ? this.data.author.map((a) => `${a.given} ${a.family}`).join(', ')\n      : null;\n  }\n\n  get containerTitle() {\n    return this.data['container-title'];\n  }\n\n  get DOI() {\n    return this.data.DOI;\n  }\n\n  get eventPlace() {\n    return this.data['event-place'];\n  }\n\n  get issuedDate() {\n    if (\n      !(\n        this.data.issued &&\n        this.data.issued['date-parts'] &&\n        this.data.issued['date-parts'][0].length > 0\n      )\n    )\n      return null;\n\n    const [year, month, day] = this.data.issued['date-parts'][0];\n    return new Date(Date.UTC(year, (month || 1) - 1, day || 1));\n  }\n\n  get page() {\n    return this.data.page;\n  }\n\n  get publisher() {\n    return this.data.publisher;\n  }\n\n  get publisherPlace() {\n    return this.data['publisher-place'];\n  }\n\n  get title() {\n    return this.data.title;\n  }\n\n  get titleShort() {\n    return this.data['title-short'];\n  }\n\n  get URL() {\n    return this.data.URL;\n  }\n}\n\nconst BIBLATEX_PROPERTY_MAPPING: Record<string, string> = {\n  abstract: 'abstract',\n  booktitle: '_containerTitle',\n  date: 'issued',\n  doi: 'DOI',\n  eprint: 'eprint',\n  eprinttype: 'eprinttype',\n  eventtitle: 'event',\n  journal: '_containerTitle',\n  journaltitle: '_containerTitle',\n  location: 'publisherPlace',\n  pages: 'page',\n  shortjournal: 'containerTitleShort',\n  title: 'title',\n  shorttitle: 'titleShort',\n  url: 'URL',\n  venue: 'eventPlace',\n  year: '_year',\n  publisher: 'publisher',\n  note: '_note',\n};\n\n// BibLaTeX parser returns arrays of property values (allowing for repeated\n// property entries). For the following fields, just blindly take the first.\nconst BIBLATEX_PROPERTY_TAKE_FIRST: string[] = [\n  'abstract',\n  'booktitle',\n  '_containerTitle',\n  'date',\n  'doi',\n  'eprint',\n  'eprinttype',\n  'eventtitle',\n  'journaltitle',\n  'location',\n  'pages',\n  'shortjournal',\n  'title',\n  'shorttitle',\n  'url',\n  'venue',\n  '_year',\n  'publisher',\n];\n\nexport class EntryBibLaTeXAdapter extends Entry {\n  abstract?: string;\n  _containerTitle?: string;\n  containerTitleShort?: string;\n  DOI?: string;\n  eprint?: string;\n  eprinttype?: string;\n  event?: string;\n  eventPlace?: string;\n  issued?: string;\n  page?: string;\n  publisher?: string;\n  publisherPlace?: string;\n  title?: string;\n  titleShort?: string;\n  URL?: string;\n  _year?: string;\n  _note?: string[];\n\n  constructor(private data: EntryDataBibLaTeX) {\n    super();\n\n    Object.entries(BIBLATEX_PROPERTY_MAPPING).forEach(\n      (map: [string, string]) => {\n        const [src, tgt] = map;\n        if (src in this.data.fields) {\n          let val = this.data.fields[src];\n          if (BIBLATEX_PROPERTY_TAKE_FIRST.includes(src)) {\n            val = (val as any[])[0];\n          }\n\n          (this as IIndexable)[tgt] = val;\n        }\n      },\n    );\n  }\n\n  get id() {\n    return this.data.key;\n  }\n  get type() {\n    return this.data.type;\n  }\n\n  get files(): string[] {\n    // For some reason the bibtex parser doesn't reliably parse file list to\n    // array ; so we'll do it manually / redundantly\n    let ret: string[] = [];\n    if (this.data.fields.file) {\n      ret = ret.concat(this.data.fields.file.flatMap((x) => x.split(';')));\n    }\n    if (this.data.fields.files) {\n      ret = ret.concat(this.data.fields.files.flatMap((x) => x.split(';')));\n    }\n\n    return ret;\n  }\n\n  get authorString() {\n    if (this.data.creators.author) {\n      const names = this.data.creators.author.map((name) => {\n        if (name.literal) return name.literal;\n        const parts = [name.firstName, name.prefix, name.lastName, name.suffix];\n        // Drop any null parts and join\n        return parts.filter((x) => x).join(' ');\n      });\n      return names.join(', ');\n    } else {\n      return this.data.fields.author?.join(', ');\n    }\n  }\n\n  get containerTitle() {\n    if (this._containerTitle) {\n      return this._containerTitle;\n    } else if (this.data.fields.eprint) {\n      const prefix = this.data.fields.eprinttype\n        ? `${this.data.fields.eprinttype}:`\n        : '';\n      const suffix = this.data.fields.primaryclass\n        ? ` [${this.data.fields.primaryclass}]`\n        : '';\n      return `${prefix}${this.data.fields.eprint}${suffix}`;\n    }\n  }\n\n  get issuedDate() {\n    return this.issued ? new Date(this.issued) : null;\n  }\n\n  get author(): Author[] {\n    return this.data.creators.author?.map((a) => ({\n      given: a.firstName,\n      family: a.lastName,\n    }));\n  }\n}\n","import registerPromiseWorker from 'promise-worker/register';\n\nimport { DatabaseType, EntryData, loadEntries } from './types';\n\nregisterPromiseWorker(\n  (msg: { databaseRaw: string; databaseType: DatabaseType }): EntryData[] => {\n    return loadEntries(msg.databaseRaw, msg.databaseType);\n  },\n);\n"],"names":["charCategories","chunker_1","bibtex","unicode2latex_1","jabref_1","BibTeXParser.parse","registerPromiseWorker"],"mappings":"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AAO,CAAC,CAAC;EACpD,CAAC;EACD,aAAa,GAAG,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}'); +/* 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 */ \ No newline at end of file diff --git a/.obsidian/plugins/obsidian-citation-plugin/manifest.json b/.obsidian/plugins/obsidian-citation-plugin/manifest.json new file mode 100644 index 0000000..caaf297 --- /dev/null +++ b/.obsidian/plugins/obsidian-citation-plugin/manifest.json @@ -0,0 +1,10 @@ +{ + "id": "obsidian-citation-plugin", + "name": "Citations", + "version": "0.4.5", + "minAppVersion": "0.9.20", + "description": "Automatically search and insert citations from a Zotero library", + "author": "Jon Gauthier", + "authorUrl": "http://foldl.me", + "isDesktopOnly": true +} diff --git a/.obsidian/plugins/obsidian-citation-plugin/styles.css b/.obsidian/plugins/obsidian-citation-plugin/styles.css new file mode 100644 index 0000000..729a0d1 --- /dev/null +++ b/.obsidian/plugins/obsidian-citation-plugin/styles.css @@ -0,0 +1,114 @@ +/** Citations modal **/ + +/* + * Loading animation from + * https://loading.io/css/ + */ + .zoteroModalLoading { + color: var(--text-muted); + text-align: center; + } +.zoteroModalLoadingAnimation { + display: inline-block; + width: 80px; + height: 80px; +} +.zoteroModalLoadingAnimation { + content: " "; + display: block; + width: 32px; + height: 32px; + margin: 10px auto; + border-radius: 50%; + border: 3px solid #eee; + border-color: #eee transparent #eee transparent; + animation: lds-dual-ring 1.2s linear infinite; +} +@keyframes lds-dual-ring { + 0% { + transform: rotate(0deg); + } + 100% { + transform: rotate(360deg); + } +} + +#zoteroSettingTab .text-monospace { + font-family: monospace; +} + +.zoteroModalResults .suggestion-item { + height: fit-content; + line-height: 1.5rem; +} + +.zoteroTitle { + font-size: 14px; + display: block; +} +.zoteroAuthors { + color: #555; + font-size: 13px; +} +.zoteroAuthorsEmpty::after { + font-style: italic; + content: 'Unknown authors'; +} +.zoteroCitekey { + color: #555; + font-size: 13px; + font-family: monospace; + display: inline-block; + margin-right: 5px; + padding-right: 5px; + border-right: 1px solid #ccc; +} + +.theme-dark .zoteroTitle { + font-size: 14px; + display: block; +} +.theme-dark .zoteroAuthors { + color: #aaa; + font-size: 13px; +} +.theme-dark .zoteroCitekey { + color: #aaa; + font-size: 13px; + font-family: monospace; + display: inline-block; + margin-right: 5px; + padding-right: 5px; + border-right: 1px solid #aaa; +} + +/** Settings dialog **/ +.d-none { + display: none; +} +.zoteroSettingCitationPathLoading, +.zoteroSettingCitationPathError, +.zoteroSettingCitationPathSuccess { + font-size: 14px; +} +.zoteroSettingCitationPathLoading { + color: var(--text-muted); +} +.zoteroSettingCitationPathError { + color: var(--text-error); +} +.zoteroSettingCitationPathError:hover { + color: var(--text-error-hover); +} +.zoteroSettingCitationPathSuccess { + color: var(--text-accent); +} +.zoteroSettingCitationPathSuccess:hover { + color: var(--text-accent-hover); +} + +#zoteroSettingTab textarea { + resize: vertical; + width: 100%; + min-height: 10em; +} diff --git a/bibliography.bib b/bibliography.bib new file mode 100644 index 0000000..0f34ac0 --- /dev/null +++ b/bibliography.bib @@ -0,0 +1,358 @@ +@article{assaad_2020_predicting-project, + title = {Predicting {{Project Performance}} in the {{Construction Industry}}}, + author = {Assaad, Rayan and El-Adaway, Islam H. and Abotaleb, Ibrahim S.}, + date = {2020-05}, + journaltitle = {Journal of Construction Engineering and Management}, + shortjournal = {J. Constr. Eng. Manage.}, + volume = {146}, + number = {5}, + pages = {04020030}, + issn = {0733-9364, 1943-7862}, + doi = {10.1061/(ASCE)CO.1943-7862.0001797}, + url = {https://ascelibrary.org/doi/10.1061/%28ASCE%29CO.1943-7862.0001797}, + urldate = {2026-05-31}, + langid = {english} +} + +@article{boehm_1996_expected-wire, + title = {Expected {{Wire Length Between Two Randomly Chosen Terminals}} ({{David M}}. {{Lazoff}})}, + author = {Boehm, W. and Grosjean, Carl C. and Meyer, W. Weston and Lazoff, David M.}, + date = {1996-06}, + journaltitle = {SIAM Review}, + shortjournal = {SIAM Rev.}, + volume = {38}, + number = {2}, + pages = {321--324}, + issn = {0036-1445, 1095-7200}, + doi = {10.1137/1038053}, + url = {http://epubs.siam.org/doi/10.1137/1038053}, + urldate = {2026-05-31}, + langid = {english} +} + +@article{borel__solution-dally, + title = {Solution by {{D}}. {{J}}. {{DALLY}} ({{Australian National University}}, {{Canberra}},}, + author = {Borel, E}, + langid = {english} +} + +@article{burgstaller_2009_average-distance, + title = {The {{Average Distance Between Two Points}}}, + author = {Burgstaller, Bernhard and Pillichshammer, Friedrich}, + date = {2009}, + journaltitle = {Bulletin of the Australian Mathematical Society}, + doi = {10.1017/S0004972709000707}, + url = {https://sci-hub.st/10.1017/S0004972709000707}, + urldate = {2026-05-31} +} + +@article{carr_2005_investigation-bid, + title = {Investigation of {{Bid Price Competition Measured Through Prebid Project Estimates}}, {{Actual Bid Prices}}, and {{Number}} of {{Bidders}}}, + author = {Carr, Paul G.}, + date = {2005-11}, + journaltitle = {Journal of Construction Engineering and Management}, + shortjournal = {J. Constr. Eng. Manage.}, + volume = {131}, + number = {11}, + pages = {1165--1172}, + issn = {0733-9364, 1943-7862}, + doi = {10.1061/(ASCE)0733-9364(2005)131:11(1165)}, + url = {https://ascelibrary.org/doi/10.1061/%28ASCE%290733-9364%282005%29131%3A11%281165%29}, + urldate = {2026-05-31}, + langid = {english} +} + +@article{elbashbishy_2026_assessing-criticality, + title = {Assessing the {{Criticality}} of {{Construction Trades}}: {{Skilled Labor Shortages}} and {{Their Cost}} and {{Schedule Impacts}}}, + shorttitle = {Assessing the {{Criticality}} of {{Construction Trades}}}, + author = {Elbashbishy, Tamima and El-adaway, Islam H.}, + date = {2026-01}, + journaltitle = {Journal of Construction Engineering and Management}, + shortjournal = {J. Constr. Eng. Manage.}, + volume = {152}, + number = {1}, + pages = {04025230}, + issn = {0733-9364, 1943-7862}, + doi = {10.1061/JCEMD4.COENG-16261}, + url = {https://ascelibrary.org/doi/10.1061/JCEMD4.COENG-16261}, + urldate = {2026-05-31}, + langid = {english} +} + +@article{gabai_2026_doubling-throughput, + title = {Doubling {{Throughput}} and {{Halving Project Durations}}: {{Lessons}} from {{Intel}}’s {{OCF Strategy}} for {{Project Portfolio Management}}}, + shorttitle = {Doubling {{Throughput}} and {{Halving Project Durations}}}, + author = {Gabai, Doron S. and Haronian, Eran and Sacks, Rafael and Kennard, Nikita S. and Wong, Nicah and Miera, Mark K. and Cloyd, Tabitha D.}, + date = {2026-02}, + journaltitle = {Journal of Construction Engineering and Management}, + shortjournal = {J. Constr. Eng. Manage.}, + volume = {152}, + number = {2}, + pages = {04025256}, + issn = {0733-9364, 1943-7862}, + doi = {10.1061/JCEMD4.COENG-16441}, + url = {https://ascelibrary.org/doi/10.1061/JCEMD4.COENG-16441}, + urldate = {2026-05-31}, + langid = {english} +} + +@article{gaboune_1993_expected-distances, + title = {Expected {{Distances}} between {{Two Uniformly Distributed Random Points}} in {{Rectangles}} and {{Rectangular Parallelpipeds}}}, + author = {Gaboune, Brahim and Laporte, Gilbert and Soumis, François}, + date = {1993-05}, + journaltitle = {Journal of the Operational Research Society}, + shortjournal = {Journal of the Operational Research Society}, + volume = {44}, + number = {5}, + pages = {513--519}, + issn = {0160-5682, 1476-9360}, + doi = {10.1057/jors.1993.87}, + url = {https://www.tandfonline.com/doi/full/10.1057/jors.1993.87}, + urldate = {2026-05-31}, + langid = {english} +} + +@article{hanna_2002_benchmarking-productivity, + title = {Benchmarking {{Productivity Indicators}} for {{Electrical}}/{{Mechanical Projects}}}, + author = {Hanna, Awad S. and Peterson, Pehr and Lee, Min-Jae}, + date = {2002}, + journaltitle = {Journal of Construction Engineering and Management}, + volume = {128}, + number = {4}, + pages = {331--337}, + doi = {10.1061/(ASCE)0733-9364(2002)128:4(331)}, + url = {https://sci-hub.st/10.1061/(ASCE)0733-9364(2002)128:4(331)}, + urldate = {2026-05-31} +} + +@article{hanna_2005_factors-affecting, + title = {Factors {{Affecting Absenteeism}} in {{Electrical Construction}}}, + author = {Hanna, Awad S. and Menches, Cindy L. and Sullivan, Kenneth T. and Sargent, Joseph R.}, + date = {2005-11}, + journaltitle = {Journal of Construction Engineering and Management}, + shortjournal = {J. Constr. Eng. Manage.}, + volume = {131}, + number = {11}, + pages = {1212--1218}, + issn = {0733-9364, 1943-7862}, + doi = {10.1061/(ASCE)0733-9364(2005)131:11(1212)}, + url = {https://ascelibrary.org/doi/10.1061/%28ASCE%290733-9364%282005%29131%3A11%281212%29}, + urldate = {2026-05-31}, + langid = {english} +} + +@article{hanna_2017_quantifying-modeling, + title = {Quantifying and {{Modeling}} the {{Cumulative Impact}} of {{Change Orders}}}, + author = {Hanna, Awad S. and Iskandar, Karim A.}, + date = {2017-10}, + journaltitle = {Journal of Construction Engineering and Management}, + shortjournal = {J. Constr. Eng. Manage.}, + volume = {143}, + number = {10}, + pages = {04017076}, + issn = {0733-9364, 1943-7862}, + doi = {10.1061/(ASCE)CO.1943-7862.0001385}, + url = {https://ascelibrary.org/doi/10.1061/%28ASCE%29CO.1943-7862.0001385}, + urldate = {2026-05-31}, + langid = {english} +} + +@article{jafari_2026_critical-review, + title = {A {{Critical Review}} of the {{Data-Driven Cost Estimation Approach}} in {{Construction Research}}}, + author = {Jafari, Milad and Mousavi, Ehsan}, + date = {2026-02}, + journaltitle = {Journal of Construction Engineering and Management}, + shortjournal = {J. Constr. Eng. Manage.}, + volume = {152}, + number = {2}, + pages = {03125013}, + issn = {0733-9364, 1943-7862}, + doi = {10.1061/JCEMD4.COENG-16840}, + url = {https://ascelibrary.org/doi/10.1061/JCEMD4.COENG-16840}, + urldate = {2026-05-31}, + langid = {english} +} + +@inproceedings{jalloul_2022_pop-databased, + title = {{{POP}}: {{A Data-Based Construction Project Overall Performance Model}}}, + shorttitle = {{{POP}}}, + booktitle = {Construction {{Research Congress}} 2022}, + author = {Jalloul, Hiba and Hanna, Awad S. and Lotfallah, Wafik}, + date = {2022-03-07}, + pages = {734--743}, + publisher = {American Society of Civil Engineers}, + location = {Arlington, Virginia}, + doi = {10.1061/9780784483978.075}, + url = {https://ascelibrary.org/doi/10.1061/9780784483978.075}, + urldate = {2026-05-31}, + eventtitle = {Construction {{Research Congress}} 2022}, + isbn = {978-0-7844-8397-8}, + langid = {english} +} + +@article{kim_2026_incentive-scheme, + title = {An {{Incentive Scheme}} in {{GMP Contracts Using}} a {{Game Theory Approach}}}, + author = {Kim, Yong-Woo and Rhee, Byong-Duk}, + date = {2026-04}, + journaltitle = {Journal of Construction Engineering and Management}, + shortjournal = {J. Constr. Eng. Manage.}, + volume = {152}, + number = {4}, + pages = {04026016}, + issn = {0733-9364, 1943-7862}, + doi = {10.1061/JCEMD4.COENG-17037}, + url = {https://ascelibrary.org/doi/10.1061/JCEMD4.COENG-17037}, + urldate = {2026-05-31}, + langid = {english} +} + +@misc{lazoff__exact-formula, + title = {Exact {{Formula}} for the {{Expected Wire Length Between Two Randomly Chosen Terminals}}}, + author = {Lazoff, David M. and Sherman, Alan T.} +} + +@article{leon_2018_system-dynamics, + title = {System {{Dynamics Approach}} for {{Forecasting Performance}} of {{Construction Projects}}}, + author = {Leon, Hany and Osman, Hesham and Georgy, Maged and Elsaid, Moheeb}, + date = {2018-01}, + journaltitle = {Journal of Management in Engineering}, + shortjournal = {J. Manage. Eng.}, + volume = {34}, + number = {1}, + pages = {04017049}, + issn = {0742-597X, 1943-5479}, + doi = {10.1061/(ASCE)ME.1943-5479.0000575}, + url = {https://ascelibrary.org/doi/10.1061/%28ASCE%29ME.1943-5479.0000575}, + urldate = {2026-05-31}, + langid = {english} +} + +@article{lim_2026_improving-mental, + title = {Improving {{Mental Wellbeing}} of {{Project Supervisors}}: {{Shifting}} from {{Project-Focused}} to {{Process-Focused Construction Practices}}}, + shorttitle = {Improving {{Mental Wellbeing}} of {{Project Supervisors}}}, + author = {Lim, Huey Wen and Ma, Xiao}, + date = {2026-01}, + journaltitle = {Journal of Construction Engineering and Management}, + shortjournal = {J. Constr. Eng. Manage.}, + volume = {152}, + number = {1}, + pages = {04025229}, + issn = {0733-9364, 1943-7862}, + doi = {10.1061/JCEMD4.COENG-16521}, + url = {https://ascelibrary.org/doi/10.1061/JCEMD4.COENG-16521}, + urldate = {2026-05-31}, + langid = {english} +} + +@article{love_2026_quantifying-costs, + title = {Quantifying the {{Costs}} of {{Field Rework}} in {{Construction}}}, + author = {Love, Peter E. D.}, + date = {2026-01}, + journaltitle = {Journal of Construction Engineering and Management}, + shortjournal = {J. Constr. Eng. Manage.}, + volume = {152}, + number = {1}, + pages = {06025003}, + issn = {0733-9364, 1943-7862}, + doi = {10.1061/JCEMD4.COENG-17026}, + url = {https://ascelibrary.org/doi/10.1061/JCEMD4.COENG-17026}, + urldate = {2026-05-31}, + langid = {english} +} + +@article{mathai_1999_random-points, + title = {Random Points Associated with Rectangles}, + author = {Mathai, A. M. and Moschopoulos, P. and Pederzoli, G.}, + date = {1999-02}, + journaltitle = {Rendiconti del Circolo Matematico di Palermo}, + shortjournal = {Rend. Circ. Mat. Palermo}, + volume = {48}, + number = {1}, + pages = {163--190}, + issn = {0009-725X, 1973-4409}, + doi = {10.1007/BF02844387}, + url = {http://link.springer.com/10.1007/BF02844387}, + urldate = {2026-05-31}, + langid = {english} +} + +@inproceedings{naguib_2022_integrated-framework, + title = {An {{Integrated Framework}} to {{Quantify}} the {{Impact}} of {{Competency Factors}} on {{Project Performance}}}, + booktitle = {Construction {{Research Congress}} 2022}, + author = {Naguib, Mina and Eldamnhoury, Ebrahim S. and Hanna, Awad S. and Lotfallah, Wafik}, + date = {2022-03-07}, + pages = {863--873}, + publisher = {American Society of Civil Engineers}, + location = {Arlington, Virginia}, + doi = {10.1061/9780784483978.088}, + url = {https://ascelibrary.org/doi/10.1061/9780784483978.088}, + urldate = {2026-05-31}, + eventtitle = {Construction {{Research Congress}} 2022}, + isbn = {978-0-7844-8397-8}, + langid = {english} +} + +@article{ning_2025_prediction-construction, + title = {Prediction of {{Construction Material Prices Based}} on the {{Sliding Window CatBoost Model}}}, + author = {Ning, Xin and Shan, Ming and Li, Zhengfang and Nie, Zhihong}, + date = {2025-12}, + journaltitle = {Journal of Construction Engineering and Management}, + shortjournal = {J. Constr. Eng. Manage.}, + volume = {151}, + number = {12}, + pages = {04025196}, + issn = {0733-9364, 1943-7862}, + doi = {10.1061/JCEMD4.COENG-16748}, + url = {https://ascelibrary.org/doi/10.1061/JCEMD4.COENG-16748}, + urldate = {2026-05-31}, + langid = {english} +} + +@article{seppanen_2025_integrated-forecasting, + title = {Integrated {{Forecasting Approach}} for {{Takt}} and {{Location-Based Scheduling}}}, + author = {Seppänen, Olli}, + date = {2025-12}, + journaltitle = {Journal of Construction Engineering and Management}, + shortjournal = {J. Constr. Eng. Manage.}, + volume = {151}, + number = {12}, + pages = {04025199}, + issn = {0733-9364, 1943-7862}, + doi = {10.1061/JCEMD4.COENG-16877}, + url = {https://ascelibrary.org/doi/10.1061/JCEMD4.COENG-16877}, + urldate = {2026-05-31}, + langid = {english} +} + +@article{vaughan_1984_approximate-formulas, + title = {Approximate {{Formulas}} for {{Average Distances Associated}} with {{Zones}}}, + author = {Vaughan, Rodney}, + date = {1984-08}, + journaltitle = {Transportation Science}, + shortjournal = {Transportation Science}, + volume = {18}, + number = {3}, + pages = {231--244}, + issn = {0041-1655, 1526-5447}, + doi = {10.1287/trsc.18.3.231}, + url = {https://pubsonline.informs.org/doi/10.1287/trsc.18.3.231}, + urldate = {2026-05-31}, + abstract = {This paper develops formulas for estimating average distances associated with zones. The average distance between two points, one located at random in a zone and another located at random in another, is first investigated. The average distance from a fixed point to a point located at random in a zone, and the average distance between two points located at random in the same zone, are also examined. The accuracy of the approximations for these average distances are found by examining some simple cases.}, + langid = {english} +} + +@article{yucel_2026_startup-engagement, + title = {Startup {{Engagement}} and {{Innovation Strategies}} in {{Mid-}} to {{Large-Sized US Construction Firms}}}, + author = {Yucel, Busra and Azhar, Salman}, + date = {2026-04}, + journaltitle = {Journal of Construction Engineering and Management}, + shortjournal = {J. Constr. Eng. Manage.}, + volume = {152}, + number = {4}, + pages = {04026021}, + issn = {0733-9364, 1943-7862}, + doi = {10.1061/JCEMD4.COENG-17932}, + url = {https://ascelibrary.org/doi/10.1061/JCEMD4.COENG-17932}, + urldate = {2026-05-31}, + langid = {english} +} diff --git a/timestamped/2026-06-01_23-33-13.md b/timestamped/2026-06-01_23-33-13.md new file mode 100644 index 0000000..a589c20 --- /dev/null +++ b/timestamped/2026-06-01_23-33-13.md @@ -0,0 +1,17 @@ +--- +id: 2026-06-01T23:33:13-0400 +title: 2026-06-01 23:33:13 +tags: [] +daily: "[[2026-06-01]]" +--- +# 2026-06-01 23:33:13 + +## Stims + +1. thumb proximal along the side of the ring or middle opposite the thumb. + +2. tracing circles around the thumbnail with the tip of the index + +3. scratching one palm between the metacarpals with the opposite hand + +4. pad of the thumb in circles around the pads of the index and middle